@barefootjs/test 0.1.3 → 0.3.0

package/dist/index.js

@@ -187288,10 +187288,10 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 });
 
 // ../jsx/src/analyzer.ts
-var import_typescript6 = __toESM(require_typescript(), 1);
+var import_typescript7 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/prop-rewrite.ts
-var import_typescript3 = __toESM(require_typescript(), 1);
+var import_typescript4 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/utils.ts
 var import_typescript2 = __toESM(require_typescript(), 1);
@@ -187396,27 +187396,182 @@ function applyReplacement(slice, re, replacement) {
   re.lastIndex = 0;
   return typeof replacement === "string" ? slice.replace(re, replacement) : slice.replace(re, replacement);
 }
+// ../shared/src/dom-prop.ts
+var BOOLEAN_ATTRS = new Set([
+  "checked",
+  "disabled",
+  "readonly",
+  "selected",
+  "required",
+  "hidden",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "loop",
+  "muted",
+  "open",
+  "multiple",
+  "novalidate",
+  "formnovalidate"
+]);
+var SVG_XML_CAMEL_ATTRS = new Set([
+  "allowReorder",
+  "attributeName",
+  "attributeType",
+  "autoReverse",
+  "baseFrequency",
+  "baseProfile",
+  "calcMode",
+  "clipPathUnits",
+  "contentScriptType",
+  "contentStyleType",
+  "diffuseConstant",
+  "edgeMode",
+  "externalResourcesRequired",
+  "filterRes",
+  "filterUnits",
+  "glyphRef",
+  "gradientTransform",
+  "gradientUnits",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keyPoints",
+  "keySplines",
+  "keyTimes",
+  "lengthAdjust",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerUnits",
+  "markerWidth",
+  "maskContentUnits",
+  "maskUnits",
+  "numOctaves",
+  "pathLength",
+  "patternContentUnits",
+  "patternTransform",
+  "patternUnits",
+  "pointsAtX",
+  "pointsAtY",
+  "pointsAtZ",
+  "preserveAlpha",
+  "preserveAspectRatio",
+  "primitiveUnits",
+  "refX",
+  "refY",
+  "repeatCount",
+  "repeatDur",
+  "requiredExtensions",
+  "requiredFeatures",
+  "specularConstant",
+  "specularExponent",
+  "spreadMethod",
+  "startOffset",
+  "stdDeviation",
+  "stitchTiles",
+  "surfaceScale",
+  "systemLanguage",
+  "tableValues",
+  "targetX",
+  "targetY",
+  "textLength",
+  "viewBox",
+  "viewTarget",
+  "xChannelSelector",
+  "yChannelSelector",
+  "zoomAndPan"
+]);
 // ../jsx/src/ir-to-client-js/utils.ts
 var PROPS_PARAM = "_p";
+// ../jsx/src/ir-to-client-js/csr-substitute.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+
+// ../jsx/src/ir-to-client-js/html-template.ts
+function splitTemplateInterpolations(inner) {
+  const parts = [];
+  let i2 = 0;
+  let segStart = 0;
+  while (i2 < inner.length) {
+    if (inner[i2] === "$" && inner[i2 + 1] === "{") {
+      if (i2 > segStart)
+        parts.push(inner.slice(segStart, i2));
+      let depth = 1;
+      let j = i2 + 2;
+      while (j < inner.length && depth > 0) {
+        if (inner[j] === "{")
+          depth++;
+        else if (inner[j] === "}")
+          depth--;
+        if (depth > 0)
+          j++;
+      }
+      j++;
+      parts.push(inner.slice(i2, j));
+      i2 = j;
+      segStart = j;
+    } else {
+      i2++;
+    }
+  }
+  if (segStart < inner.length)
+    parts.push(inner.slice(segStart));
+  return parts;
+}
+function createTemplateAwareStringProtector() {
+  const stash = [];
+  const save = (s) => {
+    const i2 = stash.length;
+    stash.push(s);
+    return `__STRLIT_${i2}__`;
+  };
+  const protect = (s) => {
+    s = s.replace(/`([^`]*)`/g, (_full, inner) => {
+      const parts = splitTemplateInterpolations(inner);
+      return "`" + parts.map((p) => p.startsWith("${") ? p : save(p)).join("") + "`";
+    });
+    s = s.replace(/'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, (m) => save(m));
+    return s;
+  };
+  const restore = (s) => {
+    return s.replace(/__STRLIT_(\d+)__/g, (_, i2) => stash[Number(i2)]);
+  };
+  return { protect, restore };
+}
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
 
 // ../jsx/src/prop-rewrite.ts
 function collectAstPropRefs(node, propNames, out) {
   function visit(n, parent) {
-    if (import_typescript3.default.isIdentifier(n) && propNames.has(n.text)) {
-      if (parent && import_typescript3.default.isPropertyAssignment(parent) && parent.name === n)
+    if (import_typescript4.default.isIdentifier(n) && propNames.has(n.text)) {
+      if (parent && import_typescript4.default.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && import_typescript3.default.isShorthandPropertyAssignment(parent) && parent.name === n)
+      if (parent && import_typescript4.default.isShorthandPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && import_typescript3.default.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && import_typescript4.default.isPropertyAccessExpression(parent) && parent.name === n)
         return;
       out.add(n.text);
     }
-    import_typescript3.default.forEachChild(n, (child) => visit(child, n));
+    import_typescript4.default.forEachChild(n, (child) => visit(child, n));
   }
   visit(node);
 }
 function applyRegexPropRefRewrite(text, propRefs) {
-  let result = text;
+  const { protect, restore } = createTemplateAwareStringProtector();
+  let result = protect(text);
   for (const propName of propRefs) {
     const pattern = new RegExp(`(?<!${PROPS_PARAM}\\.)(?<!['"\\w.-])\\b${propName}\\b(?![a-zA-Z0-9_$])`, "g");
     result = result.replace(pattern, (match, offset, str) => {
@@ -187429,7 +187584,7 @@ function applyRegexPropRefRewrite(text, propRefs) {
       return `${PROPS_PARAM}.${propName}`;
     });
   }
-  return result;
+  return restore(result);
 }
 function rewriteBarePropRefs(text, node, propNames, extraPropRefs) {
   const foundPropRefs = new Set;
@@ -187463,10 +187618,10 @@ function incrementCounter(key) {
 }
 
 // ../jsx/src/analyzer-context.ts
-var import_typescript5 = __toESM(require_typescript(), 1);
+var import_typescript6 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/strip-types.ts
-var import_typescript4 = __toESM(require_typescript(), 1);
+var import_typescript5 = __toESM(require_typescript(), 1);
 function collectAllTypeRanges(sourceFile) {
   const ranges = [];
   collectTypeRanges(sourceFile, sourceFile, sourceFile.text, ranges);
@@ -187518,7 +187673,7 @@ function mergeRanges(ranges) {
   return merged;
 }
 function collectTypeRanges(node, sourceFile, fullText, ranges) {
-  if (import_typescript4.default.isParameter(node)) {
+  if (import_typescript5.default.isParameter(node)) {
     const hasQuestion = !!node.questionToken;
     const hasType = !!node.type;
     if (hasQuestion && hasType) {
@@ -187532,72 +187687,72 @@ function collectTypeRanges(node, sourceFile, fullText, ranges) {
       }
     }
   }
-  if (import_typescript4.default.isVariableDeclaration(node) && node.type) {
+  if (import_typescript5.default.isVariableDeclaration(node) && node.type) {
     const colonPos = findColonBefore(node.type, fullText, node.name.getEnd());
     if (colonPos >= 0) {
       ranges.push({ start: colonPos, end: node.type.getEnd() });
     }
   }
-  if (import_typescript4.default.isArrowFunction(node) && node.type) {
+  if (import_typescript5.default.isArrowFunction(node) && node.type) {
     const colonPos = findColonBefore(node.type, fullText, node.parameters.end);
     if (colonPos >= 0) {
       ranges.push({ start: colonPos, end: node.type.getEnd() });
     }
   }
-  if ((import_typescript4.default.isFunctionDeclaration(node) || import_typescript4.default.isFunctionExpression(node)) && node.type) {
+  if ((import_typescript5.default.isFunctionDeclaration(node) || import_typescript5.default.isFunctionExpression(node)) && node.type) {
     const colonPos = findColonBefore(node.type, fullText, node.parameters.end);
     if (colonPos >= 0) {
       ranges.push({ start: colonPos, end: node.type.getEnd() });
     }
   }
-  if (import_typescript4.default.isAsExpression(node)) {
+  if (import_typescript5.default.isAsExpression(node)) {
     const exprEnd = node.expression.getEnd();
     ranges.push({ start: exprEnd, end: node.getEnd() });
     collectTypeRanges(node.expression, sourceFile, fullText, ranges);
     return;
   }
-  if (import_typescript4.default.isSatisfiesExpression(node)) {
+  if (import_typescript5.default.isSatisfiesExpression(node)) {
     const exprEnd = node.expression.getEnd();
     ranges.push({ start: exprEnd, end: node.getEnd() });
     collectTypeRanges(node.expression, sourceFile, fullText, ranges);
     return;
   }
-  if (import_typescript4.default.isNonNullExpression(node)) {
+  if (import_typescript5.default.isNonNullExpression(node)) {
     const exprEnd = node.expression.getEnd();
     ranges.push({ start: exprEnd, end: node.getEnd() });
     collectTypeRanges(node.expression, sourceFile, fullText, ranges);
     return;
   }
-  if (import_typescript4.default.isTypeAssertionExpression(node)) {
+  if (import_typescript5.default.isTypeAssertionExpression(node)) {
     const exprStart = node.expression.getStart(sourceFile);
     ranges.push({ start: node.getStart(sourceFile), end: exprStart });
     collectTypeRanges(node.expression, sourceFile, fullText, ranges);
     return;
   }
-  if (import_typescript4.default.isCallExpression(node) && node.typeArguments) {
+  if (import_typescript5.default.isCallExpression(node) && node.typeArguments) {
     const typeArgsStart = findAngleBracketBefore(node.typeArguments[0], fullText, node.expression.getEnd());
     const typeArgsEnd = findAngleBracketAfter(node.typeArguments[node.typeArguments.length - 1], fullText);
     if (typeArgsStart >= 0 && typeArgsEnd >= 0) {
       ranges.push({ start: typeArgsStart, end: typeArgsEnd });
     }
   }
-  if (import_typescript4.default.isNewExpression(node) && node.typeArguments) {
+  if (import_typescript5.default.isNewExpression(node) && node.typeArguments) {
     const typeArgsStart = findAngleBracketBefore(node.typeArguments[0], fullText, node.expression.getEnd());
     const typeArgsEnd = findAngleBracketAfter(node.typeArguments[node.typeArguments.length - 1], fullText);
     if (typeArgsStart >= 0 && typeArgsEnd >= 0) {
       ranges.push({ start: typeArgsStart, end: typeArgsEnd });
     }
   }
-  if (import_typescript4.default.isTypeAliasDeclaration(node) || import_typescript4.default.isInterfaceDeclaration(node)) {
+  if (import_typescript5.default.isTypeAliasDeclaration(node) || import_typescript5.default.isInterfaceDeclaration(node)) {
     ranges.push({
       start: expandToLineStart(node.getStart(sourceFile), fullText),
       end: expandThroughLineEnd(node.getEnd(), fullText)
     });
     return;
   }
-  if (import_typescript4.default.isTypeNode(node))
+  if (import_typescript5.default.isTypeNode(node))
     return;
-  import_typescript4.default.forEachChild(node, (child) => {
+  import_typescript5.default.forEachChild(node, (child) => {
     collectTypeRanges(child, sourceFile, fullText, ranges);
   });
 }
@@ -187712,18 +187867,18 @@ function typeNodeToTypeInfo(typeNode, sourceFile) {
     return null;
   const raw = typeNode.getText(sourceFile);
   switch (typeNode.kind) {
-    case import_typescript5.default.SyntaxKind.StringKeyword:
+    case import_typescript6.default.SyntaxKind.StringKeyword:
       return { kind: "primitive", raw, primitive: "string" };
-    case import_typescript5.default.SyntaxKind.NumberKeyword:
+    case import_typescript6.default.SyntaxKind.NumberKeyword:
       return { kind: "primitive", raw, primitive: "number" };
-    case import_typescript5.default.SyntaxKind.BooleanKeyword:
+    case import_typescript6.default.SyntaxKind.BooleanKeyword:
       return { kind: "primitive", raw, primitive: "boolean" };
-    case import_typescript5.default.SyntaxKind.NullKeyword:
+    case import_typescript6.default.SyntaxKind.NullKeyword:
       return { kind: "primitive", raw, primitive: "null" };
-    case import_typescript5.default.SyntaxKind.UndefinedKeyword:
+    case import_typescript6.default.SyntaxKind.UndefinedKeyword:
       return { kind: "primitive", raw, primitive: "undefined" };
   }
-  if (import_typescript5.default.isArrayTypeNode(typeNode)) {
+  if (import_typescript6.default.isArrayTypeNode(typeNode)) {
     return {
       kind: "array",
       raw,
@@ -187733,35 +187888,35 @@ function typeNodeToTypeInfo(typeNode, sourceFile) {
       }
     };
   }
-  if (import_typescript5.default.isUnionTypeNode(typeNode)) {
+  if (import_typescript6.default.isUnionTypeNode(typeNode)) {
     return {
       kind: "union",
       raw,
       unionTypes: typeNode.types.map((t) => typeNodeToTypeInfo(t, sourceFile) ?? { kind: "unknown", raw: "unknown" })
     };
   }
-  if (import_typescript5.default.isTypeLiteralNode(typeNode)) {
+  if (import_typescript6.default.isTypeLiteralNode(typeNode)) {
     return {
       kind: "object",
       raw,
-      properties: typeNode.members.filter(import_typescript5.default.isPropertySignature).map((member) => ({
+      properties: typeNode.members.filter(import_typescript6.default.isPropertySignature).map((member) => ({
         name: member.name?.getText(sourceFile) ?? "",
         type: typeNodeToTypeInfo(member.type, sourceFile) ?? {
           kind: "unknown",
           raw: "unknown"
         },
         optional: !!member.questionToken,
-        readonly: !!member.modifiers?.some((m) => m.kind === import_typescript5.default.SyntaxKind.ReadonlyKeyword)
+        readonly: !!member.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.ReadonlyKeyword)
       }))
     };
   }
-  if (import_typescript5.default.isTypeReferenceNode(typeNode)) {
+  if (import_typescript6.default.isTypeReferenceNode(typeNode)) {
     return {
       kind: "interface",
       raw
     };
   }
-  if (import_typescript5.default.isFunctionTypeNode(typeNode)) {
+  if (import_typescript6.default.isFunctionTypeNode(typeNode)) {
     return {
       kind: "function",
       raw,
@@ -187783,16 +187938,16 @@ function isPascalCase(name) {
   return /^[A-Z][a-zA-Z0-9]*$/.test(name);
 }
 function isComponentFunction(node) {
-  return import_typescript5.default.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
+  return import_typescript6.default.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
 }
 function isArrowComponentFunction(node) {
-  if (!import_typescript5.default.isVariableDeclaration(node))
+  if (!import_typescript6.default.isVariableDeclaration(node))
     return false;
-  if (!import_typescript5.default.isIdentifier(node.name))
+  if (!import_typescript6.default.isIdentifier(node.name))
     return false;
   if (!isPascalCase(node.name.text))
     return false;
-  if (!node.initializer || !import_typescript5.default.isArrowFunction(node.initializer))
+  if (!node.initializer || !import_typescript6.default.isArrowFunction(node.initializer))
     return false;
   return true;
 }
@@ -187887,9 +188042,9 @@ function needsTypeBasedDetection(source) {
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
   for (const stmt of sourceFile.statements) {
-    if (!import_typescript6.default.isImportDeclaration(stmt))
+    if (!import_typescript7.default.isImportDeclaration(stmt))
       continue;
-    if (!import_typescript6.default.isStringLiteral(stmt.moduleSpecifier))
+    if (!import_typescript7.default.isStringLiteral(stmt.moduleSpecifier))
       continue;
     if (!REACTIVE_BRAND_PACKAGES.includes(stmt.moduleSpecifier.text))
       continue;
@@ -187908,21 +188063,21 @@ function createProgramForFile(source, filePath) {
   try {
     const normalizedPath = path_default.resolve(filePath);
     const compilerOptions = {
-      target: import_typescript6.default.ScriptTarget.Latest,
-      module: import_typescript6.default.ModuleKind.ESNext,
-      moduleResolution: import_typescript6.default.ModuleResolutionKind.Bundler,
-      jsx: import_typescript6.default.JsxEmit.ReactJSX,
+      target: import_typescript7.default.ScriptTarget.Latest,
+      module: import_typescript7.default.ModuleKind.ESNext,
+      moduleResolution: import_typescript7.default.ModuleResolutionKind.Bundler,
+      jsx: import_typescript7.default.JsxEmit.ReactJSX,
       strict: true,
       skipLibCheck: true,
       noEmit: true,
       baseUrl: path_default.dirname(normalizedPath)
     };
-    const defaultHost = import_typescript6.default.createCompilerHost(compilerOptions);
+    const defaultHost = import_typescript7.default.createCompilerHost(compilerOptions);
     const virtualHost = {
       ...defaultHost,
       getSourceFile(fileName, languageVersion) {
         if (path_default.resolve(fileName) === normalizedPath) {
-          return import_typescript6.default.createSourceFile(fileName, source, languageVersion, true, import_typescript6.default.ScriptKind.TSX);
+          return import_typescript7.default.createSourceFile(fileName, source, languageVersion, true, import_typescript7.default.ScriptKind.TSX);
         }
         return defaultHost.getSourceFile(fileName, languageVersion);
       },
@@ -187937,7 +188092,7 @@ function createProgramForFile(source, filePath) {
         return defaultHost.readFile(fileName);
       }
     };
-    const program = import_typescript6.default.createProgram([normalizedPath], compilerOptions, virtualHost);
+    const program = import_typescript7.default.createProgram([normalizedPath], compilerOptions, virtualHost);
     const sourceFile = program.getSourceFile(normalizedPath);
     if (!sourceFile)
       return null;
@@ -187970,7 +188125,7 @@ function analyzeComponent(source, filePath, targetComponentName, program) {
     }
   }
   if (!sourceFile) {
-    sourceFile = import_typescript6.default.createSourceFile(filePath, source, import_typescript6.default.ScriptTarget.Latest, true, import_typescript6.default.ScriptKind.TSX);
+    sourceFile = import_typescript7.default.createSourceFile(filePath, source, import_typescript7.default.ScriptTarget.Latest, true, import_typescript7.default.ScriptKind.TSX);
   }
   if (!checker && needsTypeBasedDetection(source)) {
     const result = createProgramForFile(source, filePath);
@@ -187997,23 +188152,23 @@ function analyzeComponent(source, filePath, targetComponentName, program) {
 function findDefaultExportedComponent(sourceFile) {
   let defaultExportName;
   function findDefaultExport(node) {
-    if (import_typescript6.default.isExportAssignment(node) && !node.isExportEquals) {
-      if (import_typescript6.default.isIdentifier(node.expression)) {
+    if (import_typescript7.default.isExportAssignment(node) && !node.isExportEquals) {
+      if (import_typescript7.default.isIdentifier(node.expression)) {
         defaultExportName = node.expression.text;
       }
     }
-    if (import_typescript6.default.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.DefaultKeyword)) {
+    if (import_typescript7.default.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.DefaultKeyword)) {
       defaultExportName = node.name.text;
     }
-    import_typescript6.default.forEachChild(node, findDefaultExport);
+    import_typescript7.default.forEachChild(node, findDefaultExport);
   }
-  import_typescript6.default.forEachChild(sourceFile, findDefaultExport);
+  import_typescript7.default.forEachChild(sourceFile, findDefaultExport);
   return defaultExportName;
 }
 function collectNamedExports(sourceFile) {
   const exported = new Set;
   for (const stmt of sourceFile.statements) {
-    if (import_typescript6.default.isExportDeclaration(stmt) && stmt.exportClause && import_typescript6.default.isNamedExports(stmt.exportClause)) {
+    if (import_typescript7.default.isExportDeclaration(stmt) && stmt.exportClause && import_typescript7.default.isNamedExports(stmt.exportClause)) {
       for (const spec of stmt.exportClause.elements) {
         const local = (spec.propertyName ?? spec.name).text;
         exported.add(local);
@@ -188023,22 +188178,22 @@ function collectNamedExports(sourceFile) {
   return exported;
 }
 function visit(node, ctx, targetComponentName, namedExports) {
-  if (import_typescript6.default.isExpressionStatement(node) && import_typescript6.default.isStringLiteral(node.expression)) {
+  if (import_typescript7.default.isExpressionStatement(node) && import_typescript7.default.isStringLiteral(node.expression)) {
     if (node.expression.text === "use client" || node.expression.text === "'use client'") {
       ctx.hasUseClientDirective = true;
     }
   }
-  if (import_typescript6.default.isImportDeclaration(node)) {
+  if (import_typescript7.default.isImportDeclaration(node)) {
     collectImport(node, ctx);
   }
-  if (import_typescript6.default.isInterfaceDeclaration(node)) {
+  if (import_typescript7.default.isInterfaceDeclaration(node)) {
     collectInterfaceDefinition(node, ctx);
   }
-  if (import_typescript6.default.isTypeAliasDeclaration(node)) {
+  if (import_typescript7.default.isTypeAliasDeclaration(node)) {
     collectTypeAliasDefinition(node, ctx);
   }
-  if (!ctx.hasUseClientDirective && import_typescript6.default.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
-    const hasInlineExport = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.ExportKeyword) ?? false;
+  if (!ctx.hasUseClientDirective && import_typescript7.default.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
+    const hasInlineExport = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.ExportKeyword) ?? false;
     const hasNamedExport = namedExports?.has(node.name.text) ?? false;
     if (!hasInlineExport && !hasNamedExport) {
       collectFunction(node, ctx, true, false);
@@ -188053,9 +188208,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 === import_typescript6.default.SyntaxKind.ExportKeyword) ?? false;
+        ctx.isExported = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.ExportKeyword) ?? false;
         analyzeComponentBody(node, ctx);
-        if (node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.DefaultKeyword)) {
+        if (node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.DefaultKeyword)) {
           ctx.hasDefaultExport = true;
         }
       }
@@ -188069,10 +188224,10 @@ function visit(node, ctx, targetComponentName, namedExports) {
         ctx.componentName = node.name.text;
         ctx.componentNode = node.initializer;
         const parentStatement = node.parent;
-        if (import_typescript6.default.isVariableDeclarationList(parentStatement)) {
+        if (import_typescript7.default.isVariableDeclarationList(parentStatement)) {
           const varStatement = parentStatement.parent;
-          if (import_typescript6.default.isVariableStatement(varStatement)) {
-            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.ExportKeyword) ?? false;
+          if (import_typescript7.default.isVariableStatement(varStatement)) {
+            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.ExportKeyword) ?? false;
           }
         }
         analyzeComponentBody(node.initializer, ctx);
@@ -188084,9 +188239,9 @@ function visit(node, ctx, targetComponentName, namedExports) {
   if (!ctx.componentNode) {
     collectAmbientGlobals(node, ctx);
   }
-  if (import_typescript6.default.isVariableStatement(node) && !ctx.componentNode) {
-    const isExported = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.ExportKeyword) ?? false;
-    const isLet = (node.declarationList.flags & import_typescript6.default.NodeFlags.Let) !== 0;
+  if (import_typescript7.default.isVariableStatement(node) && !ctx.componentNode) {
+    const isExported = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.ExportKeyword) ?? false;
+    const isLet = (node.declarationList.flags & import_typescript7.default.NodeFlags.Let) !== 0;
     const isModuleClientDirective = hasLeadingClientDirectiveOnStatement(node, ctx.sourceFile);
     for (const decl of node.declarationList.declarations) {
       if (declarationIsReactiveFactoryCall(decl, ctx)) {
@@ -188097,19 +188252,19 @@ function visit(node, ctx, targetComponentName, namedExports) {
         }
         continue;
       }
-      if (import_typescript6.default.isIdentifier(decl.name) && decl.initializer && !isArrowComponentFunction(decl)) {
+      if (import_typescript7.default.isIdentifier(decl.name) && decl.initializer && !isArrowComponentFunction(decl)) {
         collectConstant(decl, ctx, true, isLet ? "let" : "const", isExported);
       }
     }
   }
-  if (import_typescript6.default.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
-    const isExported = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.ExportKeyword) ?? false;
+  if (import_typescript7.default.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
+    const isExported = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.ExportKeyword) ?? false;
     collectFunction(node, ctx, true, isExported);
     return;
   }
-  if (import_typescript6.default.isExportDeclaration(node) && node.exportClause && import_typescript6.default.isNamedExports(node.exportClause)) {
+  if (import_typescript7.default.isExportDeclaration(node) && node.exportClause && import_typescript7.default.isNamedExports(node.exportClause)) {
     const isFromReexport = !!node.moduleSpecifier;
-    const sourceSpec = node.moduleSpecifier && import_typescript6.default.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+    const sourceSpec = node.moduleSpecifier && import_typescript7.default.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,
@@ -188137,24 +188292,24 @@ function visit(node, ctx, targetComponentName, namedExports) {
       }
     }
   }
-  if (import_typescript6.default.isExportAssignment(node) && !node.isExportEquals) {
+  if (import_typescript7.default.isExportAssignment(node) && !node.isExportEquals) {
     const expr = node.expression;
-    if (import_typescript6.default.isIdentifier(expr)) {
+    if (import_typescript7.default.isIdentifier(expr)) {
       if (ctx.componentName && expr.text === ctx.componentName) {
         ctx.hasDefaultExport = true;
         ctx.isExported = true;
       }
     }
   }
-  import_typescript6.default.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
+  import_typescript7.default.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
 }
 function analyzeComponentBody(node, ctx) {
   if (node.parameters.length > 0) {
     extractProps(node.parameters[0], ctx);
   }
-  const body = import_typescript6.default.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
+  const body = import_typescript7.default.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
   if (body) {
-    ctx.componentBodyBlock = import_typescript6.default.isBlock(body) ? body : null;
+    ctx.componentBodyBlock = import_typescript7.default.isBlock(body) ? body : null;
     if (!ctx.componentBodyBlock) {
       ctx.jsxReturn = unwrapJsxTransparent(body);
     }
@@ -188164,14 +188319,14 @@ function analyzeComponentBody(node, ctx) {
   }
 }
 function getArrowFunctionBody(node) {
-  if (import_typescript6.default.isBlock(node.body)) {
+  if (import_typescript7.default.isBlock(node.body)) {
     return node.body;
   }
   return node.body;
 }
 function visitComponentBody(node, ctx) {
   const isTopLevel = ctx.componentBodyBlock !== null && node.parent === ctx.componentBodyBlock;
-  if (import_typescript6.default.isVariableStatement(node)) {
+  if (import_typescript7.default.isVariableStatement(node)) {
     for (const decl of node.declarationList.declarations) {
       if (isSignalDeclaration(decl, ctx)) {
         collectSignal(decl, ctx);
@@ -188194,16 +188349,16 @@ function visitComponentBody(node, ctx) {
         collectEffect(decl.initializer, ctx, decl.name.text);
         continue;
       }
-      if (import_typescript6.default.isIdentifier(decl.name)) {
-        const isLet = (node.declarationList.flags & import_typescript6.default.NodeFlags.Let) !== 0;
+      if (import_typescript7.default.isIdentifier(decl.name)) {
+        const isLet = (node.declarationList.flags & import_typescript7.default.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx, false, isLet ? "let" : "const");
-      } else if (import_typescript6.default.isObjectBindingPattern(decl.name) && decl.initializer && import_typescript6.default.isIdentifier(decl.initializer) && ctx.propsObjectName === decl.initializer.text) {
-        const isLet = (node.declarationList.flags & import_typescript6.default.NodeFlags.Let) !== 0;
+      } else if (import_typescript7.default.isObjectBindingPattern(decl.name) && decl.initializer && import_typescript7.default.isIdentifier(decl.initializer) && ctx.propsObjectName === decl.initializer.text) {
+        const isLet = (node.declarationList.flags & import_typescript7.default.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx, false, isLet ? "let" : "const");
       }
     }
   }
-  if (import_typescript6.default.isExpressionStatement(node)) {
+  if (import_typescript7.default.isExpressionStatement(node)) {
     if (isEffectCall(node.expression, ctx)) {
       collectEffect(node.expression, ctx);
       return;
@@ -188217,10 +188372,10 @@ function visitComponentBody(node, ctx) {
       return;
     }
   }
-  if (import_typescript6.default.isFunctionDeclaration(node) && node.name) {
+  if (import_typescript7.default.isFunctionDeclaration(node) && node.name) {
     collectFunction(node, ctx, false);
   }
-  if (import_typescript6.default.isIfStatement(node)) {
+  if (import_typescript7.default.isIfStatement(node)) {
     const jsxReturn = findJsxReturnInBlock(node.thenStatement);
     if (jsxReturn) {
       const scopeVars = collectScopeVariables(node.thenStatement, ctx);
@@ -188239,54 +188394,54 @@ function visitComponentBody(node, ctx) {
       return;
     }
   }
-  if (isTopLevel && (import_typescript6.default.isTryStatement(node) || import_typescript6.default.isSwitchStatement(node) || import_typescript6.default.isForStatement(node) || import_typescript6.default.isForInStatement(node) || import_typescript6.default.isForOfStatement(node) || import_typescript6.default.isWhileStatement(node) || import_typescript6.default.isDoStatement(node) || import_typescript6.default.isThrowStatement(node) || import_typescript6.default.isBlock(node) && node.parent === ctx.componentBodyBlock)) {
+  if (isTopLevel && (import_typescript7.default.isTryStatement(node) || import_typescript7.default.isSwitchStatement(node) || import_typescript7.default.isForStatement(node) || import_typescript7.default.isForInStatement(node) || import_typescript7.default.isForOfStatement(node) || import_typescript7.default.isWhileStatement(node) || import_typescript7.default.isDoStatement(node) || import_typescript7.default.isThrowStatement(node) || import_typescript7.default.isBlock(node) && node.parent === ctx.componentBodyBlock)) {
     collectInitStatement(node, ctx);
     return;
   }
-  if (import_typescript6.default.isReturnStatement(node) && node.expression) {
+  if (import_typescript7.default.isReturnStatement(node) && node.expression) {
     ctx.jsxReturn = unwrapJsxTransparent(node.expression);
   }
-  import_typescript6.default.forEachChild(node, (child) => {
-    if (import_typescript6.default.isArrowFunction(child) || import_typescript6.default.isFunctionExpression(child) || import_typescript6.default.isFunctionDeclaration(child)) {
+  import_typescript7.default.forEachChild(node, (child) => {
+    if (import_typescript7.default.isArrowFunction(child) || import_typescript7.default.isFunctionExpression(child) || import_typescript7.default.isFunctionDeclaration(child)) {
       return;
     }
     visitComponentBody(child, ctx);
   });
 }
 function findJsxReturnInBlock(node) {
-  if (import_typescript6.default.isBlock(node)) {
+  if (import_typescript7.default.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+      if (import_typescript7.default.isReturnStatement(stmt) && stmt.expression) {
         const jsx = extractJsxFromExpression(stmt.expression);
         if (jsx)
           return jsx;
       }
     }
   }
-  if (import_typescript6.default.isReturnStatement(node) && node.expression) {
+  if (import_typescript7.default.isReturnStatement(node) && node.expression) {
     return extractJsxFromExpression(node.expression);
   }
   return null;
 }
 function unwrapJsxTransparent(expr) {
   let current = expr;
-  while (import_typescript6.default.isParenthesizedExpression(current) || import_typescript6.default.isAsExpression(current) || import_typescript6.default.isSatisfiesExpression(current) || import_typescript6.default.isNonNullExpression(current) || import_typescript6.default.isTypeAssertionExpression(current) || current.kind === import_typescript6.default.SyntaxKind.PartiallyEmittedExpression) {
+  while (import_typescript7.default.isParenthesizedExpression(current) || import_typescript7.default.isAsExpression(current) || import_typescript7.default.isSatisfiesExpression(current) || import_typescript7.default.isNonNullExpression(current) || import_typescript7.default.isTypeAssertionExpression(current) || current.kind === import_typescript7.default.SyntaxKind.PartiallyEmittedExpression) {
     current = current.expression;
   }
   return current;
 }
 function extractJsxFromExpression(expr) {
   const inner = unwrapJsxTransparent(expr);
-  if (import_typescript6.default.isJsxElement(inner) || import_typescript6.default.isJsxFragment(inner) || import_typescript6.default.isJsxSelfClosingElement(inner)) {
+  if (import_typescript7.default.isJsxElement(inner) || import_typescript7.default.isJsxFragment(inner) || import_typescript7.default.isJsxSelfClosingElement(inner)) {
     return inner;
   }
   return null;
 }
 function collectScopeVariables(node, ctx) {
   const variables = [];
-  if (import_typescript6.default.isBlock(node)) {
+  if (import_typescript7.default.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (import_typescript6.default.isVariableStatement(stmt)) {
+      if (import_typescript7.default.isVariableStatement(stmt)) {
         for (const decl of stmt.declarationList.declarations) {
           variables.push(decl);
         }
@@ -188298,13 +188453,13 @@ function collectScopeVariables(node, ctx) {
 function collectParamBindingNames(params) {
   const out = new Set;
   const addBindingNames = (name) => {
-    if (import_typescript6.default.isIdentifier(name)) {
+    if (import_typescript7.default.isIdentifier(name)) {
       out.add(name.text);
-    } else if (import_typescript6.default.isObjectBindingPattern(name)) {
+    } else if (import_typescript7.default.isObjectBindingPattern(name)) {
       name.elements.forEach((e) => addBindingNames(e.name));
-    } else if (import_typescript6.default.isArrayBindingPattern(name)) {
+    } else if (import_typescript7.default.isArrayBindingPattern(name)) {
       name.elements.forEach((e) => {
-        if (!import_typescript6.default.isOmittedExpression(e))
+        if (!import_typescript7.default.isOmittedExpression(e))
           addBindingNames(e.name);
       });
     }
@@ -188321,7 +188476,7 @@ function collectEnclosingBranchVars(node, ctx) {
       if (cr.ifStatement.thenStatement !== current)
         continue;
       for (const decl of cr.scopeVariables) {
-        if (!import_typescript6.default.isIdentifier(decl.name) || !decl.initializer)
+        if (!import_typescript7.default.isIdentifier(decl.name) || !decl.initializer)
           continue;
         const varName = decl.name.text;
         if (result.has(varName))
@@ -188336,10 +188491,10 @@ function collectEnclosingBranchVars(node, ctx) {
   return result;
 }
 function collectBranchSignals(thenStatement, ctx, branchCondition) {
-  if (!import_typescript6.default.isBlock(thenStatement))
+  if (!import_typescript7.default.isBlock(thenStatement))
     return;
   for (const stmt of thenStatement.statements) {
-    if (!import_typescript6.default.isVariableStatement(stmt))
+    if (!import_typescript7.default.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
       if (!isSignalDeclaration(decl, ctx))
@@ -188361,13 +188516,13 @@ var PRIMITIVE_CANONICAL_NAMES = {
   onCleanup: "onCleanup"
 };
 function resolvePrimitiveKind(callExpr, ctx) {
-  if (import_typescript6.default.isIdentifier(callExpr.expression)) {
+  if (import_typescript7.default.isIdentifier(callExpr.expression)) {
     const hit = PRIMITIVE_CANONICAL_NAMES[callExpr.expression.text];
     if (hit)
       return hit;
     return resolveCalleeViaChecker(callExpr.expression, ctx);
   }
-  if (import_typescript6.default.isPropertyAccessExpression(callExpr.expression)) {
+  if (import_typescript7.default.isPropertyAccessExpression(callExpr.expression)) {
     const propName = callExpr.expression.name.text;
     const hit = PRIMITIVE_CANONICAL_NAMES[propName];
     if (!hit)
@@ -188390,7 +188545,7 @@ function resolveCalleeViaChecker(ident, ctx) {
   if (!symbol)
     return null;
   let target = symbol;
-  if (symbol.flags & import_typescript6.default.SymbolFlags.Alias) {
+  if (symbol.flags & import_typescript7.default.SymbolFlags.Alias) {
     try {
       target = ctx.checker.getAliasedSymbol(symbol);
     } catch {
@@ -188410,7 +188565,7 @@ function resolveCalleeViaChecker(ident, ctx) {
   return null;
 }
 function isBarefootClientNamespace(expr, ctx) {
-  if (!import_typescript6.default.isIdentifier(expr))
+  if (!import_typescript7.default.isIdentifier(expr))
     return false;
   if (!ctx.checker)
     return false;
@@ -188423,22 +188578,22 @@ function isBarefootClientNamespace(expr, ctx) {
   if (!symbol)
     return false;
   for (const decl of symbol.declarations ?? []) {
-    if (!import_typescript6.default.isNamespaceImport(decl))
+    if (!import_typescript7.default.isNamespaceImport(decl))
       continue;
     const importDecl = decl.parent.parent;
-    if (!import_typescript6.default.isImportDeclaration(importDecl))
+    if (!import_typescript7.default.isImportDeclaration(importDecl))
       continue;
     const mod = importDecl.moduleSpecifier;
-    if (import_typescript6.default.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
+    if (import_typescript7.default.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
       return true;
     }
   }
   return false;
 }
 function isSignalDeclaration(node, ctx) {
-  if (!import_typescript6.default.isArrayBindingPattern(node.name))
+  if (!import_typescript7.default.isArrayBindingPattern(node.name))
     return false;
-  if (!node.initializer || !import_typescript6.default.isCallExpression(node.initializer))
+  if (!node.initializer || !import_typescript7.default.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "signal";
 }
@@ -188446,14 +188601,14 @@ function collectSignal(node, ctx) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements = pattern.elements;
-  if (elements.length < 1 || elements.length > 2 || !import_typescript6.default.isBindingElement(elements[0]) || !import_typescript6.default.isIdentifier(elements[0].name)) {
+  if (elements.length < 1 || elements.length > 2 || !import_typescript7.default.isBindingElement(elements[0]) || !import_typescript7.default.isIdentifier(elements[0].name)) {
     return;
   }
-  if (elements.length === 2 && (!import_typescript6.default.isBindingElement(elements[1]) || !import_typescript6.default.isIdentifier(elements[1].name))) {
+  if (elements.length === 2 && (!import_typescript7.default.isBindingElement(elements[1]) || !import_typescript7.default.isIdentifier(elements[1].name))) {
     return;
   }
   const getter = elements[0].name.text;
-  const setter = elements.length === 2 && import_typescript6.default.isBindingElement(elements[1]) && import_typescript6.default.isIdentifier(elements[1].name) ? elements[1].name.text : null;
+  const setter = elements.length === 2 && import_typescript7.default.isBindingElement(elements[1]) && import_typescript7.default.isIdentifier(elements[1].name) ? elements[1].name.text : null;
   const initialValue = callExpr.arguments[0] ? ctx.getJS(callExpr.arguments[0]) : "";
   const typedInitialValue = callExpr.arguments[0] ? callExpr.arguments[0].getText(ctx.sourceFile) : undefined;
   let type2 = { kind: "unknown", raw: "unknown" };
@@ -188473,33 +188628,33 @@ function collectSignal(node, ctx) {
   });
 }
 function isSignalTupleDeclaration(node) {
-  if (!import_typescript6.default.isIdentifier(node.name))
+  if (!import_typescript7.default.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !import_typescript6.default.isCallExpression(node.initializer))
+  if (!node.initializer || !import_typescript7.default.isCallExpression(node.initializer))
     return false;
   const callExpr = node.initializer;
-  return import_typescript6.default.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
+  return import_typescript7.default.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
 }
 function isSignalIndexAccess(node, ctx) {
-  if (!import_typescript6.default.isIdentifier(node.name))
+  if (!import_typescript7.default.isIdentifier(node.name))
     return null;
-  if (!node.initializer || !import_typescript6.default.isElementAccessExpression(node.initializer))
+  if (!node.initializer || !import_typescript7.default.isElementAccessExpression(node.initializer))
     return null;
   const access = node.initializer;
-  if (!import_typescript6.default.isNumericLiteral(access.argumentExpression))
+  if (!import_typescript7.default.isNumericLiteral(access.argumentExpression))
     return null;
   const indexValue = Number(access.argumentExpression.text);
   if (indexValue !== 0 && indexValue !== 1)
     return null;
   const index = indexValue;
-  if (import_typescript6.default.isCallExpression(access.expression)) {
+  if (import_typescript7.default.isCallExpression(access.expression)) {
     const call = access.expression;
-    if (import_typescript6.default.isIdentifier(call.expression) && call.expression.text === "createSignal") {
+    if (import_typescript7.default.isIdentifier(call.expression) && call.expression.text === "createSignal") {
       return { kind: "direct", index, callExpr: call };
     }
     return null;
   }
-  if (import_typescript6.default.isIdentifier(access.expression)) {
+  if (import_typescript7.default.isIdentifier(access.expression)) {
     const tupleName = access.expression.text;
     if (ctx.signalTupleRefs.has(tupleName)) {
       return { kind: "tupleRef", index, tupleName };
@@ -188594,9 +188749,9 @@ function flushPendingSignalTuples(ctx) {
   ctx.signalTupleRefs.clear();
 }
 function isMemoDeclaration(node, ctx) {
-  if (!import_typescript6.default.isIdentifier(node.name))
+  if (!import_typescript7.default.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !import_typescript6.default.isCallExpression(node.initializer))
+  if (!node.initializer || !import_typescript7.default.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "memo";
 }
@@ -188626,14 +188781,14 @@ function collectMemo(node, ctx) {
   });
 }
 function isEffectCall(node, ctx) {
-  if (!import_typescript6.default.isCallExpression(node))
+  if (!import_typescript7.default.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "effect";
 }
 function isEffectDisposerCapture(node, ctx) {
-  if (!import_typescript6.default.isIdentifier(node.name))
+  if (!import_typescript7.default.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !import_typescript6.default.isCallExpression(node.initializer))
+  if (!node.initializer || !import_typescript7.default.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "effect";
 }
@@ -188648,7 +188803,7 @@ function collectEffect(node, ctx, captureName) {
   });
 }
 function isOnMountCall(node, ctx) {
-  if (!import_typescript6.default.isCallExpression(node))
+  if (!import_typescript7.default.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "onMount";
 }
@@ -188683,19 +188838,19 @@ function leadsWithAsiHazard(body) {
 function extractAssignedIdentifiersFromNode(node) {
   const ids = new Set;
   function addFromTarget(target) {
-    if (import_typescript6.default.isIdentifier(target)) {
+    if (import_typescript7.default.isIdentifier(target)) {
       ids.add(target.text);
       return;
     }
-    if (import_typescript6.default.isParenthesizedExpression(target)) {
+    if (import_typescript7.default.isParenthesizedExpression(target)) {
       addFromTarget(target.expression);
       return;
     }
-    if (import_typescript6.default.isArrayLiteralExpression(target)) {
+    if (import_typescript7.default.isArrayLiteralExpression(target)) {
       for (const el of target.elements) {
-        if (import_typescript6.default.isOmittedExpression(el))
+        if (import_typescript7.default.isOmittedExpression(el))
           continue;
-        if (import_typescript6.default.isSpreadElement(el)) {
+        if (import_typescript7.default.isSpreadElement(el)) {
           addFromTarget(el.expression);
           continue;
         }
@@ -188703,17 +188858,17 @@ function extractAssignedIdentifiersFromNode(node) {
       }
       return;
     }
-    if (import_typescript6.default.isObjectLiteralExpression(target)) {
+    if (import_typescript7.default.isObjectLiteralExpression(target)) {
       for (const prop of target.properties) {
-        if (import_typescript6.default.isShorthandPropertyAssignment(prop)) {
+        if (import_typescript7.default.isShorthandPropertyAssignment(prop)) {
           ids.add(prop.name.text);
           continue;
         }
-        if (import_typescript6.default.isPropertyAssignment(prop)) {
+        if (import_typescript7.default.isPropertyAssignment(prop)) {
           addFromTarget(prop.initializer);
           continue;
         }
-        if (import_typescript6.default.isSpreadAssignment(prop)) {
+        if (import_typescript7.default.isSpreadAssignment(prop)) {
           addFromTarget(prop.expression);
           continue;
         }
@@ -188722,21 +188877,21 @@ function extractAssignedIdentifiersFromNode(node) {
     }
   }
   function visit2(n) {
-    if (import_typescript6.default.isArrowFunction(n) || import_typescript6.default.isFunctionExpression(n) || import_typescript6.default.isFunctionDeclaration(n) || import_typescript6.default.isMethodDeclaration(n) || import_typescript6.default.isGetAccessorDeclaration(n) || import_typescript6.default.isSetAccessorDeclaration(n) || import_typescript6.default.isConstructorDeclaration(n)) {
+    if (import_typescript7.default.isArrowFunction(n) || import_typescript7.default.isFunctionExpression(n) || import_typescript7.default.isFunctionDeclaration(n) || import_typescript7.default.isMethodDeclaration(n) || import_typescript7.default.isGetAccessorDeclaration(n) || import_typescript7.default.isSetAccessorDeclaration(n) || import_typescript7.default.isConstructorDeclaration(n)) {
       return;
     }
-    if (import_typescript6.default.isBinaryExpression(n)) {
+    if (import_typescript7.default.isBinaryExpression(n)) {
       const op = n.operatorToken.kind;
-      if (op === import_typescript6.default.SyntaxKind.EqualsToken || op === import_typescript6.default.SyntaxKind.PlusEqualsToken || op === import_typescript6.default.SyntaxKind.MinusEqualsToken || op === import_typescript6.default.SyntaxKind.AsteriskEqualsToken || op === import_typescript6.default.SyntaxKind.SlashEqualsToken || op === import_typescript6.default.SyntaxKind.PercentEqualsToken || op === import_typescript6.default.SyntaxKind.AsteriskAsteriskEqualsToken || op === import_typescript6.default.SyntaxKind.AmpersandEqualsToken || op === import_typescript6.default.SyntaxKind.BarEqualsToken || op === import_typescript6.default.SyntaxKind.CaretEqualsToken || op === import_typescript6.default.SyntaxKind.LessThanLessThanEqualsToken || op === import_typescript6.default.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === import_typescript6.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === import_typescript6.default.SyntaxKind.AmpersandAmpersandEqualsToken || op === import_typescript6.default.SyntaxKind.BarBarEqualsToken || op === import_typescript6.default.SyntaxKind.QuestionQuestionEqualsToken) {
+      if (op === import_typescript7.default.SyntaxKind.EqualsToken || op === import_typescript7.default.SyntaxKind.PlusEqualsToken || op === import_typescript7.default.SyntaxKind.MinusEqualsToken || op === import_typescript7.default.SyntaxKind.AsteriskEqualsToken || op === import_typescript7.default.SyntaxKind.SlashEqualsToken || op === import_typescript7.default.SyntaxKind.PercentEqualsToken || op === import_typescript7.default.SyntaxKind.AsteriskAsteriskEqualsToken || op === import_typescript7.default.SyntaxKind.AmpersandEqualsToken || op === import_typescript7.default.SyntaxKind.BarEqualsToken || op === import_typescript7.default.SyntaxKind.CaretEqualsToken || op === import_typescript7.default.SyntaxKind.LessThanLessThanEqualsToken || op === import_typescript7.default.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === import_typescript7.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === import_typescript7.default.SyntaxKind.AmpersandAmpersandEqualsToken || op === import_typescript7.default.SyntaxKind.BarBarEqualsToken || op === import_typescript7.default.SyntaxKind.QuestionQuestionEqualsToken) {
         addFromTarget(n.left);
       }
     }
-    if (import_typescript6.default.isPrefixUnaryExpression(n) || import_typescript6.default.isPostfixUnaryExpression(n)) {
-      if (n.operator === import_typescript6.default.SyntaxKind.PlusPlusToken || n.operator === import_typescript6.default.SyntaxKind.MinusMinusToken) {
+    if (import_typescript7.default.isPrefixUnaryExpression(n) || import_typescript7.default.isPostfixUnaryExpression(n)) {
+      if (n.operator === import_typescript7.default.SyntaxKind.PlusPlusToken || n.operator === import_typescript7.default.SyntaxKind.MinusMinusToken) {
         addFromTarget(n.operand);
       }
     }
-    import_typescript6.default.forEachChild(n, visit2);
+    import_typescript7.default.forEachChild(n, visit2);
   }
   visit2(node);
   const localDecls = collectLocalDeclarations(node);
@@ -188747,30 +188902,30 @@ function extractAssignedIdentifiersFromNode(node) {
 function collectLocalDeclarations(root) {
   const names = new Set;
   function addBindingName(name) {
-    if (import_typescript6.default.isIdentifier(name)) {
+    if (import_typescript7.default.isIdentifier(name)) {
       names.add(name.text);
       return;
     }
-    if (import_typescript6.default.isArrayBindingPattern(name)) {
+    if (import_typescript7.default.isArrayBindingPattern(name)) {
       for (const el of name.elements) {
-        if (import_typescript6.default.isBindingElement(el))
+        if (import_typescript7.default.isBindingElement(el))
           addBindingName(el.name);
       }
       return;
     }
-    if (import_typescript6.default.isObjectBindingPattern(name)) {
+    if (import_typescript7.default.isObjectBindingPattern(name)) {
       for (const el of name.elements) {
         addBindingName(el.name);
       }
     }
   }
   function visit2(n) {
-    if (import_typescript6.default.isArrowFunction(n) || import_typescript6.default.isFunctionExpression(n) || import_typescript6.default.isFunctionDeclaration(n))
+    if (import_typescript7.default.isArrowFunction(n) || import_typescript7.default.isFunctionExpression(n) || import_typescript7.default.isFunctionDeclaration(n))
       return;
-    if (import_typescript6.default.isVariableDeclaration(n)) {
+    if (import_typescript7.default.isVariableDeclaration(n)) {
       addBindingName(n.name);
     }
-    import_typescript6.default.forEachChild(n, visit2);
+    import_typescript7.default.forEachChild(n, visit2);
   }
   visit2(root);
   return names;
@@ -188798,35 +188953,35 @@ var CLIENT_EXPORTS = new Set([
   "cleanupPortalPlaceholder"
 ]);
 function collectAmbientGlobals(node, ctx) {
-  if (import_typescript6.default.isVariableStatement(node)) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.DeclareKeyword) ?? false;
+  if (import_typescript7.default.isVariableStatement(node)) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.DeclareKeyword) ?? false;
     if (!isDeclare)
       return;
     for (const decl of node.declarationList.declarations) {
-      if (import_typescript6.default.isIdentifier(decl.name))
+      if (import_typescript7.default.isIdentifier(decl.name))
         ctx.ambientGlobals.add(decl.name.text);
     }
     return;
   }
-  if (import_typescript6.default.isFunctionDeclaration(node) && node.name) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.DeclareKeyword) ?? false;
+  if (import_typescript7.default.isFunctionDeclaration(node) && node.name) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.DeclareKeyword) ?? false;
     if (isDeclare)
       ctx.ambientGlobals.add(node.name.text);
     return;
   }
-  if (import_typescript6.default.isModuleDeclaration(node)) {
-    const isGlobalAugmentation = (node.flags & import_typescript6.default.NodeFlags.GlobalAugmentation) !== 0;
+  if (import_typescript7.default.isModuleDeclaration(node)) {
+    const isGlobalAugmentation = (node.flags & import_typescript7.default.NodeFlags.GlobalAugmentation) !== 0;
     if (!isGlobalAugmentation)
       return;
-    if (!node.body || !import_typescript6.default.isModuleBlock(node.body))
+    if (!node.body || !import_typescript7.default.isModuleBlock(node.body))
       return;
     for (const inner of node.body.statements) {
-      if (import_typescript6.default.isVariableStatement(inner)) {
+      if (import_typescript7.default.isVariableStatement(inner)) {
         for (const decl of inner.declarationList.declarations) {
-          if (import_typescript6.default.isIdentifier(decl.name))
+          if (import_typescript7.default.isIdentifier(decl.name))
             ctx.ambientGlobals.add(decl.name.text);
         }
-      } else if (import_typescript6.default.isFunctionDeclaration(inner) && inner.name) {
+      } else if (import_typescript7.default.isFunctionDeclaration(inner) && inner.name) {
         ctx.ambientGlobals.add(inner.name.text);
       }
     }
@@ -188837,7 +188992,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 && import_typescript6.default.isNamedImports(node.importClause.namedBindings)) {
+  if (source === "@barefootjs/client" && !isTypeOnly && node.importClause?.namedBindings && import_typescript7.default.isNamedImports(node.importClause.namedBindings)) {
     const wrongImports = [];
     for (const element of node.importClause.namedBindings.elements) {
       const name = element.propertyName?.text ?? element.name.text;
@@ -188865,7 +189020,7 @@ function collectImport(node, ctx) {
       });
     }
     if (node.importClause.namedBindings) {
-      if (import_typescript6.default.isNamedImports(node.importClause.namedBindings)) {
+      if (import_typescript7.default.isNamedImports(node.importClause.namedBindings)) {
         for (const element of node.importClause.namedBindings.elements) {
           specifiers.push({
             name: element.propertyName?.text ?? element.name.text,
@@ -188875,7 +189030,7 @@ function collectImport(node, ctx) {
           });
         }
       }
-      if (import_typescript6.default.isNamespaceImport(node.importClause.namedBindings)) {
+      if (import_typescript7.default.isNamespaceImport(node.importClause.namedBindings)) {
         specifiers.push({
           name: node.importClause.namedBindings.name.text,
           alias: null,
@@ -188912,20 +189067,20 @@ function extractSingleJsxReturn(body) {
   let jsxReturn = null;
   let returnCount = 0;
   function visit2(node) {
-    if (import_typescript6.default.isFunctionDeclaration(node) || import_typescript6.default.isFunctionExpression(node) || import_typescript6.default.isArrowFunction(node))
+    if (import_typescript7.default.isFunctionDeclaration(node) || import_typescript7.default.isFunctionExpression(node) || import_typescript7.default.isArrowFunction(node))
       return;
-    if (import_typescript6.default.isReturnStatement(node)) {
+    if (import_typescript7.default.isReturnStatement(node)) {
       returnCount++;
       if (node.expression) {
         const expr = unwrapJsxTransparent(node.expression);
-        if (import_typescript6.default.isJsxElement(expr) || import_typescript6.default.isJsxSelfClosingElement(expr) || import_typescript6.default.isJsxFragment(expr)) {
+        if (import_typescript7.default.isJsxElement(expr) || import_typescript7.default.isJsxSelfClosingElement(expr) || import_typescript7.default.isJsxFragment(expr)) {
           jsxReturn = expr;
         }
       }
     }
-    import_typescript6.default.forEachChild(node, visit2);
+    import_typescript7.default.forEachChild(node, visit2);
   }
-  import_typescript6.default.forEachChild(body, visit2);
+  import_typescript7.default.forEachChild(body, visit2);
   if (returnCount !== 1)
     return null;
   return jsxReturn;
@@ -188936,9 +189091,9 @@ function extractMultiReturnJsxBranches(body) {
   const stmts = body.statements;
   for (let i2 = 0;i2 < stmts.length; i2++) {
     const stmt = stmts[i2];
-    if (import_typescript6.default.isIfStatement(stmt)) {
+    if (import_typescript7.default.isIfStatement(stmt)) {
       let current = stmt;
-      while (import_typescript6.default.isIfStatement(current)) {
+      while (import_typescript7.default.isIfStatement(current)) {
         const ifStmt = current;
         if (!isDirectReturnBlock(ifStmt.thenStatement))
           return null;
@@ -188948,7 +189103,7 @@ function extractMultiReturnJsxBranches(body) {
           return null;
         branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null });
         if (ifStmt.elseStatement) {
-          if (import_typescript6.default.isIfStatement(ifStmt.elseStatement)) {
+          if (import_typescript7.default.isIfStatement(ifStmt.elseStatement)) {
             current = ifStmt.elseStatement;
             continue;
           }
@@ -188968,13 +189123,13 @@ function extractMultiReturnJsxBranches(body) {
       }
       continue;
     }
-    if (import_typescript6.default.isSwitchStatement(stmt)) {
+    if (import_typescript7.default.isSwitchStatement(stmt)) {
       if (branches.length > 0)
         return null;
-      if (!import_typescript6.default.isIdentifier(stmt.expression) && !import_typescript6.default.isPropertyAccessExpression(stmt.expression)) {
+      if (!import_typescript7.default.isIdentifier(stmt.expression) && !import_typescript7.default.isPropertyAccessExpression(stmt.expression)) {
         return null;
       }
-      const hasDefault = stmt.caseBlock.clauses.some((c) => import_typescript6.default.isDefaultClause(c));
+      const hasDefault = stmt.caseBlock.clauses.some((c) => import_typescript7.default.isDefaultClause(c));
       if (!hasDefault)
         return null;
       for (const clause of stmt.caseBlock.clauses) {
@@ -188982,7 +189137,7 @@ function extractMultiReturnJsxBranches(body) {
         const nullReturn = findNullReturnInCaseClause(clause);
         if (!jsxReturn && !nullReturn)
           return null;
-        if (import_typescript6.default.isCaseClause(clause)) {
+        if (import_typescript7.default.isCaseClause(clause)) {
           branches.push({
             condition: clause.expression,
             jsxReturn: jsxReturn ?? null
@@ -188995,16 +189150,16 @@ function extractMultiReturnJsxBranches(body) {
         return null;
       return { branches, fallback, switchDiscriminant: stmt.expression };
     }
-    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+    if (import_typescript7.default.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (import_typescript6.default.isJsxElement(expr) || import_typescript6.default.isJsxSelfClosingElement(expr) || import_typescript6.default.isJsxFragment(expr)) {
+      if (import_typescript7.default.isJsxElement(expr) || import_typescript7.default.isJsxSelfClosingElement(expr) || import_typescript7.default.isJsxFragment(expr)) {
         fallback = expr;
-      } else if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword) {} else {
+      } else if (expr.kind === import_typescript7.default.SyntaxKind.NullKeyword) {} else {
         return null;
       }
       continue;
     }
-    if (import_typescript6.default.isVariableStatement(stmt))
+    if (import_typescript7.default.isVariableStatement(stmt))
       return null;
     return null;
   }
@@ -189013,14 +189168,14 @@ function extractMultiReturnJsxBranches(body) {
   return { branches, fallback };
 }
 function isDirectReturnBlock(node) {
-  if (import_typescript6.default.isReturnStatement(node))
+  if (import_typescript7.default.isReturnStatement(node))
     return true;
-  if (import_typescript6.default.isBlock(node)) {
+  if (import_typescript7.default.isBlock(node)) {
     let returnCount = 0;
     for (const stmt of node.statements) {
-      if (import_typescript6.default.isReturnStatement(stmt)) {
+      if (import_typescript7.default.isReturnStatement(stmt)) {
         returnCount++;
-      } else if (import_typescript6.default.isIfStatement(stmt) || import_typescript6.default.isSwitchStatement(stmt) || import_typescript6.default.isForStatement(stmt) || import_typescript6.default.isForOfStatement(stmt) || import_typescript6.default.isForInStatement(stmt) || import_typescript6.default.isWhileStatement(stmt) || import_typescript6.default.isDoStatement(stmt) || import_typescript6.default.isTryStatement(stmt)) {
+      } else if (import_typescript7.default.isIfStatement(stmt) || import_typescript7.default.isSwitchStatement(stmt) || import_typescript7.default.isForStatement(stmt) || import_typescript7.default.isForOfStatement(stmt) || import_typescript7.default.isForInStatement(stmt) || import_typescript7.default.isWhileStatement(stmt) || import_typescript7.default.isDoStatement(stmt) || import_typescript7.default.isTryStatement(stmt)) {
         return false;
       }
     }
@@ -189029,25 +189184,25 @@ function isDirectReturnBlock(node) {
   return false;
 }
 function findNullReturnInBlock(node) {
-  if (import_typescript6.default.isBlock(node)) {
+  if (import_typescript7.default.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+      if (import_typescript7.default.isReturnStatement(stmt) && stmt.expression) {
         const expr = unwrapJsxTransparent(stmt.expression);
-        if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+        if (expr.kind === import_typescript7.default.SyntaxKind.NullKeyword)
           return true;
       }
     }
   }
-  if (import_typescript6.default.isReturnStatement(node) && node.expression) {
+  if (import_typescript7.default.isReturnStatement(node) && node.expression) {
     const expr = unwrapJsxTransparent(node.expression);
-    if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+    if (expr.kind === import_typescript7.default.SyntaxKind.NullKeyword)
       return true;
   }
   return false;
 }
 function findJsxReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+    if (import_typescript7.default.isReturnStatement(stmt) && stmt.expression) {
       return extractJsxFromExpression(stmt.expression);
     }
   }
@@ -189055,9 +189210,9 @@ function findJsxReturnInCaseClause(clause) {
 }
 function findNullReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+    if (import_typescript7.default.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+      if (expr.kind === import_typescript7.default.SyntaxKind.NullKeyword)
         return true;
     }
   }
@@ -189068,26 +189223,26 @@ function isMultiReturnJsxFunctionBody(body) {
   let hasJsxReturn = false;
   let allReturnsAreJsxOrNull = true;
   function visit2(node) {
-    if (import_typescript6.default.isFunctionDeclaration(node) || import_typescript6.default.isFunctionExpression(node) || import_typescript6.default.isArrowFunction(node))
+    if (import_typescript7.default.isFunctionDeclaration(node) || import_typescript7.default.isFunctionExpression(node) || import_typescript7.default.isArrowFunction(node))
       return;
-    if (import_typescript6.default.isReturnStatement(node)) {
+    if (import_typescript7.default.isReturnStatement(node)) {
       returnCount++;
       if (!node.expression) {
         allReturnsAreJsxOrNull = false;
         return;
       }
       const expr = unwrapJsxTransparent(node.expression);
-      const isJsx = import_typescript6.default.isJsxElement(expr) || import_typescript6.default.isJsxSelfClosingElement(expr) || import_typescript6.default.isJsxFragment(expr);
-      const isNull2 = expr.kind === import_typescript6.default.SyntaxKind.NullKeyword;
+      const isJsx = import_typescript7.default.isJsxElement(expr) || import_typescript7.default.isJsxSelfClosingElement(expr) || import_typescript7.default.isJsxFragment(expr);
+      const isNull2 = expr.kind === import_typescript7.default.SyntaxKind.NullKeyword;
       if (isJsx)
         hasJsxReturn = true;
       if (!isJsx && !isNull2)
         allReturnsAreJsxOrNull = false;
       return;
     }
-    import_typescript6.default.forEachChild(node, visit2);
+    import_typescript7.default.forEachChild(node, visit2);
   }
-  import_typescript6.default.forEachChild(body, visit2);
+  import_typescript7.default.forEachChild(body, visit2);
   return returnCount > 1 && hasJsxReturn && allReturnsAreJsxOrNull;
 }
 function collectFunction(node, ctx, _isModule, isExported = false) {
@@ -189157,7 +189312,7 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
       }
     }
   }
-  const isAsync = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.AsyncKeyword) ?? false;
+  const isAsync = node.modifiers?.some((m) => m.kind === import_typescript7.default.SyntaxKind.AsyncKeyword) ?? false;
   const isGenerator = !!node.asteriskToken;
   ctx.localFunctions.push({
     name,
@@ -189178,10 +189333,10 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
   });
 }
 function extractValueBranches(node, ctx) {
-  if (import_typescript6.default.isParenthesizedExpression(node)) {
+  if (import_typescript7.default.isParenthesizedExpression(node)) {
     return extractValueBranches(node.expression, ctx);
   }
-  if (import_typescript6.default.isConditionalExpression(node)) {
+  if (import_typescript7.default.isConditionalExpression(node)) {
     return [
       ...extractValueBranches(node.whenTrue, ctx),
       ...extractValueBranches(node.whenFalse, ctx)
@@ -189193,46 +189348,46 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundNames = new Set;
   function addBindingNames(name, out) {
-    if (import_typescript6.default.isIdentifier(name))
+    if (import_typescript7.default.isIdentifier(name))
       out.push(name.text);
-    else if (import_typescript6.default.isObjectBindingPattern(name))
+    else if (import_typescript7.default.isObjectBindingPattern(name))
       name.elements.forEach((e) => addBindingNames(e.name, out));
-    else if (import_typescript6.default.isArrayBindingPattern(name))
+    else if (import_typescript7.default.isArrayBindingPattern(name))
       name.elements.forEach((e) => {
-        if (!import_typescript6.default.isOmittedExpression(e))
+        if (!import_typescript7.default.isOmittedExpression(e))
           addBindingNames(e.name, out);
       });
   }
   function visit2(n) {
-    if (import_typescript6.default.isTypeNode(n))
+    if (import_typescript7.default.isTypeNode(n))
       return;
-    if (import_typescript6.default.isIdentifier(n)) {
+    if (import_typescript7.default.isIdentifier(n)) {
       const parent = n.parent;
-      if (parent && import_typescript6.default.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && import_typescript7.default.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && import_typescript6.default.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && import_typescript7.default.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && import_typescript6.default.isParameter(parent) && parent.name === n)
+      if (parent && import_typescript7.default.isParameter(parent) && parent.name === n)
         return;
-      if (parent && import_typescript6.default.isVariableDeclaration(parent) && parent.name === n)
+      if (parent && import_typescript7.default.isVariableDeclaration(parent) && parent.name === n)
         return;
       if (boundNames.has(n.text))
         return;
       ids.add(n.text);
       return;
     }
-    if (import_typescript6.default.isArrowFunction(n)) {
+    if (import_typescript7.default.isArrowFunction(n)) {
       const params = [];
       for (const p of n.parameters)
         addBindingNames(p.name, params);
       for (const name of params)
         boundNames.add(name);
-      import_typescript6.default.forEachChild(n, visit2);
+      import_typescript7.default.forEachChild(n, visit2);
       for (const name of params)
         boundNames.delete(name);
       return;
     }
-    import_typescript6.default.forEachChild(n, visit2);
+    import_typescript7.default.forEachChild(n, visit2);
   }
   visit2(node);
   return ids;
@@ -189242,22 +189397,22 @@ function initializerShapeContainsJsx(node) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript6.default.isJsxElement(n) || import_typescript6.default.isJsxSelfClosingElement(n) || import_typescript6.default.isJsxFragment(n)) {
+    if (import_typescript7.default.isJsxElement(n) || import_typescript7.default.isJsxSelfClosingElement(n) || import_typescript7.default.isJsxFragment(n)) {
       found = true;
       return;
     }
-    if (import_typescript6.default.isFunctionDeclaration(n) || import_typescript6.default.isFunctionExpression(n) || import_typescript6.default.isArrowFunction(n)) {
+    if (import_typescript7.default.isFunctionDeclaration(n) || import_typescript7.default.isFunctionExpression(n) || import_typescript7.default.isArrowFunction(n)) {
       return;
     }
-    import_typescript6.default.forEachChild(n, visit2);
+    import_typescript7.default.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
 }
 function isMapLikeCallWithJsx(node) {
-  if (!import_typescript6.default.isCallExpression(node))
+  if (!import_typescript7.default.isCallExpression(node))
     return false;
-  if (!import_typescript6.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript7.default.isPropertyAccessExpression(node.expression))
     return false;
   const method = node.expression.name.text;
   if (method !== "map" && method !== "flatMap")
@@ -189265,12 +189420,12 @@ function isMapLikeCallWithJsx(node) {
   const callback = node.arguments[0];
   if (!callback)
     return false;
-  if (!import_typescript6.default.isArrowFunction(callback) && !import_typescript6.default.isFunctionExpression(callback))
+  if (!import_typescript7.default.isArrowFunction(callback) && !import_typescript7.default.isFunctionExpression(callback))
     return false;
   return containsJsxDeep(callback.body);
 }
 function containsJsxDeep(node) {
-  if (import_typescript6.default.isJsxElement(node) || import_typescript6.default.isJsxSelfClosingElement(node) || import_typescript6.default.isJsxFragment(node))
+  if (import_typescript7.default.isJsxElement(node) || import_typescript7.default.isJsxSelfClosingElement(node) || import_typescript7.default.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -189284,11 +189439,11 @@ function nodeContainsArrow(node) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript6.default.isArrowFunction(n) || import_typescript6.default.isFunctionExpression(n)) {
+    if (import_typescript7.default.isArrowFunction(n) || import_typescript7.default.isFunctionExpression(n)) {
       found = true;
       return;
     }
-    import_typescript6.default.forEachChild(n, visit2);
+    import_typescript7.default.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
@@ -189336,20 +189491,20 @@ function collectModuleScopeReactive(decl, ctx, isExported) {
   }));
 }
 function getSystemConstructKind(node) {
-  if (import_typescript6.default.isCallExpression(node) && import_typescript6.default.isIdentifier(node.expression) && node.expression.text === "createContext")
+  if (import_typescript7.default.isCallExpression(node) && import_typescript7.default.isIdentifier(node.expression) && node.expression.text === "createContext")
     return "createContext";
-  if (import_typescript6.default.isNewExpression(node) && import_typescript6.default.isIdentifier(node.expression) && node.expression.text === "WeakMap")
+  if (import_typescript7.default.isNewExpression(node) && import_typescript7.default.isIdentifier(node.expression) && node.expression.text === "WeakMap")
     return "weakMap";
   return;
 }
 function collectConstant(node, ctx, _isModule, declarationKind = "const", isExported = false) {
-  if (!_isModule && import_typescript6.default.isObjectBindingPattern(node.name) && node.initializer && import_typescript6.default.isIdentifier(node.initializer) && ctx.propsObjectName === node.initializer.text) {
+  if (!_isModule && import_typescript7.default.isObjectBindingPattern(node.name) && node.initializer && import_typescript7.default.isIdentifier(node.initializer) && ctx.propsObjectName === node.initializer.text) {
     const propsName = node.initializer.text;
     for (const el of node.name.elements) {
-      if (!import_typescript6.default.isBindingElement(el) || !import_typescript6.default.isIdentifier(el.name) || el.dotDotDotToken)
+      if (!import_typescript7.default.isBindingElement(el) || !import_typescript7.default.isIdentifier(el.name) || el.dotDotDotToken)
         continue;
       const localName = el.name.text;
-      const sourceKey = el.propertyName && import_typescript6.default.isIdentifier(el.propertyName) ? el.propertyName.text : localName;
+      const sourceKey = el.propertyName && import_typescript7.default.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;
@@ -189369,7 +189524,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     }
     return;
   }
-  if (!import_typescript6.default.isIdentifier(node.name))
+  if (!import_typescript7.default.isIdentifier(node.name))
     return;
   if (isSignalDeclaration(node, ctx) || isMemoDeclaration(node, ctx))
     return;
@@ -189387,9 +189542,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let isJsxFunction = false;
   if (node.initializer) {
     let init = node.initializer;
-    while (import_typescript6.default.isParenthesizedExpression(init))
+    while (import_typescript7.default.isParenthesizedExpression(init))
       init = init.expression;
-    if (import_typescript6.default.isJsxElement(init) || import_typescript6.default.isJsxSelfClosingElement(init) || import_typescript6.default.isJsxFragment(init)) {
+    if (import_typescript7.default.isJsxElement(init) || import_typescript7.default.isJsxSelfClosingElement(init) || import_typescript7.default.isJsxFragment(init)) {
       isJsx = true;
       ctx.jsxConstants.set(name, init);
     } else if (initializerShapeContainsJsx(init)) {
@@ -189397,9 +189552,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     } else if (isMapLikeCallWithJsx(init)) {
       ctx.inlineableJsxConsts.set(name, init);
     }
-    if (import_typescript6.default.isArrowFunction(init)) {
+    if (import_typescript7.default.isArrowFunction(init)) {
       const arrowBody = init.body;
-      if (import_typescript6.default.isBlock(arrowBody)) {
+      if (import_typescript7.default.isBlock(arrowBody)) {
         const jsxReturn = extractSingleJsxReturn(arrowBody);
         if (jsxReturn) {
           isJsxFunction = true;
@@ -189419,9 +189574,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
         }
       } else {
         let body = arrowBody;
-        while (import_typescript6.default.isParenthesizedExpression(body))
+        while (import_typescript7.default.isParenthesizedExpression(body))
           body = body.expression;
-        if (import_typescript6.default.isJsxElement(body) || import_typescript6.default.isJsxSelfClosingElement(body) || import_typescript6.default.isJsxFragment(body)) {
+        if (import_typescript7.default.isJsxElement(body) || import_typescript7.default.isJsxSelfClosingElement(body) || import_typescript7.default.isJsxFragment(body)) {
           isJsxFunction = true;
           ctx.jsxFunctions.set(name, {
             jsxReturn: body,
@@ -189434,9 +189589,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let valueBranches;
   if (node.initializer) {
     let inner = node.initializer;
-    while (import_typescript6.default.isParenthesizedExpression(inner))
+    while (import_typescript7.default.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (import_typescript6.default.isConditionalExpression(inner)) {
+    if (import_typescript7.default.isConditionalExpression(inner)) {
       valueBranches = extractValueBranches(node.initializer, ctx);
     }
   }
@@ -189509,7 +189664,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
 function hasIgnoreDirective(node, sourceFile, ruleId) {
   const checkComments = (targetNode) => {
     const fullStart = targetNode.getFullStart();
-    const leadingComments = import_typescript6.default.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
+    const leadingComments = import_typescript7.default.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
     if (!leadingComments)
       return false;
     for (const range of leadingComments) {
@@ -189522,10 +189677,10 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   };
   if (checkComments(node))
     return true;
-  if (import_typescript6.default.isArrowFunction(node)) {
+  if (import_typescript7.default.isArrowFunction(node)) {
     let current = node.parent;
     while (current) {
-      if (import_typescript6.default.isVariableStatement(current)) {
+      if (import_typescript7.default.isVariableStatement(current)) {
         if (checkComments(current))
           return true;
         break;
@@ -189536,7 +189691,7 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   return false;
 }
 function extractProps(param, ctx) {
-  if (import_typescript6.default.isObjectBindingPattern(param.name)) {
+  if (import_typescript7.default.isObjectBindingPattern(param.name)) {
     const componentNode = ctx.componentNode;
     const ignored = !!(componentNode && hasIgnoreDirective(componentNode, ctx.sourceFile, "props-destructuring"));
     ctx.propsDestructuring = {
@@ -189544,7 +189699,7 @@ function extractProps(param, ctx) {
       hasIgnoreDirective: ignored
     };
     for (const element of param.name.elements) {
-      if (import_typescript6.default.isBindingElement(element) && import_typescript6.default.isIdentifier(element.name)) {
+      if (import_typescript7.default.isBindingElement(element) && import_typescript7.default.isIdentifier(element.name)) {
         const localName = element.name.text;
         const defaultValue = element.initializer ? ctx.getJS(element.initializer) : undefined;
         if (element.dotDotDotToken) {
@@ -189569,7 +189724,7 @@ function extractProps(param, ctx) {
       }
     }
   }
-  if (import_typescript6.default.isIdentifier(param.name)) {
+  if (import_typescript7.default.isIdentifier(param.name)) {
     ctx.propsObjectName = param.name.text;
     if (param.type) {
       extractPropsFromType(param.type, ctx);
@@ -189580,24 +189735,24 @@ function extractProps(param, ctx) {
   }
 }
 function collectTypeKeys(typeNode, ctx) {
-  if (import_typescript6.default.isTypeLiteralNode(typeNode)) {
+  if (import_typescript7.default.isTypeLiteralNode(typeNode)) {
     return collectKeysFromMembers(typeNode.members, ctx);
   }
-  if (import_typescript6.default.isTypeReferenceNode(typeNode)) {
+  if (import_typescript7.default.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (!typeDecl)
       return null;
-    if (import_typescript6.default.isInterfaceDeclaration(typeDecl)) {
+    if (import_typescript7.default.isInterfaceDeclaration(typeDecl)) {
       if (typeDecl.heritageClauses && typeDecl.heritageClauses.length > 0)
         return null;
       return collectKeysFromMembers(typeDecl.members, ctx);
     }
-    if (import_typescript6.default.isTypeAliasDeclaration(typeDecl)) {
-      if (import_typescript6.default.isTypeLiteralNode(typeDecl.type)) {
+    if (import_typescript7.default.isTypeAliasDeclaration(typeDecl)) {
+      if (import_typescript7.default.isTypeLiteralNode(typeDecl.type)) {
         return collectKeysFromMembers(typeDecl.type.members, ctx);
       }
-      if (import_typescript6.default.isIntersectionTypeNode(typeDecl.type)) {
+      if (import_typescript7.default.isIntersectionTypeNode(typeDecl.type)) {
         return null;
       }
     }
@@ -189607,26 +189762,26 @@ function collectTypeKeys(typeNode, ctx) {
 function collectKeysFromMembers(members, ctx) {
   const keys = [];
   for (const member of members) {
-    if (import_typescript6.default.isIndexSignatureDeclaration(member))
+    if (import_typescript7.default.isIndexSignatureDeclaration(member))
       return null;
-    if (import_typescript6.default.isPropertySignature(member) && member.name) {
+    if (import_typescript7.default.isPropertySignature(member) && member.name) {
       keys.push(member.name.getText(ctx.sourceFile));
     }
   }
   return keys;
 }
 function extractPropsFromType(typeNode, ctx) {
-  if (import_typescript6.default.isTypeLiteralNode(typeNode)) {
+  if (import_typescript7.default.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
     return;
   }
-  if (import_typescript6.default.isTypeReferenceNode(typeNode)) {
+  if (import_typescript7.default.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (typeDecl) {
-      if (import_typescript6.default.isInterfaceDeclaration(typeDecl)) {
+      if (import_typescript7.default.isInterfaceDeclaration(typeDecl)) {
         extractPropsFromTypeMembers(typeDecl.members, ctx);
-      } else if (import_typescript6.default.isTypeAliasDeclaration(typeDecl) && import_typescript6.default.isTypeLiteralNode(typeDecl.type)) {
+      } else if (import_typescript7.default.isTypeAliasDeclaration(typeDecl) && import_typescript7.default.isTypeLiteralNode(typeDecl.type)) {
         extractPropsFromTypeMembers(typeDecl.type.members, ctx);
       }
     }
@@ -189634,7 +189789,7 @@ function extractPropsFromType(typeNode, ctx) {
 }
 function extractPropsFromTypeMembers(members, ctx) {
   for (const member of members) {
-    if (import_typescript6.default.isPropertySignature(member) && member.name) {
+    if (import_typescript7.default.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" };
@@ -189650,17 +189805,17 @@ function extractPropsFromTypeMembers(members, ctx) {
 function findTypeDeclaration(typeName, sourceFile) {
   let result;
   function visit2(node) {
-    if (import_typescript6.default.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (import_typescript7.default.isInterfaceDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    if (import_typescript6.default.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    if (import_typescript7.default.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    import_typescript6.default.forEachChild(node, visit2);
+    import_typescript7.default.forEachChild(node, visit2);
   }
-  import_typescript6.default.forEachChild(sourceFile, visit2);
+  import_typescript7.default.forEachChild(sourceFile, visit2);
   return result;
 }
 function inferTypeFromValue(value) {
@@ -189794,16 +189949,16 @@ function isResolvableComponentSource(source) {
 function collectJsxComponentTags(sourceFile) {
   const tags = new Set;
   function visit2(node) {
-    if (import_typescript6.default.isJsxOpeningElement(node) || import_typescript6.default.isJsxSelfClosingElement(node)) {
+    if (import_typescript7.default.isJsxOpeningElement(node) || import_typescript7.default.isJsxSelfClosingElement(node)) {
       const tagName = node.tagName;
-      if (import_typescript6.default.isIdentifier(tagName)) {
+      if (import_typescript7.default.isIdentifier(tagName)) {
         const first = tagName.text.charAt(0);
         if (first >= "A" && first <= "Z") {
           tags.add(tagName.text);
         }
       }
     }
-    import_typescript6.default.forEachChild(node, visit2);
+    import_typescript7.default.forEachChild(node, visit2);
   }
   visit2(sourceFile);
   return tags;
@@ -189882,18 +190037,18 @@ function fileHasUseClientDirective(filePath) {
   } catch {
     return true;
   }
-  const sf = import_typescript6.default.createSourceFile(filePath, content, import_typescript6.default.ScriptTarget.Latest, false, import_typescript6.default.ScriptKind.TSX);
+  const sf = import_typescript7.default.createSourceFile(filePath, content, import_typescript7.default.ScriptTarget.Latest, false, import_typescript7.default.ScriptKind.TSX);
   let found = false;
   function visit2(node) {
     if (found)
       return;
-    if (import_typescript6.default.isExpressionStatement(node) && import_typescript6.default.isStringLiteral(node.expression)) {
+    if (import_typescript7.default.isExpressionStatement(node) && import_typescript7.default.isStringLiteral(node.expression)) {
       if (node.expression.text === "use client") {
         found = true;
         return;
       }
     }
-    import_typescript6.default.forEachChild(node, visit2);
+    import_typescript7.default.forEachChild(node, visit2);
   }
   visit2(sf);
   return found;
@@ -189976,16 +190131,16 @@ var REACTIVE_PRIMITIVES = new Set([
   "onCleanup"
 ]);
 function prescanReactiveFactoriesInSource(source, filePath) {
-  const sourceFile = import_typescript6.default.createSourceFile(filePath + ".prescan", source, import_typescript6.default.ScriptTarget.Latest, true, import_typescript6.default.ScriptKind.TSX);
+  const sourceFile = import_typescript7.default.createSourceFile(filePath + ".prescan", source, import_typescript7.default.ScriptTarget.Latest, true, import_typescript7.default.ScriptKind.TSX);
   const factories = new Map;
   function visitTop(node) {
-    if (import_typescript6.default.isFunctionDeclaration(node) && node.name && node.body) {
+    if (import_typescript7.default.isFunctionDeclaration(node) && node.name && node.body) {
       const info = detectReactiveFactory(node, sourceFile, filePath);
       if (info)
         factories.set(node.name.text, info);
     }
   }
-  import_typescript6.default.forEachChild(sourceFile, visitTop);
+  import_typescript7.default.forEachChild(sourceFile, visitTop);
   return { factories, sourceFile };
 }
 function detectReactiveFactory(node, sourceFile, filePath) {
@@ -189994,19 +190149,19 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   let tupleReturn = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
-    if (!import_typescript6.default.isReturnStatement(stmt))
+    if (!import_typescript7.default.isReturnStatement(stmt))
       continue;
     returnCount++;
     if (!stmt.expression)
       return null;
     let expr = stmt.expression;
-    while (import_typescript6.default.isParenthesizedExpression(expr))
+    while (import_typescript7.default.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (import_typescript6.default.isAsExpression(expr))
+    if (import_typescript7.default.isAsExpression(expr))
       expr = expr.expression;
-    if (import_typescript6.default.isTypeAssertionExpression(expr))
+    if (import_typescript7.default.isTypeAssertionExpression(expr))
       expr = expr.expression;
-    if (!import_typescript6.default.isArrayLiteralExpression(expr))
+    if (!import_typescript7.default.isArrayLiteralExpression(expr))
       return null;
     tupleReturn = expr;
   }
@@ -190014,7 +190169,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
     return null;
   const returnTupleIdentifiers = [];
   for (const el of tupleReturn.elements) {
-    if (!import_typescript6.default.isIdentifier(el))
+    if (!import_typescript7.default.isIdentifier(el))
       return null;
     returnTupleIdentifiers.push(el.text);
   }
@@ -190024,29 +190179,29 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   function checkForReactive(n) {
     if (hasReactiveCall)
       return;
-    if (import_typescript6.default.isCallExpression(n) && import_typescript6.default.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
+    if (import_typescript7.default.isCallExpression(n) && import_typescript7.default.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
       hasReactiveCall = true;
       return;
     }
-    import_typescript6.default.forEachChild(n, checkForReactive);
+    import_typescript7.default.forEachChild(n, checkForReactive);
   }
   checkForReactive(node.body);
   if (!hasReactiveCall)
     return null;
   const localBindings = [];
   for (const stmt of node.body.statements) {
-    if (import_typescript6.default.isVariableStatement(stmt)) {
+    if (import_typescript7.default.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
         addBindingNames(decl.name, localBindings);
       }
-    } else if (import_typescript6.default.isFunctionDeclaration(stmt) && stmt.name) {
+    } else if (import_typescript7.default.isFunctionDeclaration(stmt) && stmt.name) {
       localBindings.push(stmt.name.text);
     }
   }
-  const bodyStatements = node.body.statements.filter((s) => !import_typescript6.default.isReturnStatement(s)).map((s) => s.getText(sourceFile)).join(`
+  const bodyStatements = node.body.statements.filter((s) => !import_typescript7.default.isReturnStatement(s)).map((s) => s.getText(sourceFile)).join(`
 `);
   const params = node.parameters.map((p) => {
-    if (import_typescript6.default.isIdentifier(p.name))
+    if (import_typescript7.default.isIdentifier(p.name))
       return p.name.text;
     return "";
   });
@@ -190061,18 +190216,18 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   };
 }
 function addBindingNames(name, out) {
-  if (import_typescript6.default.isIdentifier(name)) {
+  if (import_typescript7.default.isIdentifier(name)) {
     out.push(name.text);
     return;
   }
-  if (import_typescript6.default.isObjectBindingPattern(name)) {
+  if (import_typescript7.default.isObjectBindingPattern(name)) {
     for (const el of name.elements)
       addBindingNames(el.name, out);
     return;
   }
-  if (import_typescript6.default.isArrayBindingPattern(name)) {
+  if (import_typescript7.default.isArrayBindingPattern(name)) {
     for (const el of name.elements) {
-      if (import_typescript6.default.isOmittedExpression(el))
+      if (import_typescript7.default.isOmittedExpression(el))
         continue;
       addBindingNames(el.name, out);
     }
@@ -190083,23 +190238,23 @@ function rewriteFactoryCallsInSource(source, prescan) {
   const edits = [];
   let callSiteIndex = 0;
   function visitStmt(node, inComponent) {
-    if (import_typescript6.default.isVariableStatement(node) && inComponent) {
+    if (import_typescript7.default.isVariableStatement(node) && inComponent) {
       for (const decl of node.declarationList.declarations) {
         maybeRewriteDecl(node, decl);
       }
     }
-    import_typescript6.default.forEachChild(node, (child) => {
-      if (import_typescript6.default.isFunctionDeclaration(child) && child.name && factories.has(child.name.text))
+    import_typescript7.default.forEachChild(node, (child) => {
+      if (import_typescript7.default.isFunctionDeclaration(child) && child.name && factories.has(child.name.text))
         return;
       visitStmt(child, inComponent || isPascalCaseComponentFn(child));
     });
   }
   function maybeRewriteDecl(stmt, decl) {
-    if (!import_typescript6.default.isArrayBindingPattern(decl.name))
+    if (!import_typescript7.default.isArrayBindingPattern(decl.name))
       return;
-    if (!decl.initializer || !import_typescript6.default.isCallExpression(decl.initializer))
+    if (!decl.initializer || !import_typescript7.default.isCallExpression(decl.initializer))
       return;
-    if (!import_typescript6.default.isIdentifier(decl.initializer.expression))
+    if (!import_typescript7.default.isIdentifier(decl.initializer.expression))
       return;
     const factoryName = decl.initializer.expression.text;
     const factory = factories.get(factoryName);
@@ -190110,7 +190265,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
       return;
     const callerNames = [];
     for (const el of elements) {
-      if (import_typescript6.default.isOmittedExpression(el) || !import_typescript6.default.isIdentifier(el.name))
+      if (import_typescript7.default.isOmittedExpression(el) || !import_typescript7.default.isIdentifier(el.name))
         return;
       callerNames.push(el.name.text);
     }
@@ -190155,10 +190310,10 @@ function rewriteFactoryCallsInSource(source, prescan) {
   return out;
 }
 function isPascalCaseComponentFn(node) {
-  if (import_typescript6.default.isFunctionDeclaration(node) && node.name) {
+  if (import_typescript7.default.isFunctionDeclaration(node) && node.name) {
     return /^[A-Z]/.test(node.name.text);
   }
-  if (import_typescript6.default.isVariableDeclaration(node) && import_typescript6.default.isIdentifier(node.name) && node.initializer && import_typescript6.default.isArrowFunction(node.initializer)) {
+  if (import_typescript7.default.isVariableDeclaration(node) && import_typescript7.default.isIdentifier(node.name) && node.initializer && import_typescript7.default.isArrowFunction(node.initializer)) {
     return /^[A-Z]/.test(node.name.text);
   }
   return false;
@@ -190169,18 +190324,18 @@ function escapeRegex(s) {
 function validateReactiveFactoryCalls(ctx) {
   if (!ctx.componentNode)
     return;
-  const body = import_typescript6.default.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : import_typescript6.default.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
+  const body = import_typescript7.default.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : import_typescript7.default.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
   if (!body)
     return;
   for (const stmt of body.statements) {
-    if (!import_typescript6.default.isVariableStatement(stmt))
+    if (!import_typescript7.default.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!import_typescript6.default.isArrayBindingPattern(decl.name))
+      if (!import_typescript7.default.isArrayBindingPattern(decl.name))
         continue;
-      if (!decl.initializer || !import_typescript6.default.isCallExpression(decl.initializer))
+      if (!decl.initializer || !import_typescript7.default.isCallExpression(decl.initializer))
         continue;
-      if (!import_typescript6.default.isIdentifier(decl.initializer.expression))
+      if (!import_typescript7.default.isIdentifier(decl.initializer.expression))
         continue;
       const callee = decl.initializer.expression.text;
       if (callee === "createSignal" || callee === "createMemo")
@@ -190197,7 +190352,7 @@ function validateReactiveFactoryCalls(ctx) {
 }
 
 // ../jsx/src/jsx-to-ir.ts
-var import_typescript10 = __toESM(require_typescript(), 1);
+var import_typescript11 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -190270,7 +190425,7 @@ var AttrValueOf = {
 };
 
 // ../jsx/src/expression-parser.ts
-var import_typescript7 = __toESM(require_typescript(), 1);
+var import_typescript8 = __toESM(require_typescript(), 1);
 var UNSUPPORTED_METHODS = new Set([
   "filter",
   "map",
@@ -190287,37 +190442,37 @@ function parseExpression(expr) {
   if (!trimmed) {
     return { kind: "unsupported", raw: expr, reason: "Empty expression" };
   }
-  const sourceFile = import_typescript7.default.createSourceFile("expression.ts", trimmed, import_typescript7.default.ScriptTarget.Latest, true, import_typescript7.default.ScriptKind.TSX);
+  const sourceFile = import_typescript8.default.createSourceFile("expression.ts", trimmed, import_typescript8.default.ScriptTarget.Latest, true, import_typescript8.default.ScriptKind.TSX);
   if (sourceFile.statements.length === 0) {
     return { kind: "unsupported", raw: expr, reason: "No statements found" };
   }
   const firstStmt = sourceFile.statements[0];
-  if (!import_typescript7.default.isExpressionStatement(firstStmt)) {
+  if (!import_typescript8.default.isExpressionStatement(firstStmt)) {
     return { kind: "unsupported", raw: expr, reason: "Not an expression statement" };
   }
   return convertNode(firstStmt.expression, expr);
 }
 function convertNode(node, raw) {
-  if (import_typescript7.default.isIdentifier(node)) {
+  if (import_typescript8.default.isIdentifier(node)) {
     return { kind: "identifier", name: node.text };
   }
-  if (import_typescript7.default.isStringLiteral(node)) {
+  if (import_typescript8.default.isStringLiteral(node)) {
     return { kind: "literal", value: node.text, literalType: "string" };
   }
-  if (import_typescript7.default.isNumericLiteral(node)) {
+  if (import_typescript8.default.isNumericLiteral(node)) {
     const value = parseFloat(node.text);
     return { kind: "literal", value, literalType: "number" };
   }
-  if (node.kind === import_typescript7.default.SyntaxKind.TrueKeyword) {
+  if (node.kind === import_typescript8.default.SyntaxKind.TrueKeyword) {
     return { kind: "literal", value: true, literalType: "boolean" };
   }
-  if (node.kind === import_typescript7.default.SyntaxKind.FalseKeyword) {
+  if (node.kind === import_typescript8.default.SyntaxKind.FalseKeyword) {
     return { kind: "literal", value: false, literalType: "boolean" };
   }
-  if (node.kind === import_typescript7.default.SyntaxKind.NullKeyword) {
+  if (node.kind === import_typescript8.default.SyntaxKind.NullKeyword) {
     return { kind: "literal", value: null, literalType: "null" };
   }
-  if (import_typescript7.default.isCallExpression(node)) {
+  if (import_typescript8.default.isCallExpression(node)) {
     const callee = convertNode(node.expression, raw);
     const args = node.arguments.map((arg) => convertNode(arg, raw));
     if (callee.kind === "member" && ["filter", "every", "some", "find", "findIndex", "findLast", "findLastIndex"].includes(callee.property)) {
@@ -190397,57 +190552,57 @@ function convertNode(node, raw) {
     }
     return { kind: "call", callee, args };
   }
-  if (import_typescript7.default.isArrayLiteralExpression(node)) {
+  if (import_typescript8.default.isArrayLiteralExpression(node)) {
     const elements = node.elements.map((el) => convertNode(el, raw));
     return { kind: "array-literal", elements };
   }
-  if (import_typescript7.default.isPropertyAccessExpression(node)) {
+  if (import_typescript8.default.isPropertyAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const property = node.name.text;
     return { kind: "member", object, property, computed: false };
   }
-  if (import_typescript7.default.isElementAccessExpression(node)) {
+  if (import_typescript8.default.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const argNode = node.argumentExpression;
-    if (import_typescript7.default.isNumericLiteral(argNode)) {
+    if (import_typescript8.default.isNumericLiteral(argNode)) {
       return { kind: "member", object, property: argNode.text, computed: true };
     }
-    if (import_typescript7.default.isStringLiteral(argNode)) {
+    if (import_typescript8.default.isStringLiteral(argNode)) {
       return { kind: "member", object, property: argNode.text, computed: true };
     }
     return { kind: "unsupported", raw, reason: "Complex computed property access" };
   }
-  if (import_typescript7.default.isBinaryExpression(node)) {
+  if (import_typescript8.default.isBinaryExpression(node)) {
     const left = convertNode(node.left, raw);
     const right = convertNode(node.right, raw);
     const opToken = node.operatorToken;
-    if (opToken.kind === import_typescript7.default.SyntaxKind.AmpersandAmpersandToken) {
+    if (opToken.kind === import_typescript8.default.SyntaxKind.AmpersandAmpersandToken) {
       return { kind: "logical", op: "&&", left, right };
     }
-    if (opToken.kind === import_typescript7.default.SyntaxKind.BarBarToken) {
+    if (opToken.kind === import_typescript8.default.SyntaxKind.BarBarToken) {
       return { kind: "logical", op: "||", left, right };
     }
-    if (opToken.kind === import_typescript7.default.SyntaxKind.QuestionQuestionToken) {
+    if (opToken.kind === import_typescript8.default.SyntaxKind.QuestionQuestionToken) {
       return { kind: "logical", op: "??", left, right };
     }
     const op = getOperatorString(opToken.kind);
     return { kind: "binary", op, left, right };
   }
-  if (import_typescript7.default.isPrefixUnaryExpression(node)) {
+  if (import_typescript8.default.isPrefixUnaryExpression(node)) {
     const argument = convertNode(node.operand, raw);
     const op = getUnaryOperatorString(node.operator);
     return { kind: "unary", op, argument };
   }
-  if (import_typescript7.default.isConditionalExpression(node)) {
+  if (import_typescript8.default.isConditionalExpression(node)) {
     const test = convertNode(node.condition, raw);
     const consequent = convertNode(node.whenTrue, raw);
     const alternate = convertNode(node.whenFalse, raw);
     return { kind: "conditional", test, consequent, alternate };
   }
-  if (import_typescript7.default.isParenthesizedExpression(node)) {
+  if (import_typescript8.default.isParenthesizedExpression(node)) {
     return convertNode(node.expression, raw);
   }
-  if (import_typescript7.default.isTemplateExpression(node)) {
+  if (import_typescript8.default.isTemplateExpression(node)) {
     const parts = [];
     if (node.head.text) {
       parts.push({ type: "string", value: node.head.text });
@@ -190460,19 +190615,19 @@ function convertNode(node, raw) {
     }
     return { kind: "template-literal", parts };
   }
-  if (import_typescript7.default.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_typescript8.default.isNoSubstitutionTemplateLiteral(node)) {
     return { kind: "literal", value: node.text, literalType: "string" };
   }
-  if (import_typescript7.default.isArrowFunction(node)) {
+  if (import_typescript8.default.isArrowFunction(node)) {
     if (node.parameters.length !== 1) {
       return { kind: "unsupported", raw, reason: "Only single parameter arrow functions are supported" };
     }
     const param = node.parameters[0];
-    if (import_typescript7.default.isBlock(node.body)) {
+    if (import_typescript8.default.isBlock(node.body)) {
       return { kind: "unsupported", raw, reason: "Block body arrow functions are not supported" };
     }
     const body = convertNode(node.body, raw);
-    if (import_typescript7.default.isObjectBindingPattern(param.name)) {
+    if (import_typescript8.default.isObjectBindingPattern(param.name)) {
       const fieldMap = new Map;
       const excludedTopKeys = new Set;
       const collect = collectDestructureBindings(param.name, [], fieldMap, raw, excludedTopKeys);
@@ -190513,21 +190668,21 @@ function convertNode(node, raw) {
       const rewritten = substituteDestructuredFields(body, fieldMap, syntheticParam, restName);
       return { kind: "arrow-fn", param: syntheticParam, body: rewritten };
     }
-    if (!import_typescript7.default.isIdentifier(param.name)) {
+    if (!import_typescript8.default.isIdentifier(param.name)) {
       return { kind: "unsupported", raw, reason: "Destructuring parameters are not supported" };
     }
     return { kind: "arrow-fn", param: param.name.text, body };
   }
-  if (import_typescript7.default.isFunctionExpression(node)) {
+  if (import_typescript8.default.isFunctionExpression(node)) {
     if (node.parameters.length !== 1) {
       return { kind: "unsupported", raw, reason: "Only single-parameter function expressions are supported" };
     }
     const param = node.parameters[0];
-    if (!import_typescript7.default.isIdentifier(param.name)) {
+    if (!import_typescript8.default.isIdentifier(param.name)) {
       return { kind: "unsupported", raw, reason: "Destructured params in function expressions are not supported" };
     }
     const stmts = node.body.statements;
-    if (stmts.length !== 1 || !import_typescript7.default.isReturnStatement(stmts[0]) || !stmts[0].expression) {
+    if (stmts.length !== 1 || !import_typescript8.default.isReturnStatement(stmts[0]) || !stmts[0].expression) {
       return { kind: "unsupported", raw, reason: "Function expressions must be `function (x) { return <expr> }`" };
     }
     return {
@@ -190536,35 +190691,35 @@ function convertNode(node, raw) {
       body: convertNode(stmts[0].expression, raw)
     };
   }
-  return { kind: "unsupported", raw, reason: `Unsupported syntax: ${import_typescript7.default.SyntaxKind[node.kind]}` };
+  return { kind: "unsupported", raw, reason: `Unsupported syntax: ${import_typescript8.default.SyntaxKind[node.kind]}` };
 }
 function extractSortComparatorFromTS(node, method) {
-  if (!import_typescript7.default.isArrowFunction(node) && !import_typescript7.default.isFunctionExpression(node))
+  if (!import_typescript8.default.isArrowFunction(node) && !import_typescript8.default.isFunctionExpression(node))
     return null;
   if (node.parameters.length !== 2)
     return null;
   const pA = node.parameters[0];
   const pB = node.parameters[1];
-  if (!import_typescript7.default.isIdentifier(pA.name) || !import_typescript7.default.isIdentifier(pB.name))
+  if (!import_typescript8.default.isIdentifier(pA.name) || !import_typescript8.default.isIdentifier(pB.name))
     return null;
   const paramA = pA.name.text;
   const paramB = pB.name.text;
   let body;
-  if (import_typescript7.default.isArrowFunction(node)) {
-    if (import_typescript7.default.isBlock(node.body))
+  if (import_typescript8.default.isArrowFunction(node)) {
+    if (import_typescript8.default.isBlock(node.body))
       return null;
     body = node.body;
   } else {
     const stmts = node.body.statements;
-    if (stmts.length !== 1 || !import_typescript7.default.isReturnStatement(stmts[0]) || !stmts[0].expression)
+    if (stmts.length !== 1 || !import_typescript8.default.isReturnStatement(stmts[0]) || !stmts[0].expression)
       return null;
     body = stmts[0].expression;
   }
   const raw = body.getText();
-  if (import_typescript7.default.isBinaryExpression(body) && body.operatorToken.kind === import_typescript7.default.SyntaxKind.MinusToken) {
+  if (import_typescript8.default.isBinaryExpression(body) && body.operatorToken.kind === import_typescript8.default.SyntaxKind.MinusToken) {
     return classifyComparatorOperands(body.left, body.right, paramA, paramB, "numeric", method, raw);
   }
-  if (import_typescript7.default.isCallExpression(body) && import_typescript7.default.isPropertyAccessExpression(body.expression) && body.expression.name.text === "localeCompare" && body.arguments.length === 1) {
+  if (import_typescript8.default.isCallExpression(body) && import_typescript8.default.isPropertyAccessExpression(body.expression) && body.expression.name.text === "localeCompare" && body.arguments.length === 1) {
     return classifyComparatorOperands(body.expression.expression, body.arguments[0], paramA, paramB, "string", method, raw);
   }
   return null;
@@ -190593,14 +190748,14 @@ function classifyComparatorOperands(left, right, paramA, paramB, type2, method,
   };
 }
 function classifySortOperand(expr, paramA, paramB) {
-  if (import_typescript7.default.isIdentifier(expr)) {
+  if (import_typescript8.default.isIdentifier(expr)) {
     if (expr.text === paramA)
       return { key: { kind: "self" }, param: "A" };
     if (expr.text === paramB)
       return { key: { kind: "self" }, param: "B" };
     return null;
   }
-  if (import_typescript7.default.isPropertyAccessExpression(expr) && import_typescript7.default.isIdentifier(expr.expression)) {
+  if (import_typescript8.default.isPropertyAccessExpression(expr) && import_typescript8.default.isIdentifier(expr.expression)) {
     if (expr.expression.text === paramA) {
       return { key: { kind: "field", field: expr.name.text }, param: "A" };
     }
@@ -190613,24 +190768,24 @@ function classifySortOperand(expr, paramA, paramB) {
 function collectDestructureBindings(pattern, pathPrefix, fieldMap, raw, excludedTopKeys) {
   let restName;
   for (const el of pattern.elements) {
-    if (!import_typescript7.default.isBindingElement(el)) {
+    if (!import_typescript8.default.isBindingElement(el)) {
       return { ok: false, reason: "Unsupported binding element in destructured filter param" };
     }
     if (el.dotDotDotToken) {
       if (pathPrefix.length > 0) {
         return { ok: false, reason: "Rest patterns at nested destructure levels are not supported" };
       }
-      if (!import_typescript7.default.isIdentifier(el.name)) {
+      if (!import_typescript8.default.isIdentifier(el.name)) {
         return { ok: false, reason: "Rest patterns must bind to a simple identifier" };
       }
       restName = el.name.text;
       continue;
     }
-    if (import_typescript7.default.isObjectBindingPattern(el.name)) {
+    if (import_typescript8.default.isObjectBindingPattern(el.name)) {
       if (el.initializer) {
         return { ok: false, reason: "Default values on a nested-pattern slot in destructured filter param are not supported" };
       }
-      if (!el.propertyName || !import_typescript7.default.isIdentifier(el.propertyName)) {
+      if (!el.propertyName || !import_typescript8.default.isIdentifier(el.propertyName)) {
         return { ok: false, reason: "Non-identifier (computed/string/numeric) keys in destructured filter param are not supported" };
       }
       if (excludedTopKeys && pathPrefix.length === 0) {
@@ -190641,12 +190796,12 @@ function collectDestructureBindings(pattern, pathPrefix, fieldMap, raw, excluded
         return inner;
       continue;
     }
-    if (!import_typescript7.default.isIdentifier(el.name)) {
+    if (!import_typescript8.default.isIdentifier(el.name)) {
       return { ok: false, reason: "Array binding patterns in destructured filter param are not supported" };
     }
     let fieldName;
     if (el.propertyName) {
-      if (!import_typescript7.default.isIdentifier(el.propertyName)) {
+      if (!import_typescript8.default.isIdentifier(el.propertyName)) {
         return { ok: false, reason: "Non-identifier (computed/string/numeric) keys in destructured filter param are not supported" };
       }
       fieldName = el.propertyName.text;
@@ -190928,31 +191083,31 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
 }
 function getOperatorString(kind) {
   switch (kind) {
-    case import_typescript7.default.SyntaxKind.EqualsEqualsToken:
+    case import_typescript8.default.SyntaxKind.EqualsEqualsToken:
       return "==";
-    case import_typescript7.default.SyntaxKind.EqualsEqualsEqualsToken:
+    case import_typescript8.default.SyntaxKind.EqualsEqualsEqualsToken:
       return "===";
-    case import_typescript7.default.SyntaxKind.ExclamationEqualsToken:
+    case import_typescript8.default.SyntaxKind.ExclamationEqualsToken:
       return "!=";
-    case import_typescript7.default.SyntaxKind.ExclamationEqualsEqualsToken:
+    case import_typescript8.default.SyntaxKind.ExclamationEqualsEqualsToken:
       return "!==";
-    case import_typescript7.default.SyntaxKind.GreaterThanToken:
+    case import_typescript8.default.SyntaxKind.GreaterThanToken:
       return ">";
-    case import_typescript7.default.SyntaxKind.LessThanToken:
+    case import_typescript8.default.SyntaxKind.LessThanToken:
       return "<";
-    case import_typescript7.default.SyntaxKind.GreaterThanEqualsToken:
+    case import_typescript8.default.SyntaxKind.GreaterThanEqualsToken:
       return ">=";
-    case import_typescript7.default.SyntaxKind.LessThanEqualsToken:
+    case import_typescript8.default.SyntaxKind.LessThanEqualsToken:
       return "<=";
-    case import_typescript7.default.SyntaxKind.PlusToken:
+    case import_typescript8.default.SyntaxKind.PlusToken:
       return "+";
-    case import_typescript7.default.SyntaxKind.MinusToken:
+    case import_typescript8.default.SyntaxKind.MinusToken:
       return "-";
-    case import_typescript7.default.SyntaxKind.AsteriskToken:
+    case import_typescript8.default.SyntaxKind.AsteriskToken:
       return "*";
-    case import_typescript7.default.SyntaxKind.SlashToken:
+    case import_typescript8.default.SyntaxKind.SlashToken:
       return "/";
-    case import_typescript7.default.SyntaxKind.PercentToken:
+    case import_typescript8.default.SyntaxKind.PercentToken:
       return "%";
     default:
       return "unknown";
@@ -190960,13 +191115,13 @@ function getOperatorString(kind) {
 }
 function getUnaryOperatorString(op) {
   switch (op) {
-    case import_typescript7.default.SyntaxKind.ExclamationToken:
+    case import_typescript8.default.SyntaxKind.ExclamationToken:
       return "!";
-    case import_typescript7.default.SyntaxKind.MinusToken:
+    case import_typescript8.default.SyntaxKind.MinusToken:
       return "-";
-    case import_typescript7.default.SyntaxKind.PlusToken:
+    case import_typescript8.default.SyntaxKind.PlusToken:
       return "+";
-    case import_typescript7.default.SyntaxKind.TildeToken:
+    case import_typescript8.default.SyntaxKind.TildeToken:
       return "~";
     default:
       return "unknown";
@@ -191163,9 +191318,9 @@ function parseBlockBody(block, sourceFile, getJS) {
   return statements;
 }
 function parseStatement(stmt, sourceFile, getJS) {
-  if (import_typescript7.default.isVariableStatement(stmt)) {
+  if (import_typescript8.default.isVariableStatement(stmt)) {
     const decl = stmt.declarationList.declarations[0];
-    if (!decl || !import_typescript7.default.isIdentifier(decl.name) || !decl.initializer) {
+    if (!decl || !import_typescript8.default.isIdentifier(decl.name) || !decl.initializer) {
       return null;
     }
     const name = decl.name.text;
@@ -191176,7 +191331,7 @@ function parseStatement(stmt, sourceFile, getJS) {
     }
     return { kind: "var-decl", name, init };
   }
-  if (import_typescript7.default.isReturnStatement(stmt)) {
+  if (import_typescript8.default.isReturnStatement(stmt)) {
     if (!stmt.expression) {
       return { kind: "return", value: { kind: "literal", value: true, literalType: "boolean" } };
     }
@@ -191187,7 +191342,7 @@ function parseStatement(stmt, sourceFile, getJS) {
     }
     return { kind: "return", value };
   }
-  if (import_typescript7.default.isIfStatement(stmt)) {
+  if (import_typescript8.default.isIfStatement(stmt)) {
     const conditionText = getJS(stmt.expression);
     const condition = parseExpression(conditionText);
     if (condition.kind === "unsupported") {
@@ -191199,7 +191354,7 @@ function parseStatement(stmt, sourceFile, getJS) {
     }
     let alternate;
     if (stmt.elseStatement) {
-      if (import_typescript7.default.isIfStatement(stmt.elseStatement)) {
+      if (import_typescript8.default.isIfStatement(stmt.elseStatement)) {
         const elseIf = parseStatement(stmt.elseStatement, sourceFile, getJS);
         if (elseIf === null) {
           return null;
@@ -191218,7 +191373,7 @@ function parseStatement(stmt, sourceFile, getJS) {
   return null;
 }
 function parseIfBranch(branch, sourceFile, getJS) {
-  if (import_typescript7.default.isBlock(branch)) {
+  if (import_typescript8.default.isBlock(branch)) {
     return parseBlockBody(branch, sourceFile, getJS);
   }
   const parsed = parseStatement(branch, sourceFile, getJS);
@@ -191229,7 +191384,7 @@ function parseIfBranch(branch, sourceFile, getJS) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-var import_typescript8 = __toESM(require_typescript(), 1);
+var import_typescript9 = __toESM(require_typescript(), 1);
 var REACTIVE_BRAND = "__reactive";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
@@ -191247,7 +191402,7 @@ function safeGetText(node) {
   }
 }
 function analyze(node, checker) {
-  if (import_typescript8.default.isPropertyAccessExpression(node)) {
+  if (import_typescript9.default.isPropertyAccessExpression(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -191271,7 +191426,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (import_typescript8.default.isIdentifier(node)) {
+  if (import_typescript9.default.isIdentifier(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -191283,7 +191438,7 @@ function analyze(node, checker) {
     } catch {}
     return NOT_REACTIVE;
   }
-  if (import_typescript8.default.isCallExpression(node)) {
+  if (import_typescript9.default.isCallExpression(node)) {
     try {
       const calleeType = queryType(checker, node.expression);
       if (isReactiveType(calleeType)) {
@@ -191296,7 +191451,7 @@ function analyze(node, checker) {
   }
   let foundChild;
   let foundChildText = "";
-  import_typescript8.default.forEachChild(node, (child) => {
+  import_typescript9.default.forEachChild(node, (child) => {
     if (foundChild?.isReactive)
       return;
     const result = analyze(child, checker);
@@ -191325,7 +191480,7 @@ function containsReactiveExpression(node, checker) {
 }
 
 // ../jsx/src/free-refs.ts
-var import_typescript9 = __toESM(require_typescript(), 1);
+var import_typescript10 = __toESM(require_typescript(), 1);
 var _bindingMapCache = new WeakMap;
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
@@ -191393,20 +191548,20 @@ function defaultBindingScope(kind) {
 function collectIdentifiers2(node) {
   const out = [];
   const visit2 = (n, parent) => {
-    if (import_typescript9.default.isIdentifier(n)) {
-      if (parent && import_typescript9.default.isPropertyAccessExpression(parent) && parent.name === n)
+    if (import_typescript10.default.isIdentifier(n)) {
+      if (parent && import_typescript10.default.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && import_typescript9.default.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && import_typescript10.default.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && (import_typescript9.default.isJsxOpeningElement(parent) || import_typescript9.default.isJsxClosingElement(parent) || import_typescript9.default.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
+      if (parent && (import_typescript10.default.isJsxOpeningElement(parent) || import_typescript10.default.isJsxClosingElement(parent) || import_typescript10.default.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
         return;
       }
-      if (parent && import_typescript9.default.isJsxAttribute(parent) && parent.name === n)
+      if (parent && import_typescript10.default.isJsxAttribute(parent) && parent.name === n)
         return;
       out.push(n);
       return;
     }
-    import_typescript9.default.forEachChild(n, (child) => visit2(child, n));
+    import_typescript10.default.forEachChild(n, (child) => visit2(child, n));
   };
   visit2(node);
   return out;
@@ -191415,7 +191570,7 @@ function collectReactiveBrandRefs(node, checker) {
   const out = [];
   const seen = new Set;
   const visit2 = (n) => {
-    if (import_typescript9.default.isPropertyAccessExpression(n)) {
+    if (import_typescript10.default.isPropertyAccessExpression(n)) {
       try {
         const type2 = checker.getTypeAtLocation(n);
         if (isReactiveType(type2)) {
@@ -191433,7 +191588,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    import_typescript9.default.forEachChild(n, visit2);
+    import_typescript10.default.forEachChild(n, visit2);
   };
   visit2(node);
   return out;
@@ -191443,14 +191598,14 @@ function resolveConstantInitializerRefs(c, env, visited) {
     return [];
   if (c.containsArrow)
     return [];
-  const sf = import_typescript9.default.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, import_typescript9.default.ScriptTarget.Latest, true);
+  const sf = import_typescript10.default.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, import_typescript10.default.ScriptTarget.Latest, true);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript9.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript10.default.isVariableStatement(stmt))
     return [];
   const decl = stmt.declarationList.declarations[0];
   if (!decl || !decl.initializer)
     return [];
-  const expr = import_typescript9.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  const expr = import_typescript10.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
   return resolveFreeRefsInternal(expr, env, visited);
 }
 function resolveFreeRefsInternal(node, env, visited) {
@@ -191462,7 +191617,7 @@ function resolveFreeRefsInternal(node, env, visited) {
     const name = ident.text;
     if (env.propsObjectName === name) {
       const parent = ident.parent;
-      if (parent && import_typescript9.default.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
+      if (parent && import_typescript10.default.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
         continue;
       }
     }
@@ -191548,13 +191703,13 @@ function exprCallsReactiveGetters(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript10.default.isCallExpression(n) && import_typescript10.default.isIdentifier(n.expression)) {
+    if (import_typescript11.default.isCallExpression(n) && import_typescript11.default.isIdentifier(n.expression)) {
       if (names.has(n.expression.text)) {
         found = true;
         return;
       }
     }
-    import_typescript10.default.forEachChild(n, visit2);
+    import_typescript11.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -191581,11 +191736,11 @@ function exprReferencesModuleClientSignal(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript10.default.isCallExpression(n) && import_typescript10.default.isIdentifier(n.expression) && names.has(n.expression.text)) {
+    if (import_typescript11.default.isCallExpression(n) && import_typescript11.default.isIdentifier(n.expression) && names.has(n.expression.text)) {
       found = true;
       return;
     }
-    import_typescript10.default.forEachChild(n, visit2);
+    import_typescript11.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -191595,11 +191750,11 @@ function exprHasFunctionCalls(expr) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript10.default.isCallExpression(n)) {
+    if (import_typescript11.default.isCallExpression(n)) {
       found = true;
       return;
     }
-    import_typescript10.default.forEachChild(n, visit2);
+    import_typescript11.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -191618,10 +191773,10 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
     return;
   let acc;
   function visit2(n, parent) {
-    if (import_typescript10.default.isIdentifier(n) && propDepsMap.has(n.text)) {
-      const isObjectKey = parent && import_typescript10.default.isPropertyAssignment(parent) && parent.name === n;
-      const isShorthand = parent && import_typescript10.default.isShorthandPropertyAssignment(parent) && parent.name === n;
-      const isAccessName = parent && import_typescript10.default.isPropertyAccessExpression(parent) && parent.name === n;
+    if (import_typescript11.default.isIdentifier(n) && propDepsMap.has(n.text)) {
+      const isObjectKey = parent && import_typescript11.default.isPropertyAssignment(parent) && parent.name === n;
+      const isShorthand = parent && import_typescript11.default.isShorthandPropertyAssignment(parent) && parent.name === n;
+      const isAccessName = parent && import_typescript11.default.isPropertyAccessExpression(parent) && parent.name === n;
       if (!isObjectKey && !isShorthand && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
@@ -191632,7 +191787,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
         }
       }
     }
-    import_typescript10.default.forEachChild(n, (child) => visit2(child, n));
+    import_typescript11.default.forEachChild(n, (child) => visit2(child, n));
   }
   visit2(node);
   return acc;
@@ -191699,21 +191854,21 @@ function createTransformContext(analyzer) {
 function buildComponentNamespaces(ctx) {
   const result = new Map;
   for (const stmt of ctx.sourceFile.statements) {
-    if (!import_typescript10.default.isVariableStatement(stmt))
+    if (!import_typescript11.default.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !import_typescript10.default.isIdentifier(decl.name))
+      if (!decl.initializer || !import_typescript11.default.isIdentifier(decl.name))
         continue;
       let init = decl.initializer;
-      while (import_typescript10.default.isParenthesizedExpression(init))
+      while (import_typescript11.default.isParenthesizedExpression(init))
         init = init.expression;
-      if (!import_typescript10.default.isObjectLiteralExpression(init))
+      if (!import_typescript11.default.isObjectLiteralExpression(init))
         continue;
       const members = new Map;
       for (const prop of init.properties) {
-        if (import_typescript10.default.isShorthandPropertyAssignment(prop)) {
+        if (import_typescript11.default.isShorthandPropertyAssignment(prop)) {
           members.set(prop.name.text, prop.name.text);
-        } else if (import_typescript10.default.isPropertyAssignment(prop) && (import_typescript10.default.isIdentifier(prop.name) || import_typescript10.default.isStringLiteral(prop.name)) && import_typescript10.default.isIdentifier(prop.initializer)) {
+        } else if (import_typescript11.default.isPropertyAssignment(prop) && (import_typescript11.default.isIdentifier(prop.name) || import_typescript11.default.isStringLiteral(prop.name)) && import_typescript11.default.isIdentifier(prop.initializer)) {
           members.set(prop.name.text, prop.initializer.text);
         }
       }
@@ -191725,11 +191880,11 @@ function buildComponentNamespaces(ctx) {
   return result;
 }
 function resolveMemberExpressionTag(tagNode, ctx) {
-  if (!import_typescript10.default.isPropertyAccessExpression(tagNode))
+  if (!import_typescript11.default.isPropertyAccessExpression(tagNode))
     return null;
-  if (!import_typescript10.default.isIdentifier(tagNode.expression))
+  if (!import_typescript11.default.isIdentifier(tagNode.expression))
     return null;
-  if (!import_typescript10.default.isIdentifier(tagNode.name))
+  if (!import_typescript11.default.isIdentifier(tagNode.name))
     return null;
   if (!ctx._componentNamespaces) {
     ctx._componentNamespaces = buildComponentNamespaces(ctx);
@@ -191777,7 +191932,7 @@ function jsxToIR(analyzer) {
     return null;
   const ctx = createTransformContext(analyzer);
   const jsxReturn = analyzer.jsxReturn;
-  if (import_typescript10.default.isJsxElement(jsxReturn) || import_typescript10.default.isJsxSelfClosingElement(jsxReturn) || import_typescript10.default.isJsxFragment(jsxReturn)) {
+  if (import_typescript11.default.isJsxElement(jsxReturn) || import_typescript11.default.isJsxSelfClosingElement(jsxReturn) || import_typescript11.default.isJsxFragment(jsxReturn)) {
     const ir2 = transformNode(jsxReturn, ctx);
     if (ir2 && needsScopeWrapper(ir2)) {
       return wrapInScopeElement(ir2);
@@ -191833,22 +191988,22 @@ function wrapInScopeElement(node) {
   };
 }
 function transformNode(node, ctx) {
-  if (import_typescript10.default.isJsxElement(node)) {
+  if (import_typescript11.default.isJsxElement(node)) {
     return transformJsxElement(node, ctx);
   }
-  if (import_typescript10.default.isJsxSelfClosingElement(node)) {
+  if (import_typescript11.default.isJsxSelfClosingElement(node)) {
     return transformSelfClosingElement(node, ctx);
   }
-  if (import_typescript10.default.isJsxFragment(node)) {
+  if (import_typescript11.default.isJsxFragment(node)) {
     return transformFragment(node, ctx);
   }
-  if (import_typescript10.default.isJsxText(node)) {
+  if (import_typescript11.default.isJsxText(node)) {
     return transformText(node, ctx);
   }
-  if (import_typescript10.default.isJsxExpression(node)) {
+  if (import_typescript11.default.isJsxExpression(node)) {
     return transformExpression(node, ctx);
   }
-  if (import_typescript10.default.isConditionalExpression(node)) {
+  if (import_typescript11.default.isConditionalExpression(node)) {
     return transformConditional(node, ctx);
   }
   return null;
@@ -192058,7 +192213,7 @@ function transformSelfClosingComponent(node, ctx, name) {
 }
 function isTransparentFragment(node, ctx) {
   const children = node.children.filter((child2) => {
-    if (import_typescript10.default.isJsxText(child2)) {
+    if (import_typescript11.default.isJsxText(child2)) {
       return child2.text.trim() !== "";
     }
     return true;
@@ -192066,7 +192221,7 @@ function isTransparentFragment(node, ctx) {
   if (children.length !== 1)
     return false;
   const child = children[0];
-  if (!import_typescript10.default.isJsxExpression(child))
+  if (!import_typescript11.default.isJsxExpression(child))
     return false;
   if (!child.expression)
     return false;
@@ -192110,7 +192265,7 @@ function transformChildren(children, ctx) {
   const result = [];
   for (let i2 = 0;i2 < children.length; i2++) {
     const child = children[i2];
-    if (import_typescript10.default.isJsxExpression(child) && !child.expression) {
+    if (import_typescript11.default.isJsxExpression(child) && !child.expression) {
       continue;
     }
     const transformed = transformNode(child, ctx);
@@ -192143,7 +192298,7 @@ function transformExpression(node, ctx) {
 }
 function transformExpressionInner(expr, ctx, node, isClientOnly) {
   checkBareSignalOrMemoIdentifier(expr, ctx);
-  if (import_typescript10.default.isIdentifier(expr)) {
+  if (import_typescript11.default.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
       return transformNode(jsxNode, ctx);
@@ -192159,7 +192314,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   }
   const ir = transformJsxExpression(expr, ctx, isClientOnly);
   if (ir !== null) {
-    if (isClientOnly && ir.type === "conditional") {
+    if ((isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx)) && ir.type === "conditional") {
       ir.clientOnly = true;
       if (!ir.slotId) {
         ir.slotId = generateSlotId(ctx);
@@ -192417,21 +192572,21 @@ function transformLogicalAnd(node, ctx) {
   };
 }
 function containsJsxInExpression(node) {
-  if (import_typescript10.default.isJsxElement(node) || import_typescript10.default.isJsxSelfClosingElement(node) || import_typescript10.default.isJsxFragment(node)) {
+  if (import_typescript11.default.isJsxElement(node) || import_typescript11.default.isJsxSelfClosingElement(node) || import_typescript11.default.isJsxFragment(node)) {
     return true;
   }
-  return import_typescript10.default.forEachChild(node, containsJsxInExpression) ?? false;
+  return import_typescript11.default.forEachChild(node, containsJsxInExpression) ?? false;
 }
 function containsAwaitExpression(node) {
-  if (import_typescript10.default.isAwaitExpression(node))
+  if (import_typescript11.default.isAwaitExpression(node))
     return true;
-  if (import_typescript10.default.isFunctionDeclaration(node) || import_typescript10.default.isFunctionExpression(node) || import_typescript10.default.isArrowFunction(node))
+  if (import_typescript11.default.isFunctionDeclaration(node) || import_typescript11.default.isFunctionExpression(node) || import_typescript11.default.isArrowFunction(node))
     return false;
-  return import_typescript10.default.forEachChild(node, containsAwaitExpression) ?? false;
+  return import_typescript11.default.forEachChild(node, containsAwaitExpression) ?? false;
 }
 function transformNullishCoalescing(node, ctx) {
   const leftText = ctx.getJS(node.left);
-  const isNullish = node.operatorToken.kind === import_typescript10.default.SyntaxKind.QuestionQuestionToken;
+  const isNullish = node.operatorToken.kind === import_typescript11.default.SyntaxKind.QuestionQuestionToken;
   const condition = isNullish ? `${leftText} != null` : leftText;
   const leftOrigin = {
     phase: "tick",
@@ -192475,38 +192630,38 @@ function transformNullishCoalescing(node, ctx) {
     origin: leftOrigin
   };
 }
-function assertNever(expr) {
+function assertNever2(expr) {
   const kind = expr?.kind;
-  throw new Error(`transformJsxExpression: unhandled ts.SyntaxKind ${kind !== undefined ? import_typescript10.default.SyntaxKind[kind] : "unknown"} ` + `(kind=${kind}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`);
+  throw new Error(`transformJsxExpression: unhandled ts.SyntaxKind ${kind !== undefined ? import_typescript11.default.SyntaxKind[kind] : "unknown"} ` + `(kind=${kind}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`);
 }
 function transformJsxExpression(expr, ctx, isClientOnly = false) {
   const node = expr;
   switch (node.kind) {
-    case import_typescript10.default.SyntaxKind.ParenthesizedExpression:
-    case import_typescript10.default.SyntaxKind.AsExpression:
-    case import_typescript10.default.SyntaxKind.SatisfiesExpression:
-    case import_typescript10.default.SyntaxKind.NonNullExpression:
-    case import_typescript10.default.SyntaxKind.TypeAssertionExpression:
-    case import_typescript10.default.SyntaxKind.PartiallyEmittedExpression:
+    case import_typescript11.default.SyntaxKind.ParenthesizedExpression:
+    case import_typescript11.default.SyntaxKind.AsExpression:
+    case import_typescript11.default.SyntaxKind.SatisfiesExpression:
+    case import_typescript11.default.SyntaxKind.NonNullExpression:
+    case import_typescript11.default.SyntaxKind.TypeAssertionExpression:
+    case import_typescript11.default.SyntaxKind.PartiallyEmittedExpression:
       return transformJsxExpression(node.expression, ctx, isClientOnly);
-    case import_typescript10.default.SyntaxKind.JsxElement:
+    case import_typescript11.default.SyntaxKind.JsxElement:
       return transformJsxElement(node, ctx);
-    case import_typescript10.default.SyntaxKind.JsxFragment:
+    case import_typescript11.default.SyntaxKind.JsxFragment:
       return transformFragment(node, ctx);
-    case import_typescript10.default.SyntaxKind.JsxSelfClosingElement:
+    case import_typescript11.default.SyntaxKind.JsxSelfClosingElement:
       return transformSelfClosingElement(node, ctx);
-    case import_typescript10.default.SyntaxKind.ConditionalExpression:
+    case import_typescript11.default.SyntaxKind.ConditionalExpression:
       return transformConditional(node, ctx);
-    case import_typescript10.default.SyntaxKind.BinaryExpression: {
-      if (node.operatorToken.kind === import_typescript10.default.SyntaxKind.AmpersandAmpersandToken) {
+    case import_typescript11.default.SyntaxKind.BinaryExpression: {
+      if (node.operatorToken.kind === import_typescript11.default.SyntaxKind.AmpersandAmpersandToken) {
         return transformLogicalAnd(node, ctx);
       }
-      if ((node.operatorToken.kind === import_typescript10.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript10.default.SyntaxKind.BarBarToken) && containsJsxInExpression(node.right)) {
+      if ((node.operatorToken.kind === import_typescript11.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript11.default.SyntaxKind.BarBarToken) && containsJsxInExpression(node.right)) {
         return transformNullishCoalescing(node, ctx);
       }
       return null;
     }
-    case import_typescript10.default.SyntaxKind.CallExpression: {
+    case import_typescript11.default.SyntaxKind.CallExpression: {
       const mapMethod = getMapLikeMethod(node);
       if (mapMethod) {
         const mapResult = transformMapCall(node, ctx, isClientOnly, mapMethod);
@@ -192514,7 +192669,7 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
           return mapResult;
       }
       const callee = node.expression;
-      if (import_typescript10.default.isIdentifier(callee)) {
+      if (import_typescript11.default.isIdentifier(callee)) {
         const jsxFunc = ctx.analyzer.jsxFunctions.get(callee.text);
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx, isClientOnly);
@@ -192526,39 +192681,39 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
       }
       return null;
     }
-    case import_typescript10.default.SyntaxKind.Identifier:
-    case import_typescript10.default.SyntaxKind.StringLiteral:
-    case import_typescript10.default.SyntaxKind.NumericLiteral:
-    case import_typescript10.default.SyntaxKind.BigIntLiteral:
-    case import_typescript10.default.SyntaxKind.RegularExpressionLiteral:
-    case import_typescript10.default.SyntaxKind.NoSubstitutionTemplateLiteral:
-    case import_typescript10.default.SyntaxKind.TemplateExpression:
-    case import_typescript10.default.SyntaxKind.TaggedTemplateExpression:
-    case import_typescript10.default.SyntaxKind.TrueKeyword:
-    case import_typescript10.default.SyntaxKind.FalseKeyword:
-    case import_typescript10.default.SyntaxKind.NullKeyword:
-    case import_typescript10.default.SyntaxKind.ThisKeyword:
-    case import_typescript10.default.SyntaxKind.SuperKeyword:
-    case import_typescript10.default.SyntaxKind.ImportKeyword:
-    case import_typescript10.default.SyntaxKind.PropertyAccessExpression:
-    case import_typescript10.default.SyntaxKind.ElementAccessExpression:
-    case import_typescript10.default.SyntaxKind.PrefixUnaryExpression:
-    case import_typescript10.default.SyntaxKind.PostfixUnaryExpression:
-    case import_typescript10.default.SyntaxKind.TypeOfExpression:
-    case import_typescript10.default.SyntaxKind.VoidExpression:
-    case import_typescript10.default.SyntaxKind.DeleteExpression:
-    case import_typescript10.default.SyntaxKind.NewExpression:
-    case import_typescript10.default.SyntaxKind.ObjectLiteralExpression:
-    case import_typescript10.default.SyntaxKind.ArrowFunction:
-    case import_typescript10.default.SyntaxKind.FunctionExpression:
-    case import_typescript10.default.SyntaxKind.ClassExpression:
-    case import_typescript10.default.SyntaxKind.MetaProperty:
-    case import_typescript10.default.SyntaxKind.ExpressionWithTypeArguments:
-    case import_typescript10.default.SyntaxKind.CommaListExpression:
-    case import_typescript10.default.SyntaxKind.SyntheticExpression:
-    case import_typescript10.default.SyntaxKind.ArrayLiteralExpression:
+    case import_typescript11.default.SyntaxKind.Identifier:
+    case import_typescript11.default.SyntaxKind.StringLiteral:
+    case import_typescript11.default.SyntaxKind.NumericLiteral:
+    case import_typescript11.default.SyntaxKind.BigIntLiteral:
+    case import_typescript11.default.SyntaxKind.RegularExpressionLiteral:
+    case import_typescript11.default.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case import_typescript11.default.SyntaxKind.TemplateExpression:
+    case import_typescript11.default.SyntaxKind.TaggedTemplateExpression:
+    case import_typescript11.default.SyntaxKind.TrueKeyword:
+    case import_typescript11.default.SyntaxKind.FalseKeyword:
+    case import_typescript11.default.SyntaxKind.NullKeyword:
+    case import_typescript11.default.SyntaxKind.ThisKeyword:
+    case import_typescript11.default.SyntaxKind.SuperKeyword:
+    case import_typescript11.default.SyntaxKind.ImportKeyword:
+    case import_typescript11.default.SyntaxKind.PropertyAccessExpression:
+    case import_typescript11.default.SyntaxKind.ElementAccessExpression:
+    case import_typescript11.default.SyntaxKind.PrefixUnaryExpression:
+    case import_typescript11.default.SyntaxKind.PostfixUnaryExpression:
+    case import_typescript11.default.SyntaxKind.TypeOfExpression:
+    case import_typescript11.default.SyntaxKind.VoidExpression:
+    case import_typescript11.default.SyntaxKind.DeleteExpression:
+    case import_typescript11.default.SyntaxKind.NewExpression:
+    case import_typescript11.default.SyntaxKind.ObjectLiteralExpression:
+    case import_typescript11.default.SyntaxKind.ArrowFunction:
+    case import_typescript11.default.SyntaxKind.FunctionExpression:
+    case import_typescript11.default.SyntaxKind.ClassExpression:
+    case import_typescript11.default.SyntaxKind.MetaProperty:
+    case import_typescript11.default.SyntaxKind.ExpressionWithTypeArguments:
+    case import_typescript11.default.SyntaxKind.CommaListExpression:
+    case import_typescript11.default.SyntaxKind.SyntheticExpression:
+    case import_typescript11.default.SyntaxKind.ArrayLiteralExpression:
       return null;
-    case import_typescript10.default.SyntaxKind.AwaitExpression:
+    case import_typescript11.default.SyntaxKind.AwaitExpression:
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(node, ctx.sourceFile, ctx.filePath)));
       return {
         type: "expression",
@@ -192569,19 +192724,19 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
         loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
         origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
       };
-    case import_typescript10.default.SyntaxKind.YieldExpression:
+    case import_typescript11.default.SyntaxKind.YieldExpression:
       return null;
-    case import_typescript10.default.SyntaxKind.SpreadElement:
-    case import_typescript10.default.SyntaxKind.OmittedExpression:
-    case import_typescript10.default.SyntaxKind.JsxExpression:
-    case import_typescript10.default.SyntaxKind.JsxOpeningElement:
-    case import_typescript10.default.SyntaxKind.JsxOpeningFragment:
-    case import_typescript10.default.SyntaxKind.JsxClosingFragment:
-    case import_typescript10.default.SyntaxKind.JsxAttributes:
-    case import_typescript10.default.SyntaxKind.MissingDeclaration:
+    case import_typescript11.default.SyntaxKind.SpreadElement:
+    case import_typescript11.default.SyntaxKind.OmittedExpression:
+    case import_typescript11.default.SyntaxKind.JsxExpression:
+    case import_typescript11.default.SyntaxKind.JsxOpeningElement:
+    case import_typescript11.default.SyntaxKind.JsxOpeningFragment:
+    case import_typescript11.default.SyntaxKind.JsxClosingFragment:
+    case import_typescript11.default.SyntaxKind.JsxAttributes:
+    case import_typescript11.default.SyntaxKind.MissingDeclaration:
       return null;
     default:
-      return assertNever(node);
+      return assertNever2(node);
   }
 }
 function transformConditionalBranch(node, ctx) {
@@ -192595,21 +192750,26 @@ function transformConditionalBranch(node, ctx) {
     effect: "pure",
     freeRefs: resolveFreeRefs(node, makeBindingEnv(ctx))
   };
+  const callsReactive = exprCallsReactiveGetters(node, ctx);
+  const hasCalls = exprHasFunctionCalls(node);
+  const reactive = isReactiveExpression(exprText, ctx, node) || isReactiveOrigin(branchOrigin);
+  const needsSlot = reactive || callsReactive;
+  const slotId = needsSlot ? generateSlotId(ctx) : null;
   return {
     type: "expression",
     expr: exprText,
     templateExpr: rewriteBarePropRefs2(exprText, node, ctx),
     typeInfo: inferExpressionType(node, ctx),
-    reactive: isReactiveExpression(exprText, ctx, node) || isReactiveOrigin(branchOrigin),
-    slotId: null,
-    callsReactiveGetters: exprCallsReactiveGetters(node, ctx) || undefined,
-    hasFunctionCalls: exprHasFunctionCalls(node) || undefined,
+    reactive,
+    slotId,
+    callsReactiveGetters: callsReactive || undefined,
+    hasFunctionCalls: hasCalls || undefined,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
     origin: branchOrigin
   };
 }
 function getMapLikeMethod(node) {
-  if (!import_typescript10.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript11.default.isPropertyAccessExpression(node.expression))
     return null;
   const name = node.expression.name.text;
   if (name === "map")
@@ -192619,9 +192779,9 @@ function getMapLikeMethod(node) {
   return null;
 }
 function isFilterCall(node) {
-  if (!import_typescript10.default.isCallExpression(node))
+  if (!import_typescript11.default.isCallExpression(node))
     return null;
-  if (!import_typescript10.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript11.default.isPropertyAccessExpression(node.expression))
     return null;
   if (node.expression.name.text !== "filter")
     return null;
@@ -192633,9 +192793,9 @@ function isFilterCall(node) {
   };
 }
 function isSortCall(node) {
-  if (!import_typescript10.default.isCallExpression(node))
+  if (!import_typescript11.default.isCallExpression(node))
     return null;
-  if (!import_typescript10.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript11.default.isPropertyAccessExpression(node.expression))
     return null;
   const methodName = node.expression.name.text;
   if (methodName !== "sort" && methodName !== "toSorted")
@@ -192648,8 +192808,20 @@ function isSortCall(node) {
     method: methodName
   };
 }
+function isIteratorShapeCall(node) {
+  if (!import_typescript11.default.isCallExpression(node))
+    return null;
+  if (!import_typescript11.default.isPropertyAccessExpression(node.expression))
+    return null;
+  if (node.arguments.length !== 0)
+    return null;
+  const name = node.expression.name.text;
+  if (name !== "entries" && name !== "keys" && name !== "values")
+    return null;
+  return { array: node.expression.expression, shape: name };
+}
 function extractSortComparator(callback, method, ctx) {
-  if (!import_typescript10.default.isArrowFunction(callback) && !import_typescript10.default.isFunctionExpression(callback)) {
+  if (!import_typescript11.default.isArrowFunction(callback) && !import_typescript11.default.isFunctionExpression(callback)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
@@ -192670,13 +192842,13 @@ function extractSortComparator(callback, method, ctx) {
   };
 }
 function extractFilterPredicate(callback, ctx) {
-  if (!import_typescript10.default.isArrowFunction(callback))
+  if (!import_typescript11.default.isArrowFunction(callback))
     return { result: null };
   if (callback.parameters.length < 1)
     return { result: null };
   const firstParam = callback.parameters[0];
-  if (!import_typescript10.default.isIdentifier(firstParam.name)) {
-    if (import_typescript10.default.isBlock(callback.body)) {
+  if (!import_typescript11.default.isIdentifier(firstParam.name)) {
+    if (import_typescript11.default.isBlock(callback.body)) {
       return {
         result: null,
         unsupportedReason: "Block body in a destructured filter param is not supported. Workaround: use an expression-body arrow, or add /* @client */."
@@ -192696,7 +192868,7 @@ function extractFilterPredicate(callback, ctx) {
     return { result: null };
   }
   const param = firstParam.name.getText(ctx.sourceFile);
-  if (import_typescript10.default.isBlock(callback.body)) {
+  if (import_typescript11.default.isBlock(callback.body)) {
     const raw2 = ctx.getJS(callback.body);
     const statements = parseBlockBody(callback.body, ctx.sourceFile, (n) => ctx.getJS(n));
     if (!statements) {
@@ -192713,7 +192885,7 @@ function extractFilterPredicate(callback, ctx) {
   return { result: { param, predicate, raw } };
 }
 function extractLoopParamBindings(pattern) {
-  if (import_typescript10.default.isIdentifier(pattern))
+  if (import_typescript11.default.isIdentifier(pattern))
     return null;
   const bindings = [];
   let unsupported = false;
@@ -192722,7 +192894,7 @@ function extractLoopParamBindings(pattern) {
       return false;
     for (let i2 = 0;i2 < key.length; ) {
       const cp = key.codePointAt(i2);
-      const ok = i2 === 0 ? import_typescript10.default.isIdentifierStart(cp, import_typescript10.default.ScriptTarget.Latest) : import_typescript10.default.isIdentifierPart(cp, import_typescript10.default.ScriptTarget.Latest);
+      const ok = i2 === 0 ? import_typescript11.default.isIdentifierStart(cp, import_typescript11.default.ScriptTarget.Latest) : import_typescript11.default.isIdentifierPart(cp, import_typescript11.default.ScriptTarget.Latest);
       if (!ok)
         return false;
       i2 += cp > 65535 ? 2 : 1;
@@ -192735,17 +192907,17 @@ function extractLoopParamBindings(pattern) {
   const walk = (p, prefix) => {
     if (unsupported)
       return;
-    if (import_typescript10.default.isArrayBindingPattern(p)) {
+    if (import_typescript11.default.isArrayBindingPattern(p)) {
       const elements2 = p.elements;
       for (let index = 0;index < elements2.length; index++) {
         if (unsupported)
           return;
         const el = elements2[index];
-        if (import_typescript10.default.isOmittedExpression(el))
+        if (import_typescript11.default.isOmittedExpression(el))
           continue;
         if (el.dotDotDotToken) {
           internalInvariant(index === elements2.length - 1, "extractLoopParamBindings: array rest token in non-final position (parser should reject)");
-          internalInvariant(import_typescript10.default.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
+          internalInvariant(import_typescript11.default.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
           bindings.push({
             name: el.name.text,
             path: prefix,
@@ -192754,7 +192926,7 @@ function extractLoopParamBindings(pattern) {
           return;
         }
         const path = `${prefix}[${index}]`;
-        if (import_typescript10.default.isIdentifier(el.name)) {
+        if (import_typescript11.default.isIdentifier(el.name)) {
           bindings.push({ name: el.name.text, path });
         } else {
           walk(el.name, path);
@@ -192770,7 +192942,7 @@ function extractLoopParamBindings(pattern) {
       const el = elements[i2];
       if (el.dotDotDotToken) {
         internalInvariant(i2 === elements.length - 1, "extractLoopParamBindings: object rest token in non-final position (parser should reject)");
-        internalInvariant(import_typescript10.default.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
+        internalInvariant(import_typescript11.default.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
         bindings.push({
           name: el.name.text,
           path: prefix,
@@ -192781,17 +192953,17 @@ function extractLoopParamBindings(pattern) {
       let keyText = null;
       if (el.propertyName) {
         const pn = el.propertyName;
-        if (import_typescript10.default.isIdentifier(pn))
+        if (import_typescript11.default.isIdentifier(pn))
           keyText = pn.text;
-        else if (import_typescript10.default.isStringLiteral(pn))
+        else if (import_typescript11.default.isStringLiteral(pn))
           keyText = pn.text;
-        else if (import_typescript10.default.isNumericLiteral(pn))
+        else if (import_typescript11.default.isNumericLiteral(pn))
           keyText = pn.text;
         else {
           unsupported = true;
           return;
         }
-      } else if (import_typescript10.default.isIdentifier(el.name)) {
+      } else if (import_typescript11.default.isIdentifier(el.name)) {
         keyText = el.name.text;
       } else {
         unsupported = true;
@@ -192799,14 +192971,14 @@ function extractLoopParamBindings(pattern) {
       }
       collectedKeys.push({ key: keyText, isIdent: isIdent(keyText) });
       const path = appendDotAccess(prefix, keyText);
-      if (import_typescript10.default.isIdentifier(el.name)) {
+      if (import_typescript11.default.isIdentifier(el.name)) {
         bindings.push({ name: el.name.text, path });
       } else {
         walk(el.name, path);
       }
     }
   };
-  if (import_typescript10.default.isArrayBindingPattern(pattern) || import_typescript10.default.isObjectBindingPattern(pattern)) {
+  if (import_typescript11.default.isArrayBindingPattern(pattern) || import_typescript11.default.isObjectBindingPattern(pattern)) {
     walk(pattern, "");
     if (unsupported)
       return { unsupported: true };
@@ -192816,7 +192988,7 @@ function extractLoopParamBindings(pattern) {
 }
 function findKeyJsxAttribute(opening) {
   for (const prop of opening.attributes.properties) {
-    if (import_typescript10.default.isJsxAttribute(prop) && prop.name.getText() === "key") {
+    if (import_typescript11.default.isJsxAttribute(prop) && prop.name.getText() === "key") {
       return prop;
     }
   }
@@ -192861,7 +193033,7 @@ function keyAttrValueToExpr(v) {
 function normalizeKeyExpr(expr) {
   let out = "";
   for (const tok of iterateJsTokens(expr)) {
-    if (tok.kind === import_typescript10.default.SyntaxKind.WhitespaceTrivia || tok.kind === import_typescript10.default.SyntaxKind.NewLineTrivia) {
+    if (tok.kind === import_typescript11.default.SyntaxKind.WhitespaceTrivia || tok.kind === import_typescript11.default.SyntaxKind.NewLineTrivia) {
       continue;
     }
     out += expr.slice(tok.pos, tok.end);
@@ -192873,13 +193045,13 @@ function conditionalHasExplicitNullishBranch(cond) {
 }
 function branchHasExplicitNullish(branch) {
   let b = branch;
-  while (import_typescript10.default.isParenthesizedExpression(b))
+  while (import_typescript11.default.isParenthesizedExpression(b))
     b = b.expression;
-  if (b.kind === import_typescript10.default.SyntaxKind.NullKeyword)
+  if (b.kind === import_typescript11.default.SyntaxKind.NullKeyword)
     return true;
-  if (import_typescript10.default.isIdentifier(b) && b.text === "undefined")
+  if (import_typescript11.default.isIdentifier(b) && b.text === "undefined")
     return true;
-  if (import_typescript10.default.isConditionalExpression(b))
+  if (import_typescript11.default.isConditionalExpression(b))
     return conditionalHasExplicitNullishBranch(b);
   return false;
 }
@@ -192888,26 +193060,26 @@ function classifyKeyProblem(keyAttr, checker) {
     return "missing";
   if (!keyAttr.initializer)
     return "missing";
-  if (import_typescript10.default.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
+  if (import_typescript11.default.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
     return "missing";
   }
   let expr;
-  if (import_typescript10.default.isStringLiteral(keyAttr.initializer)) {
+  if (import_typescript11.default.isStringLiteral(keyAttr.initializer)) {
     return null;
-  } else if (import_typescript10.default.isJsxExpression(keyAttr.initializer)) {
+  } else if (import_typescript11.default.isJsxExpression(keyAttr.initializer)) {
     expr = keyAttr.initializer.expression;
   }
   if (!expr)
     return null;
-  if (expr.kind === import_typescript10.default.SyntaxKind.NullKeyword)
+  if (expr.kind === import_typescript11.default.SyntaxKind.NullKeyword)
     return null;
-  if (import_typescript10.default.isIdentifier(expr) && expr.text === "undefined")
+  if (import_typescript11.default.isIdentifier(expr) && expr.text === "undefined")
     return null;
-  if (import_typescript10.default.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr))
+  if (import_typescript11.default.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr))
     return null;
   if (checker) {
     const type2 = checker.getTypeAtLocation(expr);
-    const isNullable = type2.isUnion() ? type2.types.some((t) => (t.flags & (import_typescript10.default.TypeFlags.Null | import_typescript10.default.TypeFlags.Undefined | import_typescript10.default.TypeFlags.Void)) !== 0) : (type2.flags & (import_typescript10.default.TypeFlags.Null | import_typescript10.default.TypeFlags.Undefined | import_typescript10.default.TypeFlags.Void)) !== 0;
+    const isNullable = type2.isUnion() ? type2.types.some((t) => (t.flags & (import_typescript11.default.TypeFlags.Null | import_typescript11.default.TypeFlags.Undefined | import_typescript11.default.TypeFlags.Void)) !== 0) : (type2.flags & (import_typescript11.default.TypeFlags.Null | import_typescript11.default.TypeFlags.Undefined | import_typescript11.default.TypeFlags.Void)) !== 0;
     if (isNullable)
       return "nullable-type";
   }
@@ -192933,38 +193105,38 @@ function checkLoopKey(callback, ctx, isNested) {
     ctx.analyzer.errors.push(createError(errorCode, getSourceLocation(locNode, ctx.sourceFile, ctx.filePath), { suggestion: { message: keyErrorSuggestion(problem) } }));
   }
   let body = callback.body;
-  if (import_typescript10.default.isBlock(body)) {
-    const ret = body.statements.find((s) => import_typescript10.default.isReturnStatement(s) && s.expression != null);
+  if (import_typescript11.default.isBlock(body)) {
+    const ret = body.statements.find((s) => import_typescript11.default.isReturnStatement(s) && s.expression != null);
     if (!ret?.expression)
       return;
     body = ret.expression;
   }
-  while (import_typescript10.default.isParenthesizedExpression(body))
+  while (import_typescript11.default.isParenthesizedExpression(body))
     body = body.expression;
-  if (import_typescript10.default.isConditionalExpression(body)) {
+  if (import_typescript11.default.isConditionalExpression(body)) {
     const whenTrue = body.whenTrue;
     const whenFalse = body.whenFalse;
     let wt = whenTrue;
     let wf = whenFalse;
-    while (import_typescript10.default.isParenthesizedExpression(wt))
+    while (import_typescript11.default.isParenthesizedExpression(wt))
       wt = wt.expression;
-    while (import_typescript10.default.isParenthesizedExpression(wf))
+    while (import_typescript11.default.isParenthesizedExpression(wf))
       wf = wf.expression;
-    if (import_typescript10.default.isJsxElement(wt))
+    if (import_typescript11.default.isJsxElement(wt))
       checkOpening(wt.openingElement);
-    else if (import_typescript10.default.isJsxSelfClosingElement(wt))
+    else if (import_typescript11.default.isJsxSelfClosingElement(wt))
       checkOpening(wt);
-    if (import_typescript10.default.isJsxElement(wf))
+    if (import_typescript11.default.isJsxElement(wf))
       checkOpening(wf.openingElement);
-    else if (import_typescript10.default.isJsxSelfClosingElement(wf))
+    else if (import_typescript11.default.isJsxSelfClosingElement(wf))
       checkOpening(wf);
     return;
   }
-  if (import_typescript10.default.isJsxElement(body)) {
+  if (import_typescript11.default.isJsxElement(body)) {
     checkOpening(body.openingElement);
     return;
   }
-  if (import_typescript10.default.isJsxSelfClosingElement(body)) {
+  if (import_typescript11.default.isJsxSelfClosingElement(body)) {
     checkOpening(body);
     return;
   }
@@ -192993,13 +193165,24 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let mapPreamble;
   let templateMapPreamble;
   let typedMapPreamble;
+  let iterationShape;
   const setArray = (node2) => {
     array = ctx.getJS(node2);
     templateArray = rewriteBarePropRefs2(array, node2, ctx);
     arrayExpr = node2;
   };
-  const filterInfo = isFilterCall(mapSource);
-  const sortInfo = isSortCall(mapSource);
+  let chainSource = mapSource;
+  const iteratorInfo = isIteratorShapeCall(mapSource);
+  if (iteratorInfo) {
+    chainSource = iteratorInfo.array;
+    if (iteratorInfo.shape === "entries") {
+      iterationShape = "entries";
+    } else if (iteratorInfo.shape === "keys") {
+      iterationShape = "keys";
+    }
+  }
+  const filterInfo = isFilterCall(chainSource);
+  const sortInfo = isSortCall(chainSource);
   if (sortInfo) {
     const innerFilter = isFilterCall(sortInfo.array);
     const sortExtraction = extractSortComparator(sortInfo.callback, sortInfo.method, ctx);
@@ -193076,8 +193259,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       }
     }
   } else {
-    array = ctx.getJS(mapSource);
-    arrayExpr = mapSource;
+    array = ctx.getJS(chainSource);
+    arrayExpr = chainSource;
   }
   const callback = node.arguments[0];
   let param = "item";
@@ -193087,21 +193270,36 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let children = [];
   let paramBindings;
   let flatMapCallback;
-  if (import_typescript10.default.isArrowFunction(callback)) {
+  if (import_typescript11.default.isArrowFunction(callback)) {
     if (callback.parameters.length > 0) {
       const firstParam = callback.parameters[0];
       param = firstParam.name.getText(ctx.sourceFile);
       if (firstParam.type) {
         paramType = firstParam.type.getText(ctx.sourceFile);
       }
-      const bindingResult = extractLoopParamBindings(firstParam.name);
-      if (bindingResult && !Array.isArray(bindingResult)) {
-        ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST, getSourceLocation(firstParam, ctx.sourceFile, ctx.filePath)));
-      } else if (Array.isArray(bindingResult)) {
-        paramBindings = bindingResult;
+      if (iterationShape === "entries" && import_typescript11.default.isArrayBindingPattern(firstParam.name)) {
+        const elements = firstParam.name.elements.filter((el) => !import_typescript11.default.isOmittedExpression(el));
+        if (elements.length === 2 && import_typescript11.default.isBindingElement(elements[0]) && import_typescript11.default.isIdentifier(elements[0].name) && import_typescript11.default.isBindingElement(elements[1]) && import_typescript11.default.isIdentifier(elements[1].name)) {
+          index = elements[0].name.text;
+          param = elements[1].name.text;
+        } else {
+          const bindingResult = extractLoopParamBindings(firstParam.name);
+          if (bindingResult && !Array.isArray(bindingResult)) {
+            ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST, getSourceLocation(firstParam, ctx.sourceFile, ctx.filePath)));
+          } else if (Array.isArray(bindingResult)) {
+            paramBindings = bindingResult;
+          }
+        }
+      } else {
+        const bindingResult = extractLoopParamBindings(firstParam.name);
+        if (bindingResult && !Array.isArray(bindingResult)) {
+          ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST, getSourceLocation(firstParam, ctx.sourceFile, ctx.filePath)));
+        } else if (Array.isArray(bindingResult)) {
+          paramBindings = bindingResult;
+        }
       }
     }
-    if (callback.parameters.length > 1) {
+    if (callback.parameters.length > 1 && iterationShape !== "entries") {
       const secondParam = callback.parameters[1];
       index = secondParam.name.getText(ctx.sourceFile);
       if (secondParam.type) {
@@ -193117,38 +193315,38 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     if (index)
       ctx.loopParams.add(index);
     const body = callback.body;
-    if (import_typescript10.default.isJsxElement(body) || import_typescript10.default.isJsxSelfClosingElement(body) || import_typescript10.default.isJsxFragment(body)) {
+    if (import_typescript11.default.isJsxElement(body) || import_typescript11.default.isJsxSelfClosingElement(body) || import_typescript11.default.isJsxFragment(body)) {
       const transformed = transformNode(body, ctx);
       if (transformed) {
         children = [transformed];
       }
-    } else if (import_typescript10.default.isConditionalExpression(body)) {
+    } else if (import_typescript11.default.isConditionalExpression(body)) {
       children = [transformConditional(body, ctx)];
-    } else if (import_typescript10.default.isParenthesizedExpression(body)) {
+    } else if (import_typescript11.default.isParenthesizedExpression(body)) {
       let inner = body.expression;
-      while (import_typescript10.default.isParenthesizedExpression(inner)) {
+      while (import_typescript11.default.isParenthesizedExpression(inner)) {
         inner = inner.expression;
       }
-      if (import_typescript10.default.isJsxElement(inner) || import_typescript10.default.isJsxSelfClosingElement(inner) || import_typescript10.default.isJsxFragment(inner)) {
+      if (import_typescript11.default.isJsxElement(inner) || import_typescript11.default.isJsxSelfClosingElement(inner) || import_typescript11.default.isJsxFragment(inner)) {
         const transformed = transformNode(inner, ctx);
         if (transformed) {
           children = [transformed];
         }
-      } else if (import_typescript10.default.isConditionalExpression(inner)) {
+      } else if (import_typescript11.default.isConditionalExpression(inner)) {
         children = [transformConditional(inner, ctx)];
-      } else if (method === "flatMap" && import_typescript10.default.isArrayLiteralExpression(inner)) {
+      } else if (method === "flatMap" && import_typescript11.default.isArrayLiteralExpression(inner)) {
         children = transformArrayLiteralChildren(inner, ctx);
       }
-    } else if (method === "flatMap" && import_typescript10.default.isArrayLiteralExpression(body)) {
+    } else if (method === "flatMap" && import_typescript11.default.isArrayLiteralExpression(body)) {
       children = transformArrayLiteralChildren(body, ctx);
-    } else if (import_typescript10.default.isBlock(body)) {
-      const returnStmt = body.statements.find((s) => import_typescript10.default.isReturnStatement(s) && s.expression != null);
+    } else if (import_typescript11.default.isBlock(body)) {
+      const returnStmt = body.statements.find((s) => import_typescript11.default.isReturnStatement(s) && s.expression != null);
       if (returnStmt && returnStmt.expression) {
         let returnExpr = returnStmt.expression;
-        while (import_typescript10.default.isParenthesizedExpression(returnExpr)) {
+        while (import_typescript11.default.isParenthesizedExpression(returnExpr)) {
           returnExpr = returnExpr.expression;
         }
-        if (import_typescript10.default.isJsxElement(returnExpr) || import_typescript10.default.isJsxSelfClosingElement(returnExpr) || import_typescript10.default.isJsxFragment(returnExpr)) {
+        if (import_typescript11.default.isJsxElement(returnExpr) || import_typescript11.default.isJsxSelfClosingElement(returnExpr) || import_typescript11.default.isJsxFragment(returnExpr)) {
           const transformed = transformNode(returnExpr, ctx);
           if (transformed) {
             children = [transformed];
@@ -193164,11 +193362,11 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
             break;
           const js = ctx.getJS(stmt);
           const tjs = ctx.getTemplateJS(stmt);
-          const ts11 = stmt.getText(ctx.sourceFile);
+          const ts12 = stmt.getText(ctx.sourceFile);
           preambleStmts.push(js.endsWith(";") ? js : js + ";");
           templatePreambleStmts.push(tjs.endsWith(";") ? tjs : tjs + ";");
-          typedPreambleStmts.push(ts11.endsWith(";") ? ts11 : ts11 + ";");
-          if (js !== ts11)
+          typedPreambleStmts.push(ts12.endsWith(";") ? ts12 : ts12 + ";");
+          if (js !== ts12)
             hasTypeDiff = true;
           if (js !== tjs)
             hasTemplateDiff = true;
@@ -193199,7 +193397,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   if (children.length === 0 && !flatMapCallback) {
     return null;
   }
-  if (import_typescript10.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
+  if (import_typescript11.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
     checkLoopKey(node.arguments[0], ctx, isNested);
   }
   const key = children.length > 0 ? extractLoopKey(children[0]) : null;
@@ -193246,6 +193444,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     filterPredicate,
     sortComparator,
     chainOrder,
+    iterationShape,
     clientOnly: isClientOnly || undefined,
     mapPreamble,
     templateMapPreamble,
@@ -193261,12 +193460,12 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
 function transformArrayLiteralChildren(arrayLiteral, ctx) {
   const children = [];
   for (const element of arrayLiteral.elements) {
-    if (import_typescript10.default.isSpreadElement(element))
+    if (import_typescript11.default.isSpreadElement(element))
       continue;
     let inner = element;
-    while (import_typescript10.default.isParenthesizedExpression(inner))
+    while (import_typescript11.default.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (import_typescript10.default.isJsxElement(inner) || import_typescript10.default.isJsxSelfClosingElement(inner) || import_typescript10.default.isJsxFragment(inner)) {
+    if (import_typescript11.default.isJsxElement(inner) || import_typescript11.default.isJsxSelfClosingElement(inner) || import_typescript11.default.isJsxFragment(inner)) {
       const transformed = transformNode(inner, ctx);
       if (transformed)
         children.push(transformed);
@@ -193275,7 +193474,7 @@ function transformArrayLiteralChildren(arrayLiteral, ctx) {
   return children;
 }
 function containsJsx(node) {
-  if (import_typescript10.default.isJsxElement(node) || import_typescript10.default.isJsxSelfClosingElement(node) || import_typescript10.default.isJsxFragment(node))
+  if (import_typescript11.default.isJsxElement(node) || import_typescript11.default.isJsxSelfClosingElement(node) || import_typescript11.default.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -193294,7 +193493,7 @@ function buildFlatMapCallback(callback, body, ctx) {
   const bodyText = sourceText.slice(bodyStart, bodyEnd);
   const jsxNodes = [];
   function collectJsx(n) {
-    if (import_typescript10.default.isJsxElement(n) || import_typescript10.default.isJsxSelfClosingElement(n) || import_typescript10.default.isJsxFragment(n)) {
+    if (import_typescript11.default.isJsxElement(n) || import_typescript11.default.isJsxSelfClosingElement(n) || import_typescript11.default.isJsxFragment(n)) {
       jsxNodes.push({
         node: n,
         start: n.getStart(ctx.sourceFile) - bodyStart,
@@ -193398,13 +193597,13 @@ function expandSpreadAttribute(attr, ctx) {
   }];
 }
 function attrFreeIdentifiers(attr) {
-  if (!attr.initializer || !import_typescript10.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !import_typescript11.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return;
   }
   return extractFreeIdentifiersFromNode(attr.initializer.expression);
 }
 function computeReactivityFlags(attr, ctx) {
-  if (!attr.initializer || !import_typescript10.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !import_typescript11.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return {};
   }
   const expr = attr.initializer.expression;
@@ -193430,22 +193629,22 @@ function processAttributes(attributes, ctx) {
   const events = [];
   let ref = null;
   for (const attr of attributes.properties) {
-    if (import_typescript10.default.isJsxSpreadAttribute(attr)) {
+    if (import_typescript11.default.isJsxSpreadAttribute(attr)) {
       attrs.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!import_typescript10.default.isJsxAttribute(attr))
+    if (!import_typescript11.default.isJsxAttribute(attr))
       continue;
     const name = attr.name.getText(ctx.sourceFile);
     if (name === "ref") {
-      if (attr.initializer && import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         ref = ctx.getJS(attr.initializer.expression);
       }
       continue;
     }
     if (/^on[A-Z]/.test(name)) {
-      if (attr.initializer && import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         const eventName = name.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         events.push({
@@ -193459,14 +193658,14 @@ function processAttributes(attributes, ctx) {
     }
     let value = getAttributeValue(attr, ctx);
     let clientOnly;
-    if (attr.initializer && import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value.kind === "expression" && value.templateExpr === undefined) {
         const rewritten = rewriteBarePropRefs2(value.expr, attr.initializer.expression, ctx);
         if (rewritten !== value.expr) {
           value = { ...value, templateExpr: rewritten };
         }
       }
-      if (hasLeadingClientDirective(attr.initializer.expression, ctx.sourceFile)) {
+      if (hasLeadingClientDirective(attr.initializer.expression, ctx.sourceFile) || shouldAutoDeferReactiveBrand(attr.initializer.expression, ctx)) {
         clientOnly = true;
       }
     }
@@ -193486,48 +193685,48 @@ function getAttributeValue(attr, ctx) {
   if (!attr.initializer) {
     return AttrValueOf.booleanAttr();
   }
-  if (import_typescript10.default.isStringLiteral(attr.initializer)) {
+  if (import_typescript11.default.isStringLiteral(attr.initializer)) {
     return AttrValueOf.literal(attr.initializer.text);
   }
-  if (import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+  if (import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
-    if (import_typescript10.default.isIdentifier(expr)) {
+    if (import_typescript11.default.isIdentifier(expr)) {
       const branchInit = ctx._branchScopeVars?.get(expr.text);
       if (branchInit && !initializerShapeContainsJsx(branchInit)) {
         expr = branchInit;
       }
     }
-    if (import_typescript10.default.isAwaitExpression(expr)) {
+    if (import_typescript11.default.isAwaitExpression(expr)) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
     }
     checkBareSignalOrMemoIdentifier(expr, ctx);
-    if (attr.name.getText(ctx.sourceFile) === "style" && import_typescript10.default.isObjectLiteralExpression(expr)) {
+    if (attr.name.getText(ctx.sourceFile) === "style" && import_typescript11.default.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
       if (cssString !== null) {
         return AttrValueOf.literal(cssString);
       }
     }
-    if (import_typescript10.default.isTemplateExpression(expr)) {
+    if (import_typescript11.default.isTemplateExpression(expr)) {
       const parts = parseTemplateLiteral(expr, ctx);
       if (parts.some((p) => p.type === "ternary" || p.type === "lookup")) {
         return AttrValueOf.template(parts);
       }
     }
-    if (import_typescript10.default.isIdentifier(expr)) {
+    if (import_typescript11.default.isIdentifier(expr)) {
       const resolved = tryResolveIdentifierAsTemplateLiteral(expr, ctx);
       if (resolved) {
         return AttrValueOf.template(resolved);
       }
     }
-    if (import_typescript10.default.isConditionalExpression(expr)) {
+    if (import_typescript11.default.isConditionalExpression(expr)) {
       const ternary = parseTernary(expr, ctx);
       if (ternary) {
         return AttrValueOf.template([ternary]);
       }
     }
-    if (import_typescript10.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript10.default.SyntaxKind.BarBarToken) {
-      if (import_typescript10.default.isIdentifier(expr.right) && expr.right.text === "undefined") {
+    if (import_typescript11.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript11.default.SyntaxKind.BarBarToken) {
+      if (import_typescript11.default.isIdentifier(expr.right) && expr.right.text === "undefined") {
         const baseExpr = ctx.getJS(expr.left);
         return AttrValueOf.expression(baseExpr, { presenceOrUndefined: true });
       }
@@ -193540,11 +193739,11 @@ function getAttributeValue(attr, ctx) {
 function tryStaticStyleObjectToCss(expr) {
   const parts = [];
   for (const prop of expr.properties) {
-    if (!import_typescript10.default.isPropertyAssignment(prop))
+    if (!import_typescript11.default.isPropertyAssignment(prop))
       return null;
-    if (!import_typescript10.default.isIdentifier(prop.name) && !import_typescript10.default.isStringLiteral(prop.name))
+    if (!import_typescript11.default.isIdentifier(prop.name) && !import_typescript11.default.isStringLiteral(prop.name))
       return null;
-    if (!import_typescript10.default.isStringLiteral(prop.initializer))
+    if (!import_typescript11.default.isStringLiteral(prop.initializer))
       return null;
     const key = prop.name.text.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
     parts.push(`${key}:${prop.initializer.text}`);
@@ -193557,7 +193756,7 @@ function parseTemplateLiteral(expr, ctx) {
     parts.push({ type: "string", value: expr.head.text });
   }
   for (const span of expr.templateSpans) {
-    if (import_typescript10.default.isConditionalExpression(span.expression)) {
+    if (import_typescript11.default.isConditionalExpression(span.expression)) {
       const ternary = parseTernary(span.expression, ctx);
       if (ternary) {
         parts.push(ternary);
@@ -193583,36 +193782,36 @@ function parseTemplateLiteral(expr, ctx) {
   return parts;
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
-  if (import_typescript10.default.isIdentifier(expr)) {
+  if (import_typescript11.default.isIdentifier(expr)) {
     const constInfo = findLocalConst(expr.text, ctx);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
     if (!ast)
       return null;
-    if (import_typescript10.default.isStringLiteral(ast) || import_typescript10.default.isNoSubstitutionTemplateLiteral(ast)) {
+    if (import_typescript11.default.isStringLiteral(ast) || import_typescript11.default.isNoSubstitutionTemplateLiteral(ast)) {
       return [{ type: "string", value: ast.text }];
     }
     return null;
   }
-  if (import_typescript10.default.isElementAccessExpression(expr)) {
-    if (!import_typescript10.default.isIdentifier(expr.expression))
+  if (import_typescript11.default.isElementAccessExpression(expr)) {
+    if (!import_typescript11.default.isIdentifier(expr.expression))
       return null;
     const constInfo = findLocalConst(expr.expression.text, ctx);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
-    if (!ast || !import_typescript10.default.isObjectLiteralExpression(ast))
+    if (!ast || !import_typescript11.default.isObjectLiteralExpression(ast))
       return null;
     const cases = {};
     for (const prop of ast.properties) {
-      if (!import_typescript10.default.isPropertyAssignment(prop))
+      if (!import_typescript11.default.isPropertyAssignment(prop))
         return null;
-      const keyName = prop.name && (import_typescript10.default.isStringLiteral(prop.name) || import_typescript10.default.isIdentifier(prop.name)) ? prop.name.text : null;
+      const keyName = prop.name && (import_typescript11.default.isStringLiteral(prop.name) || import_typescript11.default.isIdentifier(prop.name)) ? prop.name.text : null;
       if (!keyName)
         return null;
       const value = prop.initializer;
-      if (import_typescript10.default.isStringLiteral(value) || import_typescript10.default.isNoSubstitutionTemplateLiteral(value)) {
+      if (import_typescript11.default.isStringLiteral(value) || import_typescript11.default.isNoSubstitutionTemplateLiteral(value)) {
         cases[keyName] = value.text;
       } else {
         return null;
@@ -193639,10 +193838,10 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   const ast = parseConstInitializer(constInfo);
   if (!ast)
     return null;
-  if (import_typescript10.default.isNoSubstitutionTemplateLiteral(ast) || import_typescript10.default.isStringLiteral(ast)) {
+  if (import_typescript11.default.isNoSubstitutionTemplateLiteral(ast) || import_typescript11.default.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
-  if (!import_typescript10.default.isTemplateExpression(ast))
+  if (!import_typescript11.default.isTemplateExpression(ast))
     return null;
   let resolvedAny = false;
   const parts = [];
@@ -193680,14 +193879,14 @@ function parseConstInitializerImpl(c) {
   if (!c.value)
     return null;
   const wrapped = `const __bf_resolve__ = (${c.value})`;
-  const sf = import_typescript10.default.createSourceFile("__bf_resolve.ts", wrapped, import_typescript10.default.ScriptTarget.Latest, true, import_typescript10.default.ScriptKind.TS);
+  const sf = import_typescript11.default.createSourceFile("__bf_resolve.ts", wrapped, import_typescript11.default.ScriptTarget.Latest, true, import_typescript11.default.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript10.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
     return null;
-  return import_typescript10.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  return import_typescript11.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
 }
 function astText(node) {
   return node.getText(node.getSourceFile());
@@ -193708,10 +193907,10 @@ function parseTernary(expr, ctx) {
   return null;
 }
 function getStringValue(node) {
-  if (import_typescript10.default.isStringLiteral(node)) {
+  if (import_typescript11.default.isStringLiteral(node)) {
     return node.text;
   }
-  if (import_typescript10.default.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_typescript11.default.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
   return null;
@@ -193719,19 +193918,19 @@ function getStringValue(node) {
 function processComponentProps(attributes, ctx) {
   const props = [];
   for (const attr of attributes.properties) {
-    if (import_typescript10.default.isJsxSpreadAttribute(attr)) {
+    if (import_typescript11.default.isJsxSpreadAttribute(attr)) {
       props.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!import_typescript10.default.isJsxAttribute(attr))
+    if (!import_typescript11.default.isJsxAttribute(attr))
       continue;
     const name = attr.name.getText(ctx.sourceFile);
-    if (attr.initializer && import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       let jsxExpr = attr.initializer.expression;
-      while (import_typescript10.default.isParenthesizedExpression(jsxExpr)) {
+      while (import_typescript11.default.isParenthesizedExpression(jsxExpr)) {
         jsxExpr = jsxExpr.expression;
       }
-      if (import_typescript10.default.isJsxElement(jsxExpr) || import_typescript10.default.isJsxSelfClosingElement(jsxExpr) || import_typescript10.default.isJsxFragment(jsxExpr)) {
+      if (import_typescript11.default.isJsxElement(jsxExpr) || import_typescript11.default.isJsxSelfClosingElement(jsxExpr) || import_typescript11.default.isJsxFragment(jsxExpr)) {
         const prevInsideComponentChildren = ctx.insideComponentChildren;
         ctx.insideComponentChildren = true;
         const irNode = transformNode(jsxExpr, ctx);
@@ -193755,7 +193954,7 @@ function processComponentProps(attributes, ctx) {
       value = AttrValueOf.booleanShorthand();
     }
     let clientOnly;
-    if (attr.initializer && import_typescript10.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value.kind === "expression" && value.templateExpr === undefined) {
         const rewritten = rewriteBarePropRefs2(value.expr, attr.initializer.expression, ctx);
         if (rewritten !== value.expr) {
@@ -193794,7 +193993,7 @@ function templatePartsToJsString(parts) {
   return result;
 }
 function checkBareSignalOrMemoIdentifier(expr, ctx) {
-  if (!import_typescript10.default.isIdentifier(expr))
+  if (!import_typescript11.default.isIdentifier(expr))
     return;
   const name = expr.text;
   for (const signal of ctx.analyzer.signals) {
@@ -193825,12 +194024,12 @@ function checkBareSignalOrMemoIdentifier(expr, ctx) {
 function isArrayExprDirectPropRef(arrayExpr, ctx) {
   const propNames = new Set(ctx.patterns.props.map((p) => p.name));
   const propsObjName = ctx.analyzer.propsObjectName;
-  if (import_typescript10.default.isIdentifier(arrayExpr)) {
+  if (import_typescript11.default.isIdentifier(arrayExpr)) {
     return propNames.has(arrayExpr.text);
   }
-  if (import_typescript10.default.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+  if (import_typescript11.default.isPropertyAccessExpression(arrayExpr) && propsObjName) {
     const obj = arrayExpr.expression;
-    if (import_typescript10.default.isIdentifier(obj) && obj.text === propsObjName) {
+    if (import_typescript11.default.isIdentifier(obj) && obj.text === propsObjName) {
       return true;
     }
   }
@@ -193870,6 +194069,16 @@ function isReactiveExpression(expr, ctx, astNode) {
   }
   return false;
 }
+function shouldAutoDeferReactiveBrand(expr, ctx) {
+  const checker = ctx.analyzer.checker;
+  if (!checker)
+    return false;
+  if (!containsReactiveExpression(expr, checker))
+    return false;
+  if (isSignalOrMemoReference(ctx.getJS(expr), ctx))
+    return false;
+  return true;
+}
 function isSignalOrMemoReference(expr, ctx, visited) {
   for (const { pattern } of ctx.patterns.signals) {
     if (pattern.test(expr))
@@ -194012,7 +194221,7 @@ function buildIfStatementChain(analyzer, ctx) {
         jsxBranchLocalNames.add(n);
     }
     for (const decl of condReturn.scopeVariables) {
-      if (import_typescript10.default.isIdentifier(decl.name) && decl.initializer) {
+      if (import_typescript11.default.isIdentifier(decl.name) && decl.initializer) {
         branchScopeVars.set(decl.name.text, decl.initializer);
         if (initializerShapeContainsJsx(decl.initializer)) {
           jsxBranchLocalNames.add(decl.name.text);
@@ -194079,7 +194288,7 @@ function buildIfStatementChain(analyzer, ctx) {
     }
     const scopeVariables = [];
     for (const decl of condReturn.scopeVariables) {
-      if (import_typescript10.default.isIdentifier(decl.name) && decl.initializer) {
+      if (import_typescript11.default.isIdentifier(decl.name) && decl.initializer) {
         const init = ctx.getJS(decl.initializer);
         const typedInit = decl.initializer.getText(ctx.sourceFile);
         scopeVariables.push({
@@ -194105,45 +194314,6 @@ function buildIfStatementChain(analyzer, ctx) {
   return alternate;
 }
 
-// ../jsx/src/html-constants.ts
-var BOOLEAN_ATTRS = new Set([
-  "checked",
-  "disabled",
-  "readonly",
-  "selected",
-  "required",
-  "hidden",
-  "autofocus",
-  "autoplay",
-  "controls",
-  "loop",
-  "muted",
-  "open",
-  "multiple",
-  "novalidate"
-]);
-
-// ../jsx/src/ir-to-client-js/csr-substitute.ts
-var import_typescript11 = __toESM(require_typescript(), 1);
-
-// ../jsx/src/ir-to-client-js/html-template.ts
-var VOID_ELEMENTS = new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-
 // ../jsx/src/ir-to-client-js/identifiers.ts
 var KEYWORDS_AND_GLOBALS = new Set([
   "true",
@@ -194478,6 +194648,97 @@ var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
 ]);
+// ../jsx/src/debug.ts
+function escapeForIdBoundary(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function makeIdCallRegex(name) {
+  return new RegExp(`(?:^|[^\\w$])${escapeForIdBoundary(name)}\\s*\\(`);
+}
+function buildLocalFunctionSetterMap(meta, setterToSignal) {
+  const setterPatterns = [...setterToSignal.keys()].map((s) => ({ name: s, re: makeIdCallRegex(s) }));
+  const bodies = new Map;
+  for (const fn of meta.localFunctions)
+    bodies.set(fn.name, fn.body);
+  for (const c of meta.localConstants) {
+    if (c.containsArrow && c.value)
+      bodies.set(c.name, c.value);
+  }
+  const fnNamePatterns = [...bodies.keys()].map((n) => ({ name: n, re: makeIdCallRegex(n) }));
+  const directSetters = new Map;
+  const directCalls = new Map;
+  for (const [name, body] of bodies) {
+    const setters = [];
+    for (const { name: setter, re } of setterPatterns) {
+      if (re.test(body))
+        setters.push(setter);
+    }
+    directSetters.set(name, setters);
+    const calls = [];
+    for (const { name: callee, re } of fnNamePatterns) {
+      if (callee !== name && re.test(body))
+        calls.push(callee);
+    }
+    directCalls.set(name, calls);
+  }
+  const resolve2 = (name, stack) => {
+    const out = [];
+    const seen = new Set;
+    for (const setter of directSetters.get(name) ?? []) {
+      if (!seen.has(setter)) {
+        out.push({ setter, chain: [] });
+        seen.add(setter);
+      }
+    }
+    for (const callee of directCalls.get(name) ?? []) {
+      if (stack.has(callee))
+        continue;
+      const sub = resolve2(callee, new Set([...stack, callee]));
+      for (const r of sub) {
+        if (!seen.has(r.setter)) {
+          out.push({ setter: r.setter, chain: [callee, ...r.chain] });
+          seen.add(r.setter);
+        }
+      }
+    }
+    return out;
+  };
+  const result = new Map;
+  for (const name of bodies.keys()) {
+    const resolved = resolve2(name, new Set([name]));
+    if (resolved.length > 0)
+      result.set(name, resolved);
+  }
+  return result;
+}
+function resolveSetters(handler, setterToSignal, fnSetters) {
+  const refs = [];
+  const seen = new Set;
+  const trimmed = handler.trim();
+  for (const [setter, signal] of setterToSignal) {
+    if (trimmed === setter || makeIdCallRegex(setter).test(handler)) {
+      if (!seen.has(setter)) {
+        refs.push({ setter, signal });
+        seen.add(setter);
+      }
+    }
+  }
+  for (const [fnName, resolutions] of fnSetters) {
+    if (trimmed === fnName || makeIdCallRegex(fnName).test(handler)) {
+      for (const r of resolutions) {
+        if (!seen.has(r.setter)) {
+          refs.push({
+            setter: r.setter,
+            signal: setterToSignal.get(r.setter) ?? null,
+            via: [fnName, ...r.chain]
+          });
+          seen.add(r.setter);
+        }
+      }
+    }
+  }
+  return refs;
+}
 // src/test-node.ts
 class TestNode {
   tag;
@@ -194490,8 +194751,24 @@ class TestNode {
   aria;
   dataState;
   events;
+  handlers;
   reactive;
   componentName;
+  get onClick() {
+    return this.handlers.click;
+  }
+  get onInput() {
+    return this.handlers.input;
+  }
+  get onChange() {
+    return this.handlers.change;
+  }
+  get onSubmit() {
+    return this.handlers.submit;
+  }
+  on(event) {
+    return this.handlers[event] ?? null;
+  }
   constructor(data) {
     this.tag = data.tag;
     this.type = data.type;
@@ -194503,6 +194780,7 @@ class TestNode {
     this.aria = data.aria;
     this.dataState = data.dataState;
     this.events = data.events;
+    this.handlers = data.handlers;
     this.reactive = data.reactive;
     this.componentName = data.componentName;
   }
@@ -194550,41 +194828,52 @@ class TestNode {
 }
 
 // src/ir-to-test-node.ts
-function irNodeToTestNode(node, constantMap) {
+function irNodeToTestNode(node, constantMap, metadata) {
   const cmap = constantMap ?? new Map;
-  return convert(node, cmap);
+  const setterToSignal = new Map;
+  const fnSetters = new Map;
+  if (metadata) {
+    for (const s of metadata.signals) {
+      if (s.setter)
+        setterToSignal.set(s.setter, s.getter);
+    }
+    for (const [k, v] of buildLocalFunctionSetterMap(metadata, setterToSignal)) {
+      fnSetters.set(k, v);
+    }
+  }
+  return convert(node, { cmap, setterToSignal, fnSetters });
 }
-function convert(node, cmap) {
+function convert(node, ctx) {
   switch (node.type) {
     case "element":
-      return convertElement(node, cmap);
+      return convertElement(node, ctx);
     case "text":
       return convertText(node);
     case "expression":
       return convertExpression(node);
     case "conditional":
-      return convertConditional(node, cmap);
+      return convertConditional(node, ctx);
     case "loop":
-      return convertLoop(node, cmap);
+      return convertLoop(node, ctx);
     case "component":
-      return convertComponent(node, cmap);
+      return convertComponent(node, ctx);
     case "fragment":
-      return convertFragment(node, cmap);
+      return convertFragment(node, ctx);
     case "slot":
       return convertSlot(node);
     case "if-statement":
-      return convertIfStatement(node, cmap);
+      return convertIfStatement(node, ctx);
     case "provider":
-      return convertProvider(node, cmap);
+      return convertProvider(node, ctx);
     case "async":
-      return convertAsync(node, cmap);
+      return convertAsync(node, ctx);
     default: {
       const _exhaustive = node;
       throw new Error(`Unhandled IR node type: ${_exhaustive.type}`);
     }
   }
 }
-function convertElement(node, cmap) {
+function convertElement(node, ctx) {
   const props = {};
   const aria = {};
   let role = null;
@@ -194595,8 +194884,8 @@ function convertElement(node, cmap) {
     if (attr.name === "className" || attr.name === "class") {
       if (typeof value === "string") {
         const isDynamic = attr.value.kind === "expression" || attr.value.kind === "template" || attr.value.kind === "spread";
-        if (isDynamic && cmap.size > 0) {
-          const resolved = resolveClassValue(value, cmap);
+        if (isDynamic && ctx.cmap.size > 0) {
+          const resolved = resolveClassValue(value, ctx.cmap);
           if (resolved !== null) {
             classes = resolved.split(/\s+/).filter(Boolean);
             continue;
@@ -194627,7 +194916,12 @@ function convertElement(node, cmap) {
     props[attr.name] = value;
   }
   const events = node.events.map((e) => e.name);
-  const children = node.children.map((c) => convert(c, cmap));
+  const handlers = {};
+  for (const event of node.events) {
+    const refs = resolveSetters(event.handler, ctx.setterToSignal, ctx.fnSetters);
+    handlers[event.name] = refsToHandler(refs);
+  }
+  const children = node.children.map((c) => convert(c, ctx));
   return new TestNode({
     tag: node.tag,
     type: "element",
@@ -194639,6 +194933,7 @@ function convertElement(node, cmap) {
     aria,
     dataState,
     events,
+    handlers,
     reactive: false,
     componentName: null
   });
@@ -194655,6 +194950,7 @@ function convertText(node) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
@@ -194671,14 +194967,15 @@ function convertExpression(node) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: node.reactive,
     componentName: null
   });
 }
-function convertConditional(node, cmap) {
-  const children = [convert(node.whenTrue, cmap)];
+function convertConditional(node, ctx) {
+  const children = [convert(node.whenTrue, ctx)];
   if (node.whenFalse) {
-    children.push(convert(node.whenFalse, cmap));
+    children.push(convert(node.whenFalse, ctx));
   }
   return new TestNode({
     tag: null,
@@ -194691,12 +194988,13 @@ function convertConditional(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: node.reactive,
     componentName: null
   });
 }
-function convertLoop(node, cmap) {
-  const children = node.children.map((c) => convert(c, cmap));
+function convertLoop(node, ctx) {
+  const children = node.children.map((c) => convert(c, ctx));
   return new TestNode({
     tag: null,
     type: "loop",
@@ -194708,12 +195006,15 @@ function convertLoop(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
 }
-function convertComponent(node, cmap) {
+function convertComponent(node, ctx) {
   const props = {};
+  const events = [];
+  const handlers = {};
   for (const prop of node.props) {
     switch (prop.value.kind) {
       case "literal":
@@ -194734,8 +195035,13 @@ function convertComponent(node, cmap) {
         props[prop.name] = null;
         break;
     }
+    if (/^on[A-Z]/.test(prop.name) && prop.value.kind === "expression") {
+      const eventName = prop.name.charAt(2).toLowerCase() + prop.name.slice(3);
+      events.push(eventName);
+      handlers[eventName] = refsToHandler(resolveSetters(prop.value.expr, ctx.setterToSignal, ctx.fnSetters));
+    }
   }
-  const children = node.children.map((c) => convert(c, cmap));
+  const children = node.children.map((c) => convert(c, ctx));
   return new TestNode({
     tag: null,
     type: "component",
@@ -194746,13 +195052,14 @@ function convertComponent(node, cmap) {
     role: null,
     aria: {},
     dataState: null,
-    events: [],
+    events,
+    handlers,
     reactive: false,
     componentName: node.name
   });
 }
-function convertFragment(node, cmap) {
-  const children = node.children.map((c) => convert(c, cmap));
+function convertFragment(node, ctx) {
+  const children = node.children.map((c) => convert(c, ctx));
   return new TestNode({
     tag: null,
     type: "fragment",
@@ -194764,6 +195071,7 @@ function convertFragment(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
@@ -194780,14 +195088,15 @@ function convertSlot(_node) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
 }
-function convertIfStatement(node, cmap) {
-  const children = [convert(node.consequent, cmap)];
+function convertIfStatement(node, ctx) {
+  const children = [convert(node.consequent, ctx)];
   if (node.alternate) {
-    children.push(convert(node.alternate, cmap));
+    children.push(convert(node.alternate, ctx));
   }
   return new TestNode({
     tag: null,
@@ -194800,12 +195109,13 @@ function convertIfStatement(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
 }
-function convertProvider(node, cmap) {
-  const children = node.children.map((c) => convert(c, cmap));
+function convertProvider(node, ctx) {
+  const children = node.children.map((c) => convert(c, ctx));
   if (children.length === 1)
     return children[0];
   return new TestNode({
@@ -194819,12 +195129,13 @@ function convertProvider(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
 }
-function convertAsync(node, cmap) {
-  const children = node.children.map((c) => convert(c, cmap));
+function convertAsync(node, ctx) {
+  const children = node.children.map((c) => convert(c, ctx));
   return new TestNode({
     tag: null,
     type: "fragment",
@@ -194836,10 +195147,24 @@ function convertAsync(node, cmap) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });
 }
+function refsToHandler(refs) {
+  const setters = [];
+  const via = [];
+  for (const ref of refs) {
+    if (!setters.includes(ref.setter))
+      setters.push(ref.setter);
+    for (const v of ref.via ?? []) {
+      if (!via.includes(v))
+        via.push(v);
+    }
+  }
+  return { setters, via };
+}
 function resolveClassValue(value, cmap) {
   if (cmap.has(value)) {
     return cmap.get(value);
@@ -195015,7 +195340,7 @@ function renderToTest(source, filePath, componentName) {
   }
   const metadata = buildMetadata2(ctx);
   const constantMap = resolveConstants(metadata.localConstants);
-  const root = irNodeToTestNode(ir, constantMap);
+  const root = irNodeToTestNode(ir, constantMap, metadata);
   const signals = metadata.signals.map((s) => s.getter);
   const memos = metadata.memos.map((m) => m.name);
   const effects = metadata.effects.length;
@@ -195072,6 +195397,7 @@ function emptyResult(componentName, isClient, errors) {
     aria: {},
     dataState: null,
     events: [],
+    handlers: {},
     reactive: false,
     componentName: null
   });