@barefootjs/test 0.31.3 → 0.31.5

package/dist/index.js

@@ -187288,7 +187288,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 });
 
 // ../jsx/src/compiler.ts
-var import_typescript23 = __toESM(require_typescript(), 1);
+var import_typescript24 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/analyzer.ts
 var import_typescript9 = __toESM(require_typescript(), 1);
@@ -188846,6 +188846,24 @@ function templatePartsToJsExpr(parts, opts) {
   return result;
 }
 
+// ../jsx/src/identifier-pattern.ts
+function withUnicodeFlag(flags) {
+  return flags.includes("u") ? flags : `${flags}u`;
+}
+function escapeIdentifierForRegex(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ID_BOUNDARY_BEFORE = "(?<![\\p{ID_Continue}$])";
+var ID_BOUNDARY_AFTER = "(?![\\p{ID_Continue}$])";
+function identifierPattern(name, flags = "") {
+  const esc = escapeIdentifierForRegex(name);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}${ID_BOUNDARY_AFTER}`, withUnicodeFlag(flags));
+}
+function identifierCallPattern(name, flags = "") {
+  const esc = escapeIdentifierForRegex(name);
+  return new RegExp(`${ID_BOUNDARY_BEFORE}${esc}\\s*\\(`, withUnicodeFlag(flags));
+}
+
 // ../jsx/src/scanner/js-scanner.ts
 var import_typescript2 = __toESM(require_typescript(), 1);
 function* iterateJsTokens(text, start = 0, end = text.length) {
@@ -189229,6 +189247,83 @@ function extractFreeIdentifiersFromText(text) {
   return extractFreeIdentifiersFromNode(expr);
 }
 
+// ../jsx/src/scope/binding-scope.ts
+class BindingScope {
+  frames;
+  static EMPTY = new BindingScope([]);
+  constructor(frames) {
+    this.frames = frames;
+  }
+  enterLoopRow(loop) {
+    const bindings = new Map;
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      for (const b of loop.paramBindings)
+        bindings.set(b.name, { source: "destructure" });
+    } else {
+      bindings.set(loop.param, { source: "item" });
+    }
+    if (loop.index != null)
+      bindings.set(loop.index, { source: "index" });
+    for (const name of loop.preamble?.declaredNames ?? [])
+      bindings.set(name, { source: "preamble" });
+    const frame = { kind: "loop-row", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  enterCallback(params) {
+    const bindings = new Map;
+    for (const name of params)
+      bindings.set(name, { source: "param" });
+    const frame = { kind: "callback", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  isBound(name) {
+    for (const frame of this.frames) {
+      if (frame.bindings.has(name))
+        return true;
+    }
+    return false;
+  }
+  lookup(name) {
+    for (let depth = 0;depth < this.frames.length; depth++) {
+      const frame = this.frames[depth];
+      const binding = frame.bindings.get(name);
+      if (binding)
+        return { depth, frame, binding };
+    }
+    return null;
+  }
+  boundNames() {
+    if (this.boundNamesCache)
+      return this.boundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const name of frame.bindings.keys())
+        names.add(name);
+    }
+    this.boundNamesCache = names;
+    return names;
+  }
+  boundNamesCache;
+  valueBoundNamesCache;
+  valueBoundNames() {
+    if (this.valueBoundNamesCache)
+      return this.valueBoundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const [name, binding] of frame.bindings) {
+        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+          names.add(name);
+        }
+      }
+    }
+    this.valueBoundNamesCache = names;
+    return names;
+  }
+  asShadowPredicate() {
+    return (name) => this.isBound(name);
+  }
+}
+
 // ../jsx/src/ir-to-client-js/html-template.ts
 function splitTemplateInterpolations(inner) {
   const parts = [];
@@ -193544,7 +193639,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
 }
 
 // ../jsx/src/jsx-to-ir.ts
-var import_typescript12 = __toESM(require_typescript(), 1);
+var import_typescript13 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -193620,6 +193715,7 @@ var AttrValueOf = {
 };
 
 // ../jsx/src/module-exports.ts
+var import_typescript10 = __toESM(require_typescript(), 1);
 function formatParamWithType(p) {
   const rest = p.isRest ? "..." : "";
   const optional = p.optional ? "?" : "";
@@ -193633,7 +193729,7 @@ function findReachableNames(primaryRefs, declarations) {
   const reachable = new Set;
   const queue = [];
   for (const name of allNames) {
-    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+    if (identifierPattern(name).test(primaryRefs)) {
       reachable.add(name);
       queue.push(name);
     }
@@ -193642,7 +193738,7 @@ function findReachableNames(primaryRefs, declarations) {
     const current = queue.shift();
     const body = bodyMap.get(current) || "";
     for (const name of allNames) {
-      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+      if (!reachable.has(name) && identifierPattern(name).test(body)) {
         reachable.add(name);
         queue.push(name);
       }
@@ -193650,6 +193746,49 @@ function findReachableNames(primaryRefs, declarations) {
   }
   return reachable;
 }
+function findAssignedNames(bodyText, candidates) {
+  const assigned = new Set;
+  if (candidates.size === 0)
+    return assigned;
+  const sf = import_typescript10.default.createSourceFile("bf-assignment-scan.tsx", bodyText, import_typescript10.default.ScriptTarget.Latest, false, import_typescript10.default.ScriptKind.TSX);
+  const record = (target) => {
+    if (import_typescript10.default.isIdentifier(target) && candidates.has(target.text)) {
+      assigned.add(target.text);
+    }
+  };
+  const visit2 = (node) => {
+    if (import_typescript10.default.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+      record(node.left);
+    } else if ((import_typescript10.default.isPrefixUnaryExpression(node) || import_typescript10.default.isPostfixUnaryExpression(node)) && (node.operator === import_typescript10.default.SyntaxKind.PlusPlusToken || node.operator === import_typescript10.default.SyntaxKind.MinusMinusToken)) {
+      record(node.operand);
+    }
+    import_typescript10.default.forEachChild(node, visit2);
+  };
+  import_typescript10.default.forEachChild(sf, visit2);
+  return assigned;
+}
+function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
+  let reachable = findReachableNames(primaryRefs, declarations);
+  if (mutableNames.size === 0)
+    return reachable;
+  let seedText = primaryRefs;
+  for (let round = 0;round <= declarations.length; round++) {
+    const survivingMutables = new Set([...reachable].filter((name) => mutableNames.has(name)));
+    if (survivingMutables.size === 0)
+      return reachable;
+    const added = declarations.filter((d) => !reachable.has(d.name)).filter((d) => findAssignedNames(d.body, survivingMutables).size > 0).map((d) => d.name);
+    if (added.length === 0)
+      return reachable;
+    seedText += `
+` + added.join(`
+`);
+    reachable = findReachableNames(seedText, declarations);
+  }
+  return reachable;
+}
+function isAssignmentOperator(kind) {
+  return kind >= import_typescript10.default.SyntaxKind.FirstAssignment && kind <= import_typescript10.default.SyntaxKind.LastAssignment;
+}
 
 // ../jsx/src/builtins.ts
 var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
@@ -193658,7 +193797,7 @@ function isClientBuiltinName(name) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-var import_typescript10 = __toESM(require_typescript(), 1);
+var import_typescript11 = __toESM(require_typescript(), 1);
 var REACTIVE_BRAND = "__reactive";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
@@ -193676,7 +193815,7 @@ function safeGetText(node) {
   }
 }
 function analyze(node, checker) {
-  if (import_typescript10.default.isPropertyAccessExpression(node)) {
+  if (import_typescript11.default.isPropertyAccessExpression(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -193700,7 +193839,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (import_typescript10.default.isIdentifier(node)) {
+  if (import_typescript11.default.isIdentifier(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -193712,7 +193851,7 @@ function analyze(node, checker) {
     } catch {}
     return NOT_REACTIVE;
   }
-  if (import_typescript10.default.isCallExpression(node)) {
+  if (import_typescript11.default.isCallExpression(node)) {
     try {
       const calleeType = queryType(checker, node.expression);
       if (isReactiveType(calleeType)) {
@@ -193725,7 +193864,7 @@ function analyze(node, checker) {
   }
   let foundChild;
   let foundChildText = "";
-  import_typescript10.default.forEachChild(node, (child) => {
+  import_typescript11.default.forEachChild(node, (child) => {
     if (foundChild?.isReactive)
       return;
     const result = analyze(child, checker);
@@ -193754,7 +193893,7 @@ function containsReactiveExpression(node, checker) {
 }
 
 // ../jsx/src/free-refs.ts
-var import_typescript11 = __toESM(require_typescript(), 1);
+var import_typescript12 = __toESM(require_typescript(), 1);
 var _bindingMapCache = new WeakMap;
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
@@ -193792,8 +193931,8 @@ function buildBindingMap(env) {
   for (const m of env.memos) {
     map.set(m.name, "memo-getter");
   }
-  if (env.loopParams) {
-    for (const name of env.loopParams)
+  if (env.loopValueBoundNames) {
+    for (const name of env.loopValueBoundNames)
       map.set(name, "render-item");
   }
   _bindingMapCache.set(env, map);
@@ -193822,20 +193961,20 @@ function defaultBindingScope(kind) {
 function collectIdentifiers2(node) {
   const out = [];
   const visit2 = (n, parent) => {
-    if (import_typescript11.default.isIdentifier(n)) {
-      if (parent && import_typescript11.default.isPropertyAccessExpression(parent) && parent.name === n)
+    if (import_typescript12.default.isIdentifier(n)) {
+      if (parent && import_typescript12.default.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && import_typescript11.default.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && import_typescript12.default.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && (import_typescript11.default.isJsxOpeningElement(parent) || import_typescript11.default.isJsxClosingElement(parent) || import_typescript11.default.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
+      if (parent && (import_typescript12.default.isJsxOpeningElement(parent) || import_typescript12.default.isJsxClosingElement(parent) || import_typescript12.default.isJsxSelfClosingElement(parent)) && parent.tagName === n) {
         return;
       }
-      if (parent && import_typescript11.default.isJsxAttribute(parent) && parent.name === n)
+      if (parent && import_typescript12.default.isJsxAttribute(parent) && parent.name === n)
         return;
       out.push(n);
       return;
     }
-    import_typescript11.default.forEachChild(n, (child) => visit2(child, n));
+    import_typescript12.default.forEachChild(n, (child) => visit2(child, n));
   };
   visit2(node);
   return out;
@@ -193844,7 +193983,7 @@ function collectReactiveBrandRefs(node, checker) {
   const out = [];
   const seen = new Set;
   const visit2 = (n) => {
-    if (import_typescript11.default.isPropertyAccessExpression(n)) {
+    if (import_typescript12.default.isPropertyAccessExpression(n)) {
       try {
         const type2 = checker.getTypeAtLocation(n);
         if (isReactiveType(type2)) {
@@ -193862,7 +194001,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    import_typescript11.default.forEachChild(n, visit2);
+    import_typescript12.default.forEachChild(n, visit2);
   };
   visit2(node);
   return out;
@@ -193872,14 +194011,14 @@ function resolveConstantInitializerRefs(c, env, visited) {
     return [];
   if (c.containsArrow)
     return [];
-  const sf = import_typescript11.default.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, import_typescript11.default.ScriptTarget.Latest, true);
+  const sf = import_typescript12.default.createSourceFile("__const_init.ts", `const __probe = (${c.value});`, import_typescript12.default.ScriptTarget.Latest, true);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript12.default.isVariableStatement(stmt))
     return [];
   const decl = stmt.declarationList.declarations[0];
   if (!decl || !decl.initializer)
     return [];
-  const expr = import_typescript11.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  const expr = import_typescript12.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
   return resolveFreeRefsInternal(expr, env, visited);
 }
 function resolveFreeRefsInternal(node, env, visited) {
@@ -193891,7 +194030,7 @@ function resolveFreeRefsInternal(node, env, visited) {
     const name = ident.text;
     if (env.propsObjectName === name) {
       const parent = ident.parent;
-      if (parent && import_typescript11.default.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
+      if (parent && import_typescript12.default.isPropertyAccessExpression(parent) && parent.expression === ident && parent.name.text === "children") {
         continue;
       }
     }
@@ -194294,83 +194433,6 @@ var toLocaleDatePlugin = {
   }
 };
 
-// ../jsx/src/scope/binding-scope.ts
-class BindingScope {
-  frames;
-  static EMPTY = new BindingScope([]);
-  constructor(frames) {
-    this.frames = frames;
-  }
-  enterLoopRow(loop) {
-    const bindings = new Map;
-    if (loop.paramBindings && loop.paramBindings.length > 0) {
-      for (const b of loop.paramBindings)
-        bindings.set(b.name, { source: "destructure" });
-    } else {
-      bindings.set(loop.param, { source: "item" });
-    }
-    if (loop.index != null)
-      bindings.set(loop.index, { source: "index" });
-    for (const name of loop.preamble?.declaredNames ?? [])
-      bindings.set(name, { source: "preamble" });
-    const frame = { kind: "loop-row", bindings };
-    return new BindingScope([frame, ...this.frames]);
-  }
-  enterCallback(params) {
-    const bindings = new Map;
-    for (const name of params)
-      bindings.set(name, { source: "param" });
-    const frame = { kind: "callback", bindings };
-    return new BindingScope([frame, ...this.frames]);
-  }
-  isBound(name) {
-    for (const frame of this.frames) {
-      if (frame.bindings.has(name))
-        return true;
-    }
-    return false;
-  }
-  lookup(name) {
-    for (let depth = 0;depth < this.frames.length; depth++) {
-      const frame = this.frames[depth];
-      const binding = frame.bindings.get(name);
-      if (binding)
-        return { depth, frame, binding };
-    }
-    return null;
-  }
-  boundNames() {
-    if (this.boundNamesCache)
-      return this.boundNamesCache;
-    const names = new Set;
-    for (const frame of this.frames) {
-      for (const name of frame.bindings.keys())
-        names.add(name);
-    }
-    this.boundNamesCache = names;
-    return names;
-  }
-  boundNamesCache;
-  valueBoundNamesCache;
-  valueBoundNames() {
-    if (this.valueBoundNamesCache)
-      return this.valueBoundNamesCache;
-    const names = new Set;
-    for (const frame of this.frames) {
-      for (const [name, binding] of frame.bindings) {
-        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
-          names.add(name);
-        }
-      }
-    }
-    this.valueBoundNamesCache = names;
-    return names;
-  }
-  asShadowPredicate() {
-    return (name) => this.isBound(name);
-  }
-}
-
 // ../jsx/src/jsx-to-ir.ts
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
@@ -194396,13 +194458,13 @@ function exprCallsReactiveGetters(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript12.default.isCallExpression(n) && import_typescript12.default.isIdentifier(n.expression)) {
+    if (import_typescript13.default.isCallExpression(n) && import_typescript13.default.isIdentifier(n.expression)) {
       if (names.has(n.expression.text)) {
         found = true;
         return;
       }
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -194429,11 +194491,11 @@ function exprReferencesModuleClientSignal(expr, ctx) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript12.default.isCallExpression(n) && import_typescript12.default.isIdentifier(n.expression) && names.has(n.expression.text)) {
+    if (import_typescript13.default.isCallExpression(n) && import_typescript13.default.isIdentifier(n.expression) && names.has(n.expression.text)) {
       found = true;
       return;
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -194443,11 +194505,11 @@ function exprHasFunctionCalls(expr) {
   function visit2(n) {
     if (found)
       return;
-    if (import_typescript12.default.isCallExpression(n)) {
+    if (import_typescript13.default.isCallExpression(n)) {
       found = true;
       return;
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   }
   visit2(expr);
   return found;
@@ -194484,10 +194546,10 @@ function lowerDateCalls(text, expr, ctx) {
     return text;
   const candidates = [];
   function visit2(n) {
-    if (import_typescript12.default.isCallExpression(n) && n.arguments.length === 0 && import_typescript12.default.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (import_typescript13.default.isCallExpression(n) && n.arguments.length === 0 && import_typescript13.default.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   }
   visit2(expr);
   if (candidates.length === 0)
@@ -194512,10 +194574,10 @@ function lowerToLocaleDateCalls(text, expr, ctx) {
     return text;
   const candidates = [];
   function visit2(n) {
-    if (import_typescript12.default.isCallExpression(n) && n.arguments.length === 2 && import_typescript12.default.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (import_typescript13.default.isCallExpression(n) && n.arguments.length === 2 && import_typescript13.default.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   }
   visit2(expr);
   if (candidates.length === 0)
@@ -194569,10 +194631,10 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
     return;
   let acc;
   function visit2(n, parent) {
-    if (import_typescript12.default.isIdentifier(n) && propDepsMap.has(n.text)) {
-      const isObjectKey = parent && import_typescript12.default.isPropertyAssignment(parent) && parent.name === n;
-      const isShorthand = parent && import_typescript12.default.isShorthandPropertyAssignment(parent) && parent.name === n;
-      const isAccessName = parent && import_typescript12.default.isPropertyAccessExpression(parent) && parent.name === n;
+    if (import_typescript13.default.isIdentifier(n) && propDepsMap.has(n.text)) {
+      const isObjectKey = parent && import_typescript13.default.isPropertyAssignment(parent) && parent.name === n;
+      const isShorthand = parent && import_typescript13.default.isShorthandPropertyAssignment(parent) && parent.name === n;
+      const isAccessName = parent && import_typescript13.default.isPropertyAccessExpression(parent) && parent.name === n;
       if (!isObjectKey && !isShorthand && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
@@ -194583,7 +194645,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx) {
         }
       }
     }
-    import_typescript12.default.forEachChild(n, (child) => visit2(child, n));
+    import_typescript13.default.forEachChild(n, (child) => visit2(child, n));
   }
   visit2(node);
   return acc;
@@ -194634,17 +194696,17 @@ function createTransformContext(analyzer) {
     patterns: {
       signals: analyzer.signals.map((s) => ({
         getter: s.getter,
-        pattern: new RegExp(`\\b${s.getter}\\s*\\(`)
+        pattern: identifierCallPattern(s.getter)
       })),
       memos: analyzer.memos.map((m) => ({
         name: m.name,
-        pattern: new RegExp(`\\b${m.name}\\s*\\(`)
+        pattern: identifierCallPattern(m.name)
       })),
-      props: analyzer.propsParams.filter((p) => p.name !== "children").map((p) => ({ name: p.name, pattern: new RegExp(`\\b${p.name}\\b`) })),
+      props: analyzer.propsParams.filter((p) => p.name !== "children").map((p) => ({ name: p.name, pattern: identifierPattern(p.name) })),
       constants: analyzer.localConstants.map((c) => ({
         name: c.name,
         value: c.value,
-        pattern: new RegExp(`\\b${c.name}\\b`)
+        pattern: identifierPattern(c.name)
       }))
     },
     getJS(node) {
@@ -194659,21 +194721,21 @@ function createTransformContext(analyzer) {
 function buildComponentNamespaces(ctx) {
   const result = new Map;
   for (const stmt of ctx.sourceFile.statements) {
-    if (!import_typescript12.default.isVariableStatement(stmt))
+    if (!import_typescript13.default.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !import_typescript12.default.isIdentifier(decl.name))
+      if (!decl.initializer || !import_typescript13.default.isIdentifier(decl.name))
         continue;
       let init = decl.initializer;
-      while (import_typescript12.default.isParenthesizedExpression(init))
+      while (import_typescript13.default.isParenthesizedExpression(init))
         init = init.expression;
-      if (!import_typescript12.default.isObjectLiteralExpression(init))
+      if (!import_typescript13.default.isObjectLiteralExpression(init))
         continue;
       const members = new Map;
       for (const prop of init.properties) {
-        if (import_typescript12.default.isShorthandPropertyAssignment(prop)) {
+        if (import_typescript13.default.isShorthandPropertyAssignment(prop)) {
           members.set(prop.name.text, prop.name.text);
-        } else if (import_typescript12.default.isPropertyAssignment(prop) && (import_typescript12.default.isIdentifier(prop.name) || import_typescript12.default.isStringLiteral(prop.name)) && import_typescript12.default.isIdentifier(prop.initializer)) {
+        } else if (import_typescript13.default.isPropertyAssignment(prop) && (import_typescript13.default.isIdentifier(prop.name) || import_typescript13.default.isStringLiteral(prop.name)) && import_typescript13.default.isIdentifier(prop.initializer)) {
           members.set(prop.name.text, prop.initializer.text);
         }
       }
@@ -194685,11 +194747,11 @@ function buildComponentNamespaces(ctx) {
   return result;
 }
 function resolveMemberExpressionTag(tagNode, ctx) {
-  if (!import_typescript12.default.isPropertyAccessExpression(tagNode))
+  if (!import_typescript13.default.isPropertyAccessExpression(tagNode))
     return null;
-  if (!import_typescript12.default.isIdentifier(tagNode.expression))
+  if (!import_typescript13.default.isIdentifier(tagNode.expression))
     return null;
-  if (!import_typescript12.default.isIdentifier(tagNode.name))
+  if (!import_typescript13.default.isIdentifier(tagNode.name))
     return null;
   if (!ctx._componentNamespaces) {
     ctx._componentNamespaces = buildComponentNamespaces(ctx);
@@ -194722,7 +194784,7 @@ function makeBindingEnv(ctx) {
     localFunctions: a.localFunctions,
     imports: a.imports,
     ambientGlobals: a.ambientGlobals,
-    loopParams: boundNames,
+    loopValueBoundNames: boundNames,
     checker: a.checker
   };
   ctx._bindingEnv = env;
@@ -194846,7 +194908,7 @@ function buildIRRoot(analyzer) {
     return null;
   const ctx = createTransformContext(analyzer);
   const jsxReturn = analyzer.jsxReturn;
-  if (import_typescript12.default.isJsxElement(jsxReturn) || import_typescript12.default.isJsxSelfClosingElement(jsxReturn) || import_typescript12.default.isJsxFragment(jsxReturn)) {
+  if (import_typescript13.default.isJsxElement(jsxReturn) || import_typescript13.default.isJsxSelfClosingElement(jsxReturn) || import_typescript13.default.isJsxFragment(jsxReturn)) {
     const ir2 = transformNode(jsxReturn, ctx);
     if (ir2 && needsScopeWrapper(ir2)) {
       return wrapInScopeElement(ir2);
@@ -194902,22 +194964,22 @@ function wrapInScopeElement(node) {
   };
 }
 function transformNode(node, ctx) {
-  if (import_typescript12.default.isJsxElement(node)) {
+  if (import_typescript13.default.isJsxElement(node)) {
     return transformJsxElement(node, ctx);
   }
-  if (import_typescript12.default.isJsxSelfClosingElement(node)) {
+  if (import_typescript13.default.isJsxSelfClosingElement(node)) {
     return transformSelfClosingElement(node, ctx);
   }
-  if (import_typescript12.default.isJsxFragment(node)) {
+  if (import_typescript13.default.isJsxFragment(node)) {
     return transformFragment(node, ctx);
   }
-  if (import_typescript12.default.isJsxText(node)) {
+  if (import_typescript13.default.isJsxText(node)) {
     return transformText(node, ctx);
   }
-  if (import_typescript12.default.isJsxExpression(node)) {
+  if (import_typescript13.default.isJsxExpression(node)) {
     return transformExpression(node, ctx);
   }
-  if (import_typescript12.default.isConditionalExpression(node)) {
+  if (import_typescript13.default.isConditionalExpression(node)) {
     return transformConditional(node, ctx);
   }
   return null;
@@ -195274,7 +195336,7 @@ function transformSelfClosingComponent(node, ctx, name) {
 }
 function isTransparentFragment(node, ctx) {
   const children = node.children.filter((child2) => {
-    if (import_typescript12.default.isJsxText(child2)) {
+    if (import_typescript13.default.isJsxText(child2)) {
       return child2.text.trim() !== "";
     }
     return true;
@@ -195282,7 +195344,7 @@ function isTransparentFragment(node, ctx) {
   if (children.length !== 1)
     return false;
   const child = children[0];
-  if (!import_typescript12.default.isJsxExpression(child))
+  if (!import_typescript13.default.isJsxExpression(child))
     return false;
   if (!child.expression)
     return false;
@@ -195326,7 +195388,7 @@ function transformChildren(children, ctx) {
   const result = [];
   for (let i2 = 0;i2 < children.length; i2++) {
     const child = children[i2];
-    if (import_typescript12.default.isJsxExpression(child) && !child.expression) {
+    if (import_typescript13.default.isJsxExpression(child) && !child.expression) {
       continue;
     }
     const transformed = transformNode(child, ctx);
@@ -195341,10 +195403,10 @@ function transformChildren(children, ctx) {
 }
 function isRenderNothingLiteral(expr, ctx) {
   let e = expr;
-  while (import_typescript12.default.isParenthesizedExpression(e) || import_typescript12.default.isAsExpression(e) || import_typescript12.default.isSatisfiesExpression(e) || import_typescript12.default.isNonNullExpression(e)) {
+  while (import_typescript13.default.isParenthesizedExpression(e) || import_typescript13.default.isAsExpression(e) || import_typescript13.default.isSatisfiesExpression(e) || import_typescript13.default.isNonNullExpression(e)) {
     e = e.expression;
   }
-  return e.kind === import_typescript12.default.SyntaxKind.NullKeyword || e.kind === import_typescript12.default.SyntaxKind.TrueKeyword || e.kind === import_typescript12.default.SyntaxKind.FalseKeyword || import_typescript12.default.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx));
+  return e.kind === import_typescript13.default.SyntaxKind.NullKeyword || e.kind === import_typescript13.default.SyntaxKind.TrueKeyword || e.kind === import_typescript13.default.SyntaxKind.FalseKeyword || import_typescript13.default.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx));
 }
 function transformText(node, ctx) {
   const text = node.text.replace(/\s+/g, " ");
@@ -195370,7 +195432,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
     return null;
   }
   checkBareSignalOrMemoIdentifier(expr, ctx);
-  if (import_typescript12.default.isIdentifier(expr)) {
+  if (import_typescript13.default.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
       return transformNode(jsxNode, ctx);
@@ -195416,7 +195478,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   };
   const reactive = isReactiveExpression(exprText, ctx, expr) || isReactiveOrigin(origin);
   const scopeValueNames = ctx.scope.valueBoundNames();
-  const refsLoopParam = scopeValueNames.size > 0 && Array.from(scopeValueNames).some((p) => new RegExp(`\\b${p}\\b`).test(exprText));
+  const refsLoopParam = scopeValueNames.size > 0 && Array.from(scopeValueNames).some((p) => identifierPattern(p).test(exprText));
   const callsReactive = exprCallsReactiveGetters(expr, ctx);
   const hasCalls = exprHasFunctionCalls(expr);
   const needsSlot = reactive || isClientOnly || refsLoopParam || callsReactive || hasCalls;
@@ -195451,7 +195513,7 @@ function transformJsxFunctionCall(callExpr, jsxFunc, ctx, _isClientOnly) {
   const substitutedGetJS = (node) => {
     let text = baseGetJS(node);
     for (const [paramName, argExpr] of substitutions) {
-      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+      text = text.replace(identifierPattern(paramName, "g"), () => argExpr);
     }
     return text;
   };
@@ -195493,7 +195555,7 @@ function transformMultiReturnJsxFunctionCall(callExpr, info, ctx) {
   const substitutedGetJS = (node) => {
     let text = baseGetJS(node);
     for (const [paramName, argExpr] of substitutions) {
-      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+      text = text.replace(identifierPattern(paramName, "g"), () => argExpr);
     }
     return text;
   };
@@ -195649,38 +195711,38 @@ function transformLogicalAnd(node, ctx) {
   };
 }
 function containsJsxInExpression(node) {
-  if (import_typescript12.default.isJsxElement(node) || import_typescript12.default.isJsxSelfClosingElement(node) || import_typescript12.default.isJsxFragment(node)) {
+  if (import_typescript13.default.isJsxElement(node) || import_typescript13.default.isJsxSelfClosingElement(node) || import_typescript13.default.isJsxFragment(node)) {
     return true;
   }
-  return import_typescript12.default.forEachChild(node, containsJsxInExpression) ?? false;
+  return import_typescript13.default.forEachChild(node, containsJsxInExpression) ?? false;
 }
 function callsJsxHelper(node, ctx) {
   let found = false;
   const visit2 = (n) => {
     if (found)
       return;
-    if (import_typescript12.default.isCallExpression(n) && import_typescript12.default.isIdentifier(n.expression)) {
+    if (import_typescript13.default.isCallExpression(n) && import_typescript13.default.isIdentifier(n.expression)) {
       const name = n.expression.text;
       if (ctx.analyzer.jsxFunctions.has(name) || ctx.analyzer.jsxMultiReturnFunctions.has(name)) {
         found = true;
         return;
       }
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   };
   visit2(node);
   return found;
 }
 function containsAwaitExpression(node) {
-  if (import_typescript12.default.isAwaitExpression(node))
+  if (import_typescript13.default.isAwaitExpression(node))
     return true;
-  if (import_typescript12.default.isFunctionDeclaration(node) || import_typescript12.default.isFunctionExpression(node) || import_typescript12.default.isArrowFunction(node))
+  if (import_typescript13.default.isFunctionDeclaration(node) || import_typescript13.default.isFunctionExpression(node) || import_typescript13.default.isArrowFunction(node))
     return false;
-  return import_typescript12.default.forEachChild(node, containsAwaitExpression) ?? false;
+  return import_typescript13.default.forEachChild(node, containsAwaitExpression) ?? false;
 }
 function transformNullishCoalescing(node, ctx) {
   const leftText = ctx.getJS(node.left);
-  const isNullish = node.operatorToken.kind === import_typescript12.default.SyntaxKind.QuestionQuestionToken;
+  const isNullish = node.operatorToken.kind === import_typescript13.default.SyntaxKind.QuestionQuestionToken;
   const condition = isNullish ? `${leftText} != null` : leftText;
   const leftOrigin = {
     phase: "tick",
@@ -195726,36 +195788,36 @@ function transformNullishCoalescing(node, ctx) {
 }
 function assertNever2(expr) {
   const kind = expr?.kind;
-  throw new Error(`transformJsxExpression: unhandled ts.SyntaxKind ${kind !== undefined ? import_typescript12.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_typescript13.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_typescript12.default.SyntaxKind.ParenthesizedExpression:
-    case import_typescript12.default.SyntaxKind.AsExpression:
-    case import_typescript12.default.SyntaxKind.SatisfiesExpression:
-    case import_typescript12.default.SyntaxKind.NonNullExpression:
-    case import_typescript12.default.SyntaxKind.TypeAssertionExpression:
-    case import_typescript12.default.SyntaxKind.PartiallyEmittedExpression:
+    case import_typescript13.default.SyntaxKind.ParenthesizedExpression:
+    case import_typescript13.default.SyntaxKind.AsExpression:
+    case import_typescript13.default.SyntaxKind.SatisfiesExpression:
+    case import_typescript13.default.SyntaxKind.NonNullExpression:
+    case import_typescript13.default.SyntaxKind.TypeAssertionExpression:
+    case import_typescript13.default.SyntaxKind.PartiallyEmittedExpression:
       return transformJsxExpression(node.expression, ctx, isClientOnly);
-    case import_typescript12.default.SyntaxKind.JsxElement:
+    case import_typescript13.default.SyntaxKind.JsxElement:
       return transformJsxElement(node, ctx);
-    case import_typescript12.default.SyntaxKind.JsxFragment:
+    case import_typescript13.default.SyntaxKind.JsxFragment:
       return transformFragment(node, ctx);
-    case import_typescript12.default.SyntaxKind.JsxSelfClosingElement:
+    case import_typescript13.default.SyntaxKind.JsxSelfClosingElement:
       return transformSelfClosingElement(node, ctx);
-    case import_typescript12.default.SyntaxKind.ConditionalExpression:
+    case import_typescript13.default.SyntaxKind.ConditionalExpression:
       return transformConditional(node, ctx);
-    case import_typescript12.default.SyntaxKind.BinaryExpression: {
-      if (node.operatorToken.kind === import_typescript12.default.SyntaxKind.AmpersandAmpersandToken) {
+    case import_typescript13.default.SyntaxKind.BinaryExpression: {
+      if (node.operatorToken.kind === import_typescript13.default.SyntaxKind.AmpersandAmpersandToken) {
         return transformLogicalAnd(node, ctx);
       }
-      if ((node.operatorToken.kind === import_typescript12.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript12.default.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx))) {
+      if ((node.operatorToken.kind === import_typescript13.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript13.default.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx))) {
         return transformNullishCoalescing(node, ctx);
       }
       return null;
     }
-    case import_typescript12.default.SyntaxKind.CallExpression: {
+    case import_typescript13.default.SyntaxKind.CallExpression: {
       const mapMethod = getMapLikeMethod(node);
       if (mapMethod) {
         const mapResult = transformMapCall(node, ctx, isClientOnly, mapMethod);
@@ -195763,7 +195825,7 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
           return mapResult;
       }
       const callee = node.expression;
-      if (import_typescript12.default.isIdentifier(callee)) {
+      if (import_typescript13.default.isIdentifier(callee)) {
         const jsxFunc = ctx.analyzer.jsxFunctions.get(callee.text);
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx, isClientOnly);
@@ -195775,39 +195837,39 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
       }
       return null;
     }
-    case import_typescript12.default.SyntaxKind.Identifier:
-    case import_typescript12.default.SyntaxKind.StringLiteral:
-    case import_typescript12.default.SyntaxKind.NumericLiteral:
-    case import_typescript12.default.SyntaxKind.BigIntLiteral:
-    case import_typescript12.default.SyntaxKind.RegularExpressionLiteral:
-    case import_typescript12.default.SyntaxKind.NoSubstitutionTemplateLiteral:
-    case import_typescript12.default.SyntaxKind.TemplateExpression:
-    case import_typescript12.default.SyntaxKind.TaggedTemplateExpression:
-    case import_typescript12.default.SyntaxKind.TrueKeyword:
-    case import_typescript12.default.SyntaxKind.FalseKeyword:
-    case import_typescript12.default.SyntaxKind.NullKeyword:
-    case import_typescript12.default.SyntaxKind.ThisKeyword:
-    case import_typescript12.default.SyntaxKind.SuperKeyword:
-    case import_typescript12.default.SyntaxKind.ImportKeyword:
-    case import_typescript12.default.SyntaxKind.PropertyAccessExpression:
-    case import_typescript12.default.SyntaxKind.ElementAccessExpression:
-    case import_typescript12.default.SyntaxKind.PrefixUnaryExpression:
-    case import_typescript12.default.SyntaxKind.PostfixUnaryExpression:
-    case import_typescript12.default.SyntaxKind.TypeOfExpression:
-    case import_typescript12.default.SyntaxKind.VoidExpression:
-    case import_typescript12.default.SyntaxKind.DeleteExpression:
-    case import_typescript12.default.SyntaxKind.NewExpression:
-    case import_typescript12.default.SyntaxKind.ObjectLiteralExpression:
-    case import_typescript12.default.SyntaxKind.ArrowFunction:
-    case import_typescript12.default.SyntaxKind.FunctionExpression:
-    case import_typescript12.default.SyntaxKind.ClassExpression:
-    case import_typescript12.default.SyntaxKind.MetaProperty:
-    case import_typescript12.default.SyntaxKind.ExpressionWithTypeArguments:
-    case import_typescript12.default.SyntaxKind.CommaListExpression:
-    case import_typescript12.default.SyntaxKind.SyntheticExpression:
-    case import_typescript12.default.SyntaxKind.ArrayLiteralExpression:
+    case import_typescript13.default.SyntaxKind.Identifier:
+    case import_typescript13.default.SyntaxKind.StringLiteral:
+    case import_typescript13.default.SyntaxKind.NumericLiteral:
+    case import_typescript13.default.SyntaxKind.BigIntLiteral:
+    case import_typescript13.default.SyntaxKind.RegularExpressionLiteral:
+    case import_typescript13.default.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case import_typescript13.default.SyntaxKind.TemplateExpression:
+    case import_typescript13.default.SyntaxKind.TaggedTemplateExpression:
+    case import_typescript13.default.SyntaxKind.TrueKeyword:
+    case import_typescript13.default.SyntaxKind.FalseKeyword:
+    case import_typescript13.default.SyntaxKind.NullKeyword:
+    case import_typescript13.default.SyntaxKind.ThisKeyword:
+    case import_typescript13.default.SyntaxKind.SuperKeyword:
+    case import_typescript13.default.SyntaxKind.ImportKeyword:
+    case import_typescript13.default.SyntaxKind.PropertyAccessExpression:
+    case import_typescript13.default.SyntaxKind.ElementAccessExpression:
+    case import_typescript13.default.SyntaxKind.PrefixUnaryExpression:
+    case import_typescript13.default.SyntaxKind.PostfixUnaryExpression:
+    case import_typescript13.default.SyntaxKind.TypeOfExpression:
+    case import_typescript13.default.SyntaxKind.VoidExpression:
+    case import_typescript13.default.SyntaxKind.DeleteExpression:
+    case import_typescript13.default.SyntaxKind.NewExpression:
+    case import_typescript13.default.SyntaxKind.ObjectLiteralExpression:
+    case import_typescript13.default.SyntaxKind.ArrowFunction:
+    case import_typescript13.default.SyntaxKind.FunctionExpression:
+    case import_typescript13.default.SyntaxKind.ClassExpression:
+    case import_typescript13.default.SyntaxKind.MetaProperty:
+    case import_typescript13.default.SyntaxKind.ExpressionWithTypeArguments:
+    case import_typescript13.default.SyntaxKind.CommaListExpression:
+    case import_typescript13.default.SyntaxKind.SyntheticExpression:
+    case import_typescript13.default.SyntaxKind.ArrayLiteralExpression:
       return null;
-    case import_typescript12.default.SyntaxKind.AwaitExpression:
+    case import_typescript13.default.SyntaxKind.AwaitExpression:
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(node, ctx.sourceFile, ctx.filePath)));
       return {
         type: "expression",
@@ -195818,16 +195880,16 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
         loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
         origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
       };
-    case import_typescript12.default.SyntaxKind.YieldExpression:
+    case import_typescript13.default.SyntaxKind.YieldExpression:
       return null;
-    case import_typescript12.default.SyntaxKind.SpreadElement:
-    case import_typescript12.default.SyntaxKind.OmittedExpression:
-    case import_typescript12.default.SyntaxKind.JsxExpression:
-    case import_typescript12.default.SyntaxKind.JsxOpeningElement:
-    case import_typescript12.default.SyntaxKind.JsxOpeningFragment:
-    case import_typescript12.default.SyntaxKind.JsxClosingFragment:
-    case import_typescript12.default.SyntaxKind.JsxAttributes:
-    case import_typescript12.default.SyntaxKind.MissingDeclaration:
+    case import_typescript13.default.SyntaxKind.SpreadElement:
+    case import_typescript13.default.SyntaxKind.OmittedExpression:
+    case import_typescript13.default.SyntaxKind.JsxExpression:
+    case import_typescript13.default.SyntaxKind.JsxOpeningElement:
+    case import_typescript13.default.SyntaxKind.JsxOpeningFragment:
+    case import_typescript13.default.SyntaxKind.JsxClosingFragment:
+    case import_typescript13.default.SyntaxKind.JsxAttributes:
+    case import_typescript13.default.SyntaxKind.MissingDeclaration:
       return null;
     default:
       return assertNever2(node);
@@ -195864,7 +195926,7 @@ function transformConditionalBranch(node, ctx) {
   };
 }
 function getMapLikeMethod(node) {
-  if (!import_typescript12.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript13.default.isPropertyAccessExpression(node.expression))
     return null;
   const name = node.expression.name.text;
   if (name === "map")
@@ -195874,9 +195936,9 @@ function getMapLikeMethod(node) {
   return null;
 }
 function isFilterCall(node) {
-  if (!import_typescript12.default.isCallExpression(node))
+  if (!import_typescript13.default.isCallExpression(node))
     return null;
-  if (!import_typescript12.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript13.default.isPropertyAccessExpression(node.expression))
     return null;
   if (node.expression.name.text !== "filter")
     return null;
@@ -195888,9 +195950,9 @@ function isFilterCall(node) {
   };
 }
 function isSortCall(node) {
-  if (!import_typescript12.default.isCallExpression(node))
+  if (!import_typescript13.default.isCallExpression(node))
     return null;
-  if (!import_typescript12.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript13.default.isPropertyAccessExpression(node.expression))
     return null;
   const methodName = node.expression.name.text;
   if (methodName !== "sort" && methodName !== "toSorted")
@@ -195904,9 +195966,9 @@ function isSortCall(node) {
   };
 }
 function isIteratorShapeCall(node) {
-  if (!import_typescript12.default.isCallExpression(node))
+  if (!import_typescript13.default.isCallExpression(node))
     return null;
-  if (!import_typescript12.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript13.default.isPropertyAccessExpression(node.expression))
     return null;
   if (node.arguments.length !== 0)
     return null;
@@ -195916,11 +195978,11 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name };
 }
 function isObjectIteratorCall(node) {
-  if (!import_typescript12.default.isCallExpression(node))
+  if (!import_typescript13.default.isCallExpression(node))
     return null;
-  if (!import_typescript12.default.isPropertyAccessExpression(node.expression))
+  if (!import_typescript13.default.isPropertyAccessExpression(node.expression))
     return null;
-  if (!import_typescript12.default.isIdentifier(node.expression.expression))
+  if (!import_typescript13.default.isIdentifier(node.expression.expression))
     return null;
   if (node.expression.expression.text !== "Object")
     return null;
@@ -195945,7 +196007,7 @@ function extractSortComparator(callback, _method, ctx) {
 ` + `(reverse the operands for descending order).`
   });
   let resolvedNode = callback;
-  if (import_typescript12.default.isIdentifier(callback)) {
+  if (import_typescript13.default.isIdentifier(callback)) {
     const resolved = resolveSortComparatorIdentifier(callback.text, ctx);
     if (!resolved) {
       return {
@@ -195955,7 +196017,7 @@ function extractSortComparator(callback, _method, ctx) {
     }
     resolvedNode = resolved;
   }
-  if (!import_typescript12.default.isArrowFunction(resolvedNode) && !import_typescript12.default.isFunctionExpression(resolvedNode)) {
+  if (!import_typescript13.default.isArrowFunction(resolvedNode) && !import_typescript13.default.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
@@ -195982,11 +196044,11 @@ function resolveSortComparatorIdentifier(name, ctx) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -195997,11 +196059,11 @@ function resolveCallbackMethodFunctionReferenceIdentifier(name, analyzer) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -196057,13 +196119,13 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
   return visit2(expr, bound);
 }
 function extractFilterPredicate(callback, ctx) {
-  if (!import_typescript12.default.isArrowFunction(callback))
+  if (!import_typescript13.default.isArrowFunction(callback))
     return { result: null };
   if (callback.parameters.length < 1)
     return { result: null };
   const firstParam = callback.parameters[0];
-  if (!import_typescript12.default.isIdentifier(firstParam.name)) {
-    if (import_typescript12.default.isBlock(callback.body)) {
+  if (!import_typescript13.default.isIdentifier(firstParam.name)) {
+    if (import_typescript13.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 */."
@@ -196083,7 +196145,7 @@ function extractFilterPredicate(callback, ctx) {
     return { result: null };
   }
   const param = firstParam.name.getText(ctx.sourceFile);
-  if (import_typescript12.default.isBlock(callback.body)) {
+  if (import_typescript13.default.isBlock(callback.body)) {
     const raw2 = ctx.getJS(callback.body);
     const statements = parseBlockBody(callback.body, ctx.sourceFile, (n) => ctx.getJS(n));
     if (!statements) {
@@ -196109,7 +196171,7 @@ function extractFilterPredicate(callback, ctx) {
   return { result: { param, predicate, raw } };
 }
 function extractLoopParamBindings(pattern) {
-  if (import_typescript12.default.isIdentifier(pattern))
+  if (import_typescript13.default.isIdentifier(pattern))
     return null;
   const bindings = [];
   let unsupported = false;
@@ -196118,7 +196180,7 @@ function extractLoopParamBindings(pattern) {
       return false;
     for (let i2 = 0;i2 < key.length; ) {
       const cp = key.codePointAt(i2);
-      const ok = i2 === 0 ? import_typescript12.default.isIdentifierStart(cp, import_typescript12.default.ScriptTarget.Latest) : import_typescript12.default.isIdentifierPart(cp, import_typescript12.default.ScriptTarget.Latest);
+      const ok = i2 === 0 ? import_typescript13.default.isIdentifierStart(cp, import_typescript13.default.ScriptTarget.Latest) : import_typescript13.default.isIdentifierPart(cp, import_typescript13.default.ScriptTarget.Latest);
       if (!ok)
         return false;
       i2 += cp > 65535 ? 2 : 1;
@@ -196131,17 +196193,17 @@ function extractLoopParamBindings(pattern) {
   const walk = (p, prefix, segments) => {
     if (unsupported)
       return;
-    if (import_typescript12.default.isArrayBindingPattern(p)) {
+    if (import_typescript13.default.isArrayBindingPattern(p)) {
       const elements2 = p.elements;
       for (let index = 0;index < elements2.length; index++) {
         if (unsupported)
           return;
         const el = elements2[index];
-        if (import_typescript12.default.isOmittedExpression(el))
+        if (import_typescript13.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_typescript12.default.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
+          internalInvariant(import_typescript13.default.isIdentifier(el.name), "extractLoopParamBindings: array rest target is not an identifier (parser should reject)");
           bindings.push({
             name: el.name.text,
             path: prefix,
@@ -196152,7 +196214,7 @@ function extractLoopParamBindings(pattern) {
         }
         const path = `${prefix}[${index}]`;
         const nextSegments = [...segments, { kind: "index", index }];
-        if (import_typescript12.default.isIdentifier(el.name)) {
+        if (import_typescript13.default.isIdentifier(el.name)) {
           bindings.push({ name: el.name.text, path, segments: nextSegments });
         } else {
           walk(el.name, path, nextSegments);
@@ -196168,7 +196230,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_typescript12.default.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
+        internalInvariant(import_typescript13.default.isIdentifier(el.name), "extractLoopParamBindings: object rest target is not an identifier (parser should reject)");
         bindings.push({
           name: el.name.text,
           path: prefix,
@@ -196180,17 +196242,17 @@ function extractLoopParamBindings(pattern) {
       let keyText = null;
       if (el.propertyName) {
         const pn = el.propertyName;
-        if (import_typescript12.default.isIdentifier(pn))
+        if (import_typescript13.default.isIdentifier(pn))
           keyText = pn.text;
-        else if (import_typescript12.default.isStringLiteral(pn))
+        else if (import_typescript13.default.isStringLiteral(pn))
           keyText = pn.text;
-        else if (import_typescript12.default.isNumericLiteral(pn))
+        else if (import_typescript13.default.isNumericLiteral(pn))
           keyText = pn.text;
         else {
           unsupported = true;
           return;
         }
-      } else if (import_typescript12.default.isIdentifier(el.name)) {
+      } else if (import_typescript13.default.isIdentifier(el.name)) {
         keyText = el.name.text;
       } else {
         unsupported = true;
@@ -196200,14 +196262,14 @@ function extractLoopParamBindings(pattern) {
       collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path = appendDotAccess(prefix, keyText);
       const nextSegments = [...segments, { kind: "field", key: keyText, isIdent: keyIsIdent }];
-      if (import_typescript12.default.isIdentifier(el.name)) {
+      if (import_typescript13.default.isIdentifier(el.name)) {
         bindings.push({ name: el.name.text, path, segments: nextSegments });
       } else {
         walk(el.name, path, nextSegments);
       }
     }
   };
-  if (import_typescript12.default.isArrayBindingPattern(pattern) || import_typescript12.default.isObjectBindingPattern(pattern)) {
+  if (import_typescript13.default.isArrayBindingPattern(pattern) || import_typescript13.default.isObjectBindingPattern(pattern)) {
     walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
@@ -196217,7 +196279,7 @@ function extractLoopParamBindings(pattern) {
 }
 function findKeyJsxAttribute(opening) {
   for (const prop of opening.attributes.properties) {
-    if (import_typescript12.default.isJsxAttribute(prop) && prop.name.getText() === "key") {
+    if (import_typescript13.default.isJsxAttribute(prop) && prop.name.getText() === "key") {
       return prop;
     }
   }
@@ -196262,7 +196324,7 @@ function keyAttrValueToExpr(v) {
 function normalizeKeyExpr(expr) {
   let out = "";
   for (const tok of iterateJsTokens(expr)) {
-    if (tok.kind === import_typescript12.default.SyntaxKind.WhitespaceTrivia || tok.kind === import_typescript12.default.SyntaxKind.NewLineTrivia) {
+    if (tok.kind === import_typescript13.default.SyntaxKind.WhitespaceTrivia || tok.kind === import_typescript13.default.SyntaxKind.NewLineTrivia) {
       continue;
     }
     out += expr.slice(tok.pos, tok.end);
@@ -196274,13 +196336,13 @@ function conditionalHasExplicitNullishBranch(cond) {
 }
 function branchHasExplicitNullish(branch) {
   let b = branch;
-  while (import_typescript12.default.isParenthesizedExpression(b))
+  while (import_typescript13.default.isParenthesizedExpression(b))
     b = b.expression;
-  if (b.kind === import_typescript12.default.SyntaxKind.NullKeyword)
+  if (b.kind === import_typescript13.default.SyntaxKind.NullKeyword)
     return true;
-  if (import_typescript12.default.isIdentifier(b) && b.text === "undefined")
+  if (import_typescript13.default.isIdentifier(b) && b.text === "undefined")
     return true;
-  if (import_typescript12.default.isConditionalExpression(b))
+  if (import_typescript13.default.isConditionalExpression(b))
     return conditionalHasExplicitNullishBranch(b);
   return false;
 }
@@ -196289,26 +196351,26 @@ function classifyKeyProblem(keyAttr, checker) {
     return "missing";
   if (!keyAttr.initializer)
     return "missing";
-  if (import_typescript12.default.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
+  if (import_typescript13.default.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
     return "missing";
   }
   let expr;
-  if (import_typescript12.default.isStringLiteral(keyAttr.initializer)) {
+  if (import_typescript13.default.isStringLiteral(keyAttr.initializer)) {
     return null;
-  } else if (import_typescript12.default.isJsxExpression(keyAttr.initializer)) {
+  } else if (import_typescript13.default.isJsxExpression(keyAttr.initializer)) {
     expr = keyAttr.initializer.expression;
   }
   if (!expr)
     return null;
-  if (expr.kind === import_typescript12.default.SyntaxKind.NullKeyword)
+  if (expr.kind === import_typescript13.default.SyntaxKind.NullKeyword)
     return null;
-  if (import_typescript12.default.isIdentifier(expr) && expr.text === "undefined")
+  if (import_typescript13.default.isIdentifier(expr) && expr.text === "undefined")
     return null;
-  if (import_typescript12.default.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr))
+  if (import_typescript13.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_typescript12.default.TypeFlags.Null | import_typescript12.default.TypeFlags.Undefined | import_typescript12.default.TypeFlags.Void)) !== 0) : (type2.flags & (import_typescript12.default.TypeFlags.Null | import_typescript12.default.TypeFlags.Undefined | import_typescript12.default.TypeFlags.Void)) !== 0;
+    const isNullable = type2.isUnion() ? type2.types.some((t) => (t.flags & (import_typescript13.default.TypeFlags.Null | import_typescript13.default.TypeFlags.Undefined | import_typescript13.default.TypeFlags.Void)) !== 0) : (type2.flags & (import_typescript13.default.TypeFlags.Null | import_typescript13.default.TypeFlags.Undefined | import_typescript13.default.TypeFlags.Void)) !== 0;
     if (isNullable)
       return "nullable-type";
   }
@@ -196334,81 +196396,81 @@ 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_typescript12.default.isBlock(body)) {
-    const ret = body.statements.find((s) => import_typescript12.default.isReturnStatement(s) && s.expression != null);
+  if (import_typescript13.default.isBlock(body)) {
+    const ret = body.statements.find((s) => import_typescript13.default.isReturnStatement(s) && s.expression != null);
     if (!ret?.expression)
       return;
     body = ret.expression;
   }
-  while (import_typescript12.default.isParenthesizedExpression(body))
+  while (import_typescript13.default.isParenthesizedExpression(body))
     body = body.expression;
   function checkJsxOperand(node) {
     let n = node;
-    while (import_typescript12.default.isParenthesizedExpression(n))
+    while (import_typescript13.default.isParenthesizedExpression(n))
       n = n.expression;
-    if (import_typescript12.default.isJsxElement(n))
+    if (import_typescript13.default.isJsxElement(n))
       checkOpening(n.openingElement);
-    else if (import_typescript12.default.isJsxSelfClosingElement(n))
+    else if (import_typescript13.default.isJsxSelfClosingElement(n))
       checkOpening(n);
   }
-  if (import_typescript12.default.isConditionalExpression(body)) {
+  if (import_typescript13.default.isConditionalExpression(body)) {
     checkJsxOperand(body.whenTrue);
     checkJsxOperand(body.whenFalse);
     return;
   }
-  if (import_typescript12.default.isBinaryExpression(body) && (body.operatorToken.kind === import_typescript12.default.SyntaxKind.AmpersandAmpersandToken || body.operatorToken.kind === import_typescript12.default.SyntaxKind.BarBarToken || body.operatorToken.kind === import_typescript12.default.SyntaxKind.QuestionQuestionToken)) {
+  if (import_typescript13.default.isBinaryExpression(body) && (body.operatorToken.kind === import_typescript13.default.SyntaxKind.AmpersandAmpersandToken || body.operatorToken.kind === import_typescript13.default.SyntaxKind.BarBarToken || body.operatorToken.kind === import_typescript13.default.SyntaxKind.QuestionQuestionToken)) {
     checkJsxOperand(body.left);
     checkJsxOperand(body.right);
     return;
   }
-  if (import_typescript12.default.isJsxElement(body)) {
+  if (import_typescript13.default.isJsxElement(body)) {
     checkOpening(body.openingElement);
     return;
   }
-  if (import_typescript12.default.isJsxSelfClosingElement(body)) {
+  if (import_typescript13.default.isJsxSelfClosingElement(body)) {
     checkOpening(body);
     return;
   }
 }
 function flatMapProjectionCall(body) {
   let expr;
-  if (import_typescript12.default.isBlock(body)) {
+  if (import_typescript13.default.isBlock(body)) {
     const real = body.statements;
-    if (real.length !== 1 || !import_typescript12.default.isReturnStatement(real[0]) || !real[0].expression)
+    if (real.length !== 1 || !import_typescript13.default.isReturnStatement(real[0]) || !real[0].expression)
       return null;
     expr = real[0].expression;
   } else {
     expr = body;
   }
-  while (import_typescript12.default.isParenthesizedExpression(expr))
+  while (import_typescript13.default.isParenthesizedExpression(expr))
     expr = expr.expression;
-  if (!import_typescript12.default.isCallExpression(expr))
+  if (!import_typescript13.default.isCallExpression(expr))
     return null;
   if (!getMapLikeMethod(expr))
     return null;
   const cb = expr.arguments[0];
-  if (!cb || !import_typescript12.default.isArrowFunction(cb) && !import_typescript12.default.isFunctionExpression(cb))
+  if (!cb || !import_typescript13.default.isArrowFunction(cb) && !import_typescript13.default.isFunctionExpression(cb))
     return null;
   for (const p of cb.parameters) {
-    if (!import_typescript12.default.isIdentifier(p.name))
+    if (!import_typescript13.default.isIdentifier(p.name))
       return null;
   }
   let innerBody = cb.body;
-  if (import_typescript12.default.isBlock(innerBody)) {
-    const ret = innerBody.statements.find((s) => import_typescript12.default.isReturnStatement(s) && s.expression != null);
+  if (import_typescript13.default.isBlock(innerBody)) {
+    const ret = innerBody.statements.find((s) => import_typescript13.default.isReturnStatement(s) && s.expression != null);
     if (innerBody.statements.length !== 1 || !ret?.expression)
       return null;
     innerBody = ret.expression;
   }
-  while (import_typescript12.default.isParenthesizedExpression(innerBody))
+  while (import_typescript13.default.isParenthesizedExpression(innerBody))
     innerBody = innerBody.expression;
   const isElementish = (n) => {
     let m = n;
-    while (import_typescript12.default.isParenthesizedExpression(m))
+    while (import_typescript13.default.isParenthesizedExpression(m))
       m = m.expression;
-    if (import_typescript12.default.isJsxElement(m) || import_typescript12.default.isJsxSelfClosingElement(m))
+    if (import_typescript13.default.isJsxElement(m) || import_typescript13.default.isJsxSelfClosingElement(m))
       return leafIsWirelessElement(m);
-    if (import_typescript12.default.isConditionalExpression(m))
+    if (import_typescript13.default.isConditionalExpression(m))
       return isElementish(m.whenTrue) && isElementish(m.whenFalse);
     return false;
   };
@@ -196421,19 +196483,19 @@ function leafIsWirelessElement(el) {
   const visit2 = (n) => {
     if (!ok)
       return;
-    if (import_typescript12.default.isJsxOpeningElement(n) || import_typescript12.default.isJsxSelfClosingElement(n)) {
+    if (import_typescript13.default.isJsxOpeningElement(n) || import_typescript13.default.isJsxSelfClosingElement(n)) {
       const tagNode = n.tagName;
-      const isIntrinsic = import_typescript12.default.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : import_typescript12.default.isJsxNamespacedName(tagNode);
+      const isIntrinsic = import_typescript13.default.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : import_typescript13.default.isJsxNamespacedName(tagNode);
       if (!isIntrinsic) {
         ok = false;
         return;
       }
       for (const attr of n.attributes.properties) {
-        if (import_typescript12.default.isJsxSpreadAttribute(attr)) {
+        if (import_typescript13.default.isJsxSpreadAttribute(attr)) {
           ok = false;
           return;
         }
-        if (import_typescript12.default.isJsxAttribute(attr)) {
+        if (import_typescript13.default.isJsxAttribute(attr)) {
           const name = attr.name.getText();
           if (/^on[A-Z]/.test(name)) {
             ok = false;
@@ -196442,11 +196504,11 @@ function leafIsWirelessElement(el) {
         }
       }
     }
-    if (import_typescript12.default.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
+    if (import_typescript13.default.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
       ok = false;
       return;
     }
-    import_typescript12.default.forEachChild(n, visit2);
+    import_typescript13.default.forEachChild(n, visit2);
   };
   visit2(el);
   return ok;
@@ -196626,7 +196688,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let children = [];
   let paramBindings;
   let flatMapCallback;
-  if (import_typescript12.default.isArrowFunction(callback)) {
+  if (import_typescript13.default.isArrowFunction(callback)) {
     if (callback.parameters.length > 0) {
       const firstParam = callback.parameters[0];
       param = firstParam.name.getText(ctx.sourceFile);
@@ -196634,9 +196696,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         paramType = firstParam.type.getText(ctx.sourceFile);
       }
       const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
-      if (isEntriesShape && import_typescript12.default.isArrayBindingPattern(firstParam.name)) {
-        const elements = firstParam.name.elements.filter((el) => !import_typescript12.default.isOmittedExpression(el));
-        if (elements.length === 2 && import_typescript12.default.isBindingElement(elements[0]) && import_typescript12.default.isIdentifier(elements[0].name) && import_typescript12.default.isBindingElement(elements[1]) && import_typescript12.default.isIdentifier(elements[1].name)) {
+      if (isEntriesShape && import_typescript13.default.isArrayBindingPattern(firstParam.name)) {
+        const elements = firstParam.name.elements.filter((el) => !import_typescript13.default.isOmittedExpression(el));
+        if (elements.length === 2 && import_typescript13.default.isBindingElement(elements[0]) && import_typescript13.default.isIdentifier(elements[0].name) && import_typescript13.default.isBindingElement(elements[1]) && import_typescript13.default.isIdentifier(elements[1].name)) {
           index = elements[0].name.text;
           param = elements[1].name.text;
         } else {
@@ -196667,10 +196729,10 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     ctx.scope = ctx.scope.enterLoopRow({ param, index, paramBindings });
     ctx.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
-      if (!import_typescript12.default.isBinaryExpression(expr))
+      if (!import_typescript13.default.isBinaryExpression(expr))
         return;
       const op = expr.operatorToken.kind;
-      if (op !== import_typescript12.default.SyntaxKind.AmpersandAmpersandToken && op !== import_typescript12.default.SyntaxKind.BarBarToken && op !== import_typescript12.default.SyntaxKind.QuestionQuestionToken) {
+      if (op !== import_typescript13.default.SyntaxKind.AmpersandAmpersandToken && op !== import_typescript13.default.SyntaxKind.BarBarToken && op !== import_typescript13.default.SyntaxKind.QuestionQuestionToken) {
         return;
       }
       if (!containsJsxInExpression(expr) && !callsJsxHelper(expr, ctx))
@@ -196680,33 +196742,33 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         children = [transformed];
     };
     const body = callback.body;
-    if (import_typescript12.default.isJsxElement(body) || import_typescript12.default.isJsxSelfClosingElement(body) || import_typescript12.default.isJsxFragment(body)) {
+    if (import_typescript13.default.isJsxElement(body) || import_typescript13.default.isJsxSelfClosingElement(body) || import_typescript13.default.isJsxFragment(body)) {
       const transformed = transformNode(body, ctx);
       if (transformed) {
         children = [transformed];
       }
-    } else if (import_typescript12.default.isConditionalExpression(body)) {
+    } else if (import_typescript13.default.isConditionalExpression(body)) {
       children = [transformConditional(body, ctx)];
-    } else if (import_typescript12.default.isParenthesizedExpression(body)) {
+    } else if (import_typescript13.default.isParenthesizedExpression(body)) {
       let inner = body.expression;
-      while (import_typescript12.default.isParenthesizedExpression(inner)) {
+      while (import_typescript13.default.isParenthesizedExpression(inner)) {
         inner = inner.expression;
       }
-      if (import_typescript12.default.isJsxElement(inner) || import_typescript12.default.isJsxSelfClosingElement(inner) || import_typescript12.default.isJsxFragment(inner)) {
+      if (import_typescript13.default.isJsxElement(inner) || import_typescript13.default.isJsxSelfClosingElement(inner) || import_typescript13.default.isJsxFragment(inner)) {
         const transformed = transformNode(inner, ctx);
         if (transformed) {
           children = [transformed];
         }
-      } else if (import_typescript12.default.isConditionalExpression(inner)) {
+      } else if (import_typescript13.default.isConditionalExpression(inner)) {
         children = [transformConditional(inner, ctx)];
-      } else if (method === "flatMap" && import_typescript12.default.isArrayLiteralExpression(inner)) {
+      } else if (method === "flatMap" && import_typescript13.default.isArrayLiteralExpression(inner)) {
         children = transformArrayLiteralChildren(inner, ctx);
       } else {
         tryTransformRenderableBody(inner);
       }
-    } else if (method === "flatMap" && import_typescript12.default.isArrayLiteralExpression(body)) {
+    } else if (method === "flatMap" && import_typescript13.default.isArrayLiteralExpression(body)) {
       children = transformArrayLiteralChildren(body, ctx);
-    } else if (import_typescript12.default.isBlock(body)) {
+    } else if (import_typescript13.default.isBlock(body)) {
       const multiReturn = method !== "flatMap" ? extractMultiReturnJsxBranches(body, true) : null;
       if (multiReturn && multiReturn.branches.length > 0) {
         const loc = getSourceLocation(body, ctx.sourceFile, ctx.filePath);
@@ -196724,7 +196786,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           }
         }
       }
-      const returnStmt = children.length === 0 ? body.statements.find((s) => import_typescript12.default.isReturnStatement(s) && s.expression != null) : undefined;
+      const returnStmt = children.length === 0 ? body.statements.find((s) => import_typescript13.default.isReturnStatement(s) && s.expression != null) : undefined;
       let rowScopeBeforePreamble = null;
       if (returnStmt) {
         const preambleNames = new Set;
@@ -196745,10 +196807,10 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       }
       if (returnStmt && returnStmt.expression) {
         let returnExpr = returnStmt.expression;
-        while (import_typescript12.default.isParenthesizedExpression(returnExpr)) {
+        while (import_typescript13.default.isParenthesizedExpression(returnExpr)) {
           returnExpr = returnExpr.expression;
         }
-        if (import_typescript12.default.isJsxElement(returnExpr) || import_typescript12.default.isJsxSelfClosingElement(returnExpr) || import_typescript12.default.isJsxFragment(returnExpr)) {
+        if (import_typescript13.default.isJsxElement(returnExpr) || import_typescript13.default.isJsxSelfClosingElement(returnExpr) || import_typescript13.default.isJsxFragment(returnExpr)) {
           const transformed = transformNode(returnExpr, ctx);
           if (transformed) {
             children = [transformed];
@@ -196830,7 +196892,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         }
       }
     }
-    if (method === "flatMap" && children.length === 0 && !flatMapCallback && !import_typescript12.default.isBlock(body)) {
+    if (method === "flatMap" && children.length === 0 && !flatMapCallback && !import_typescript13.default.isBlock(body)) {
       flatMapCallback = buildFlatMapCallback(callback, body, ctx);
     }
     if (flatMapCallback)
@@ -196848,7 +196910,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   }
   if (children.length === 0 && !flatMapCallback) {
     const cb = node.arguments[0];
-    const cbBody = cb && (import_typescript12.default.isArrowFunction(cb) || import_typescript12.default.isFunctionExpression(cb)) ? cb.body : undefined;
+    const cbBody = cb && (import_typescript13.default.isArrowFunction(cb) || import_typescript13.default.isFunctionExpression(cb)) ? cb.body : undefined;
     if (cbBody && containsJsxInExpression(cbBody) && ctx.analyzer.errors.length === diagCountAtEntry) {
       ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(cbBody, ctx.sourceFile, ctx.filePath), {
         message: `A .${method}() callback that builds JSX in this shape cannot be ` + "compiled — the JSX would leak verbatim into the client bundle. " + "Recognized bodies: a JSX element/fragment, a ternary or " + "&& / || / ?? expression, an array literal (flatMap), or a block " + "body whose return the compiler can lower.",
@@ -196859,7 +196921,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     return null;
   }
-  if (import_typescript12.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
+  if (import_typescript13.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
     checkLoopKey(node.arguments[0], ctx, isNested);
   }
   const itemConditional = children.length > 0 ? loopBodyItemConditional(children) : null;
@@ -196913,6 +196975,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children, new Set(preamble.declaredNames), ctx) : undefined;
   if (preamble && !isStaticArray) {
     markPreambleAttrSlots(children, new Set(preamble.declaredNames), ctx);
+    if (preamble.reactiveNames && preamble.reactiveNames.length > 0) {
+      markPreambleConditionalReactivity(children, new Set(preamble.reactiveNames), ctx);
+    }
   }
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
@@ -196956,12 +197021,12 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
 function transformArrayLiteralChildren(arrayLiteral, ctx) {
   const children = [];
   for (const element of arrayLiteral.elements) {
-    if (import_typescript12.default.isSpreadElement(element))
+    if (import_typescript13.default.isSpreadElement(element))
       continue;
     let inner = element;
-    while (import_typescript12.default.isParenthesizedExpression(inner))
+    while (import_typescript13.default.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (import_typescript12.default.isJsxElement(inner) || import_typescript12.default.isJsxSelfClosingElement(inner) || import_typescript12.default.isJsxFragment(inner)) {
+    if (import_typescript13.default.isJsxElement(inner) || import_typescript13.default.isJsxSelfClosingElement(inner) || import_typescript13.default.isJsxFragment(inner)) {
       const transformed = transformNode(inner, ctx);
       if (transformed)
         children.push(transformed);
@@ -196970,7 +197035,7 @@ function transformArrayLiteralChildren(arrayLiteral, ctx) {
   return children;
 }
 function containsJsx(node) {
-  if (import_typescript12.default.isJsxElement(node) || import_typescript12.default.isJsxSelfClosingElement(node) || import_typescript12.default.isJsxFragment(node))
+  if (import_typescript13.default.isJsxElement(node) || import_typescript13.default.isJsxSelfClosingElement(node) || import_typescript13.default.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -196986,7 +197051,7 @@ function buildFlatMapCallback(callback, body, ctx) {
   const leafIrs = [];
   let refusalNode;
   const collectJsx = (n, underTemplate) => {
-    if (import_typescript12.default.isJsxElement(n) || import_typescript12.default.isJsxSelfClosingElement(n) || import_typescript12.default.isJsxFragment(n)) {
+    if (import_typescript13.default.isJsxElement(n) || import_typescript13.default.isJsxSelfClosingElement(n) || import_typescript13.default.isJsxFragment(n)) {
       if (underTemplate)
         refusalNode ??= n;
       leafSpans.push({ start: n.getStart(ctx.sourceFile), end: n.getEnd() });
@@ -196994,7 +197059,7 @@ function buildFlatMapCallback(callback, body, ctx) {
       leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx.sourceFile, ctx.filePath) });
       return;
     }
-    const inTemplate = underTemplate || import_typescript12.default.isTemplateExpression(n) || import_typescript12.default.isTaggedTemplateExpression(n);
+    const inTemplate = underTemplate || import_typescript13.default.isTemplateExpression(n) || import_typescript13.default.isTaggedTemplateExpression(n);
     n.forEachChild((c) => collectJsx(c, inTemplate));
   };
   collectJsx(body, false);
@@ -197170,6 +197235,33 @@ function markPreambleAttrSlots(nodes, declared, ctx) {
   };
   visit2(nodes);
 }
+function markPreambleConditionalReactivity(nodes, reactiveNames, ctx) {
+  if (reactiveNames.size === 0)
+    return;
+  const visit2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+        case "fragment":
+          visit2(node.children);
+          break;
+        case "conditional": {
+          if (!node.reactive) {
+            const refs = extractFreeIdentifiersFromText(node.condition);
+            if ([...refs].some((r) => reactiveNames.has(r))) {
+              node.reactive = true;
+              if (!node.slotId)
+                node.slotId = generateSlotId(ctx);
+            }
+          }
+          visit2([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+        }
+      }
+    }
+  };
+  visit2(nodes);
+}
 function attrValueText(value) {
   if (value.kind === "expression")
     return value.expr;
@@ -197185,24 +197277,46 @@ function attrValueText(value) {
   return out.join(" ");
 }
 function collectBindingNames2(name, out) {
-  if (import_typescript12.default.isIdentifier(name)) {
+  if (import_typescript13.default.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const el of name.elements) {
-    if (import_typescript12.default.isBindingElement(el))
+    if (import_typescript13.default.isBindingElement(el))
       collectBindingNames2(el.name, out);
   }
 }
 function collectPreambleDeclaredNames(stmt, out) {
-  if (import_typescript12.default.isVariableStatement(stmt)) {
+  if (import_typescript13.default.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
       collectBindingNames2(decl.name, out);
     }
-  } else if (import_typescript12.default.isFunctionDeclaration(stmt) && stmt.name) {
+  } else if (import_typescript13.default.isFunctionDeclaration(stmt) && stmt.name) {
     out.add(stmt.name.text);
   }
 }
+function computePreambleReactiveNames(statements, ctx) {
+  const reactiveNames = new Set;
+  for (const stmt of statements) {
+    if (!import_typescript13.default.isVariableStatement(stmt))
+      continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!decl.initializer)
+        continue;
+      const boundNames = new Set;
+      collectBindingNames2(decl.name, boundNames);
+      const initText = ctx.getJS(decl.initializer);
+      const initFreeRefs = extractFreeIdentifiersFromNode(decl.initializer);
+      const readsEarlierReactive = [...initFreeRefs].some((r) => reactiveNames.has(r));
+      const isReactive = readsEarlierReactive || isReactiveExpression(initText, ctx, decl.initializer);
+      if (isReactive) {
+        for (const n of boundNames)
+          reactiveNames.add(n);
+      }
+    }
+  }
+  return reactiveNames;
+}
 function preambleFromValueStatements(statements, ctx) {
   const segments = [];
   const typedParts = [];
@@ -197217,21 +197331,23 @@ function preambleFromValueStatements(statements, ctx) {
     typedParts.push(raw0.endsWith(";") ? raw0 : raw0 + ";");
     segments.push(tjs !== js ? { kind: "js", text: js, templateText: tjs } : { kind: "js", text: js });
   }
+  const reactiveNames = computePreambleReactiveNames(statements, ctx);
   return {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     builderNames: [],
-    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined
+    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined,
+    reactiveNames: reactiveNames.size > 0 ? [...reactiveNames] : undefined
   };
 }
 function neutralPreambleDeclarations(statements, ctx) {
   const out = [];
   for (const stmt of statements) {
-    if (!import_typescript12.default.isVariableStatement(stmt))
+    if (!import_typescript13.default.isVariableStatement(stmt))
       return null;
     for (const decl of stmt.declarationList.declarations) {
-      if (!import_typescript12.default.isIdentifier(decl.name))
+      if (!import_typescript13.default.isIdentifier(decl.name))
         return null;
       if (!decl.initializer)
         return null;
@@ -197264,11 +197380,11 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
   let refusalNode;
   const recordBuilderTarget = (leaf, stmt) => {
     for (let n = leaf.parent;n && n !== stmt.parent; n = n.parent) {
-      if (import_typescript12.default.isCallExpression(n) && import_typescript12.default.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && import_typescript12.default.isIdentifier(n.expression.expression)) {
+      if (import_typescript13.default.isCallExpression(n) && import_typescript13.default.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && import_typescript13.default.isIdentifier(n.expression.expression)) {
         builders.add(n.expression.expression.text);
         return;
       }
-      if (import_typescript12.default.isVariableDeclaration(n) && import_typescript12.default.isIdentifier(n.name)) {
+      if (import_typescript13.default.isVariableDeclaration(n) && import_typescript13.default.isIdentifier(n.name)) {
         builders.add(n.name.text);
         return;
       }
@@ -197281,7 +197397,7 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
     const leafSpans = [];
     const leafIrs = [];
     const collect = (n, underTemplate) => {
-      if (import_typescript12.default.isJsxElement(n) || import_typescript12.default.isJsxSelfClosingElement(n) || import_typescript12.default.isJsxFragment(n)) {
+      if (import_typescript13.default.isJsxElement(n) || import_typescript13.default.isJsxSelfClosingElement(n) || import_typescript13.default.isJsxFragment(n)) {
         if (underTemplate)
           refusalNode ??= n;
         recordBuilderTarget(n, stmt);
@@ -197292,7 +197408,7 @@ function buildPreambleSegments(statements, returnStmt, ctx) {
         leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx.sourceFile, ctx.filePath) });
         return;
       }
-      const inTemplate = underTemplate || import_typescript12.default.isTemplateExpression(n) || import_typescript12.default.isTaggedTemplateExpression(n);
+      const inTemplate = underTemplate || import_typescript13.default.isTemplateExpression(n) || import_typescript13.default.isTaggedTemplateExpression(n);
       n.forEachChild((c) => collect(c, inTemplate));
     };
     collect(stmt, false);
@@ -197396,13 +197512,13 @@ function expandSpreadAttribute(attr, ctx) {
   }];
 }
 function attrFreeIdentifiers(attr) {
-  if (!attr.initializer || !import_typescript12.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !import_typescript13.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return;
   }
   return extractFreeIdentifiersFromNode(attr.initializer.expression);
 }
 function computeReactivityFlags(attr, ctx) {
-  if (!attr.initializer || !import_typescript12.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !import_typescript13.default.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return {};
   }
   const expr = attr.initializer.expression;
@@ -197428,22 +197544,22 @@ function processAttributes(attributes, ctx) {
   const events = [];
   let ref = null;
   for (const attr of attributes.properties) {
-    if (import_typescript12.default.isJsxSpreadAttribute(attr)) {
+    if (import_typescript13.default.isJsxSpreadAttribute(attr)) {
       attrs.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!import_typescript12.default.isJsxAttribute(attr))
+    if (!import_typescript13.default.isJsxAttribute(attr))
       continue;
     const rawName = attr.name.getText(ctx.sourceFile);
     if (rawName === "ref") {
-      if (attr.initializer && import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && import_typescript13.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         ref = ctx.getJS(attr.initializer.expression);
       }
       continue;
     }
     if (/^on[A-Z]/.test(rawName)) {
-      if (attr.initializer && import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && import_typescript13.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         const eventName = rawName.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         events.push({
@@ -197458,7 +197574,7 @@ function processAttributes(attributes, ctx) {
     const name = toHTMLAttrName(rawName);
     let value = getAttributeValue(attr, ctx);
     let clientOnly;
-    if (attr.initializer && import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript13.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) {
@@ -197485,55 +197601,55 @@ function getAttributeValue(attr, ctx) {
   if (!attr.initializer) {
     return AttrValueOf.booleanAttr();
   }
-  if (import_typescript12.default.isStringLiteral(attr.initializer)) {
+  if (import_typescript13.default.isStringLiteral(attr.initializer)) {
     return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
-  if (import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+  if (import_typescript13.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
-    if (import_typescript12.default.isIdentifier(expr)) {
+    if (import_typescript13.default.isIdentifier(expr)) {
       const branchInit = ctx._branchScopeVars?.get(expr.text);
       if (branchInit && !initializerShapeContainsJsx(branchInit)) {
         expr = branchInit;
       }
     }
     expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
-    if (import_typescript12.default.isAwaitExpression(expr)) {
+    if (import_typescript13.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_typescript12.default.isObjectLiteralExpression(expr)) {
+    if (attr.name.getText(ctx.sourceFile) === "style" && import_typescript13.default.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
       if (cssString !== null) {
         return AttrValueOf.literal(cssString);
       }
     }
-    if (import_typescript12.default.isTemplateExpression(expr)) {
+    if (import_typescript13.default.isTemplateExpression(expr)) {
       const parts = parseTemplateLiteral(expr, ctx);
       if (parts.some((p) => p.type === "ternary" || p.type === "lookup")) {
         return AttrValueOf.template(parts);
       }
     }
-    if (import_typescript12.default.isElementAccessExpression(expr) && !import_typescript12.default.isStringLiteralLike(expr.argumentExpression) && !import_typescript12.default.isNumericLiteral(expr.argumentExpression)) {
+    if (import_typescript13.default.isElementAccessExpression(expr) && !import_typescript13.default.isStringLiteralLike(expr.argumentExpression) && !import_typescript13.default.isNumericLiteral(expr.argumentExpression)) {
       const parts = tryResolveTemplateSpanFromConst(expr, ctx);
       if (parts) {
         return AttrValueOf.template(parts);
       }
     }
-    if (import_typescript12.default.isIdentifier(expr)) {
+    if (import_typescript13.default.isIdentifier(expr)) {
       const resolved = tryResolveIdentifierAsTemplateLiteral(expr, ctx);
       if (resolved) {
         return AttrValueOf.template(resolved);
       }
     }
-    if (import_typescript12.default.isConditionalExpression(expr)) {
+    if (import_typescript13.default.isConditionalExpression(expr)) {
       const ternary = parseTernary(expr, ctx);
       if (ternary) {
         return AttrValueOf.template([ternary]);
       }
     }
-    if (import_typescript12.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript12.default.SyntaxKind.BarBarToken) {
-      if (import_typescript12.default.isIdentifier(expr.right) && expr.right.text === "undefined") {
+    if (import_typescript13.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript13.default.SyntaxKind.BarBarToken) {
+      if (import_typescript13.default.isIdentifier(expr.right) && expr.right.text === "undefined") {
         const baseExpr = ctx.getJS(expr.left);
         return AttrValueOf.expression(baseExpr, { presenceOrUndefined: true });
       }
@@ -197546,11 +197662,11 @@ function getAttributeValue(attr, ctx) {
 function tryStaticStyleObjectToCss(expr) {
   const parts = [];
   for (const prop of expr.properties) {
-    if (!import_typescript12.default.isPropertyAssignment(prop))
+    if (!import_typescript13.default.isPropertyAssignment(prop))
       return null;
-    if (!import_typescript12.default.isIdentifier(prop.name) && !import_typescript12.default.isStringLiteral(prop.name))
+    if (!import_typescript13.default.isIdentifier(prop.name) && !import_typescript13.default.isStringLiteral(prop.name))
       return null;
-    if (!import_typescript12.default.isStringLiteral(prop.initializer))
+    if (!import_typescript13.default.isStringLiteral(prop.initializer))
       return null;
     const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
@@ -197563,7 +197679,7 @@ function parseTemplateLiteral(expr, ctx) {
     parts.push({ type: "string", value: expr.head.text });
   }
   for (const span of expr.templateSpans) {
-    if (import_typescript12.default.isConditionalExpression(span.expression)) {
+    if (import_typescript13.default.isConditionalExpression(span.expression)) {
       const ternary = parseTernary(span.expression, ctx);
       if (ternary) {
         parts.push(ternary);
@@ -197589,7 +197705,7 @@ function parseTemplateLiteral(expr, ctx) {
   return parts;
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
-  if (import_typescript12.default.isIdentifier(expr)) {
+  if (import_typescript13.default.isIdentifier(expr)) {
     if (ctx.scope.isBound(expr.text))
       return null;
     const constInfo = findLocalConst(expr.text, ctx.analyzer);
@@ -197598,13 +197714,13 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
     const ast = parseConstInitializer(constInfo);
     if (!ast)
       return null;
-    if (import_typescript12.default.isStringLiteral(ast) || import_typescript12.default.isNoSubstitutionTemplateLiteral(ast)) {
+    if (import_typescript13.default.isStringLiteral(ast) || import_typescript13.default.isNoSubstitutionTemplateLiteral(ast)) {
       return [{ type: "string", value: ast.text }];
     }
     return null;
   }
-  if (import_typescript12.default.isElementAccessExpression(expr)) {
-    if (!import_typescript12.default.isIdentifier(expr.expression))
+  if (import_typescript13.default.isElementAccessExpression(expr)) {
+    if (!import_typescript13.default.isIdentifier(expr.expression))
       return null;
     if (ctx.scope.isBound(expr.expression.text))
       return null;
@@ -197612,17 +197728,17 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
-    if (!ast || !import_typescript12.default.isObjectLiteralExpression(ast))
+    if (!ast || !import_typescript13.default.isObjectLiteralExpression(ast))
       return null;
     const cases = {};
     for (const prop of ast.properties) {
-      if (!import_typescript12.default.isPropertyAssignment(prop))
+      if (!import_typescript13.default.isPropertyAssignment(prop))
         return null;
-      const keyName = prop.name && (import_typescript12.default.isStringLiteral(prop.name) || import_typescript12.default.isIdentifier(prop.name)) ? prop.name.text : null;
+      const keyName = prop.name && (import_typescript13.default.isStringLiteral(prop.name) || import_typescript13.default.isIdentifier(prop.name)) ? prop.name.text : null;
       if (!keyName)
         return null;
       const value = prop.initializer;
-      if (import_typescript12.default.isStringLiteral(value) || import_typescript12.default.isNoSubstitutionTemplateLiteral(value)) {
+      if (import_typescript13.default.isStringLiteral(value) || import_typescript13.default.isNoSubstitutionTemplateLiteral(value)) {
         cases[keyName] = value.text;
       } else {
         return null;
@@ -197669,17 +197785,17 @@ function hasDynamicTagBinding(name, sourceFile) {
   const visit2 = (node) => {
     if (found)
       return;
-    if (import_typescript12.default.isVariableDeclaration(node) && import_typescript12.default.isIdentifier(node.name) && node.name.text === name && node.initializer) {
+    if (import_typescript13.default.isVariableDeclaration(node) && import_typescript13.default.isIdentifier(node.name) && node.name.text === name && node.initializer) {
       let init = node.initializer;
-      while (import_typescript12.default.isAsExpression(init) || import_typescript12.default.isSatisfiesExpression(init) || import_typescript12.default.isParenthesizedExpression(init) || import_typescript12.default.isNonNullExpression(init)) {
+      while (import_typescript13.default.isAsExpression(init) || import_typescript13.default.isSatisfiesExpression(init) || import_typescript13.default.isParenthesizedExpression(init) || import_typescript13.default.isNonNullExpression(init)) {
         init = init.expression;
       }
-      if (import_typescript12.default.isPropertyAccessExpression(init) && init.name.text === "tag") {
+      if (import_typescript13.default.isPropertyAccessExpression(init) && init.name.text === "tag") {
         found = true;
         return;
       }
     }
-    import_typescript12.default.forEachChild(node, visit2);
+    import_typescript13.default.forEachChild(node, visit2);
   };
   visit2(sourceFile);
   return found;
@@ -197693,13 +197809,13 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   const ast = parseConstInitializer(constInfo);
   if (!ast)
     return null;
-  if (import_typescript12.default.isNoSubstitutionTemplateLiteral(ast) || import_typescript12.default.isStringLiteral(ast)) {
+  if (import_typescript13.default.isNoSubstitutionTemplateLiteral(ast) || import_typescript13.default.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
-  if (import_typescript12.default.isElementAccessExpression(ast) && !import_typescript12.default.isStringLiteralLike(ast.argumentExpression) && !import_typescript12.default.isNumericLiteral(ast.argumentExpression)) {
+  if (import_typescript13.default.isElementAccessExpression(ast) && !import_typescript13.default.isStringLiteralLike(ast.argumentExpression) && !import_typescript13.default.isNumericLiteral(ast.argumentExpression)) {
     return tryResolveTemplateSpanFromConst(ast, ctx);
   }
-  if (!import_typescript12.default.isTemplateExpression(ast))
+  if (!import_typescript13.default.isTemplateExpression(ast))
     return null;
   let resolvedAny = false;
   const parts = [];
@@ -197737,14 +197853,14 @@ function parseConstInitializerImpl(c) {
   if (!c.value)
     return null;
   const wrapped = `const __bf_resolve__ = (${c.value})`;
-  const sf = import_typescript12.default.createSourceFile("__bf_resolve.ts", wrapped, import_typescript12.default.ScriptTarget.Latest, true, import_typescript12.default.ScriptKind.TS);
+  const sf = import_typescript13.default.createSourceFile("__bf_resolve.ts", wrapped, import_typescript13.default.ScriptTarget.Latest, true, import_typescript13.default.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript12.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript13.default.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
     return null;
-  return import_typescript12.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  return import_typescript13.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
 }
 function astText(node) {
   return node.getText(node.getSourceFile());
@@ -197764,9 +197880,9 @@ function parseFunctionInfoAsExprImpl(fn) {
   const params = fn.typedParams !== undefined ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
   const body = fn.typedBody ?? fn.body;
   const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body}`;
-  const sf = import_typescript12.default.createSourceFile("__bf_resolve_fn.ts", wrapped, import_typescript12.default.ScriptTarget.Latest, true, import_typescript12.default.ScriptKind.TS);
+  const sf = import_typescript13.default.createSourceFile("__bf_resolve_fn.ts", wrapped, import_typescript13.default.ScriptTarget.Latest, true, import_typescript13.default.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript12.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript13.default.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
@@ -197774,9 +197890,9 @@ function parseFunctionInfoAsExprImpl(fn) {
   return decl.initializer;
 }
 function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
-  if (!import_typescript12.default.isTaggedTemplateExpression(expr))
+  if (!import_typescript13.default.isTaggedTemplateExpression(expr))
     return expr;
-  if (!import_typescript12.default.isIdentifier(expr.tag))
+  if (!import_typescript13.default.isIdentifier(expr.tag))
     return expr;
   const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx);
   if (!resolvedTag)
@@ -197793,23 +197909,23 @@ function resolveInterleaveTagIdentifier(name, ctx) {
     return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (import_typescript12.default.isArrowFunction(ast) || import_typescript12.default.isFunctionExpression(ast)) ? ast : null;
+    return ast && (import_typescript13.default.isArrowFunction(ast) || import_typescript13.default.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
 function isInterleaveTagFunction(fn) {
-  if (!import_typescript12.default.isArrowFunction(fn) && !import_typescript12.default.isFunctionExpression(fn))
+  if (!import_typescript13.default.isArrowFunction(fn) && !import_typescript13.default.isFunctionExpression(fn))
     return false;
   if (fn.parameters.length !== 2)
     return false;
   const [partsParam, argsParam] = fn.parameters;
-  if (!import_typescript12.default.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
+  if (!import_typescript13.default.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
     return false;
-  if (!import_typescript12.default.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
+  if (!import_typescript13.default.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
     return false;
   const parsed = tsNodeToParsedExpr(fn);
   if (parsed.kind !== "arrow")
@@ -197866,7 +197982,7 @@ function isInterleaveSpanExpr(expr, i2, argsName) {
 function buildUntaggedTemplateLiteral(node, ctx) {
   const template = node.template;
   let text;
-  if (import_typescript12.default.isNoSubstitutionTemplateLiteral(template)) {
+  if (import_typescript13.default.isNoSubstitutionTemplateLiteral(template)) {
     text = "`" + (template.rawText ?? template.text) + "`";
   } else {
     let body = template.head.rawText ?? template.head.text;
@@ -197878,15 +197994,15 @@ function buildUntaggedTemplateLiteral(node, ctx) {
     text = "`" + body + "`";
   }
   const wrapped = `const __bf_resolve_tagged__ = (${text})`;
-  const sf = import_typescript12.default.createSourceFile("__bf_resolve_tagged.tsx", wrapped, import_typescript12.default.ScriptTarget.Latest, true, import_typescript12.default.ScriptKind.TSX);
+  const sf = import_typescript13.default.createSourceFile("__bf_resolve_tagged.tsx", wrapped, import_typescript13.default.ScriptTarget.Latest, true, import_typescript13.default.ScriptKind.TSX);
   const stmt = sf.statements[0];
-  if (!stmt || !import_typescript12.default.isVariableStatement(stmt))
+  if (!stmt || !import_typescript13.default.isVariableStatement(stmt))
     return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer)
     return null;
-  const result = import_typescript12.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
-  if (!import_typescript12.default.isTemplateExpression(result) && !import_typescript12.default.isNoSubstitutionTemplateLiteral(result))
+  const result = import_typescript13.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!import_typescript13.default.isTemplateExpression(result) && !import_typescript13.default.isNoSubstitutionTemplateLiteral(result))
     return null;
   return result;
 }
@@ -197906,10 +198022,10 @@ function parseTernary(expr, ctx) {
   return null;
 }
 function getStringValue(node) {
-  if (import_typescript12.default.isStringLiteral(node)) {
+  if (import_typescript13.default.isStringLiteral(node)) {
     return node.text;
   }
-  if (import_typescript12.default.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_typescript13.default.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
   return null;
@@ -197917,19 +198033,19 @@ function getStringValue(node) {
 function processComponentProps(attributes, ctx) {
   const props = [];
   for (const attr of attributes.properties) {
-    if (import_typescript12.default.isJsxSpreadAttribute(attr)) {
+    if (import_typescript13.default.isJsxSpreadAttribute(attr)) {
       props.push(...expandSpreadAttribute(attr, ctx));
       continue;
     }
-    if (!import_typescript12.default.isJsxAttribute(attr))
+    if (!import_typescript13.default.isJsxAttribute(attr))
       continue;
     const name = attr.name.getText(ctx.sourceFile);
-    if (attr.initializer && import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript13.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       let jsxExpr = attr.initializer.expression;
-      while (import_typescript12.default.isParenthesizedExpression(jsxExpr)) {
+      while (import_typescript13.default.isParenthesizedExpression(jsxExpr)) {
         jsxExpr = jsxExpr.expression;
       }
-      if (import_typescript12.default.isJsxElement(jsxExpr) || import_typescript12.default.isJsxSelfClosingElement(jsxExpr) || import_typescript12.default.isJsxFragment(jsxExpr)) {
+      if (import_typescript13.default.isJsxElement(jsxExpr) || import_typescript13.default.isJsxSelfClosingElement(jsxExpr) || import_typescript13.default.isJsxFragment(jsxExpr)) {
         const prevInsideComponentChildren = ctx.insideComponentChildren;
         ctx.insideComponentChildren = true;
         const irNode = transformNode(jsxExpr, ctx);
@@ -197956,7 +198072,7 @@ function processComponentProps(attributes, ctx) {
       value = AttrValueOf.booleanShorthand();
     }
     let clientOnly;
-    if (attr.initializer && import_typescript12.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && import_typescript13.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) {
@@ -197980,7 +198096,7 @@ function processComponentProps(attributes, ctx) {
   return props;
 }
 function checkBareSignalOrMemoIdentifier(expr, ctx) {
-  if (!import_typescript12.default.isIdentifier(expr))
+  if (!import_typescript13.default.isIdentifier(expr))
     return;
   const name = expr.text;
   for (const signal of ctx.analyzer.signals) {
@@ -198011,12 +198127,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_typescript12.default.isIdentifier(arrayExpr)) {
+  if (import_typescript13.default.isIdentifier(arrayExpr)) {
     return propNames.has(arrayExpr.text);
   }
-  if (import_typescript12.default.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+  if (import_typescript13.default.isPropertyAccessExpression(arrayExpr) && propsObjName) {
     const obj = arrayExpr.expression;
-    if (import_typescript12.default.isIdentifier(obj) && obj.text === propsObjName) {
+    if (import_typescript13.default.isIdentifier(obj) && obj.text === propsObjName) {
       return true;
     }
   }
@@ -198038,7 +198154,7 @@ function referencesLoopParam(expr, ctx) {
   if (boundNames.size === 0)
     return false;
   for (const p of boundNames) {
-    if (new RegExp(`\\b${p}\\b`).test(expr))
+    if (identifierPattern(p).test(expr))
       return true;
   }
   return false;
@@ -198120,7 +198236,7 @@ function hasReactiveAttributes(attrs, ctx) {
     const scopeValueNames = ctx.scope.valueBoundNames();
     if (scopeValueNames.size > 0) {
       for (const p of scopeValueNames) {
-        if (new RegExp(`\\b${p}\\b`).test(valueToCheck))
+        if (identifierPattern(p).test(valueToCheck))
           return true;
       }
     }
@@ -198211,7 +198327,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
         jsxBranchLocalNames.add(n);
     }
     for (const decl of condReturn.scopeVariables) {
-      if (import_typescript12.default.isIdentifier(decl.name) && decl.initializer) {
+      if (import_typescript13.default.isIdentifier(decl.name) && decl.initializer) {
         branchScopeVars.set(decl.name.text, decl.initializer);
         if (initializerShapeContainsJsx(decl.initializer)) {
           jsxBranchLocalNames.add(decl.name.text);
@@ -198278,7 +198394,7 @@ function buildIfStatementChain(analyzer, ctx, opts) {
     }
     const scopeVariables = [];
     for (const decl of condReturn.scopeVariables) {
-      if (import_typescript12.default.isIdentifier(decl.name) && decl.initializer) {
+      if (import_typescript13.default.isIdentifier(decl.name) && decl.initializer) {
         const init = ctx.getJS(decl.initializer);
         const typedInit = decl.initializer.getText(ctx.sourceFile);
         scopeVariables.push({
@@ -198416,13 +198532,13 @@ var KEYWORDS_AND_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-var import_typescript13 = __toESM(require_typescript(), 1);
+var import_typescript14 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/value-references.ts
-var import_typescript14 = __toESM(require_typescript(), 1);
+var import_typescript15 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/relocate.ts
-var import_typescript15 = __toESM(require_typescript(), 1);
+var import_typescript16 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -198601,10 +198717,10 @@ function formatDateLocalNames(metadata) {
 }
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-var import_typescript16 = __toESM(require_typescript(), 1);
+var import_typescript17 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-var import_typescript17 = __toESM(require_typescript(), 1);
+var import_typescript18 = __toESM(require_typescript(), 1);
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -198654,7 +198770,7 @@ var INERT_BINDING_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-var import_typescript18 = __toESM(require_typescript(), 1);
+var import_typescript19 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
@@ -198669,7 +198785,7 @@ var NON_BUBBLING_EVENTS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-var import_typescript19 = __toESM(require_typescript(), 1);
+var import_typescript20 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/source-map.ts
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -198760,21 +198876,21 @@ class SourceMapGenerator {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-var import_typescript20 = __toESM(require_typescript(), 1);
+var import_typescript21 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ssr-defaults.ts
-var import_typescript21 = __toESM(require_typescript(), 1);
+var import_typescript22 = __toESM(require_typescript(), 1);
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 
 // ../jsx/src/augment-inherited-props.ts
-var import_typescript22 = __toESM(require_typescript(), 1);
+var import_typescript23 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/rich-type-refusal.ts
 var EMPTY_BINDINGS2 = new Map;
 // ../jsx/src/shared-program.ts
 init_path();
-var import_typescript24 = __toESM(require_typescript(), 1);
+var import_typescript25 = __toESM(require_typescript(), 1);
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -198827,7 +198943,7 @@ class JsxAdapter extends BaseAdapter {
       ...localFunctions.map((f) => ({ name: f.name, body: f.body })),
       ...localConstants.map((c) => ({ name: c.name, body: c.value }))
     ];
-    const reachable = findReachableNames(primaryRefText, declarations);
+    const reachable = closeOverWritersOfMutableBindings(primaryRefText, declarations, new Set(ir.metadata.localConstants.filter((c) => (c.declarationKind ?? "const") !== "const").map((c) => c.name)));
     const reachableBodies = [...reachable].map((name) => {
       const func = localFunctions.find((f) => f.name === name);
       if (func)
@@ -198857,9 +198973,10 @@ class JsxAdapter extends BaseAdapter {
         lines.push(`  const ${signal.getter} = () => ${initialValue}`);
       }
       if (signal.setter) {
-        const setterUsed = new RegExp(`\\b${signal.setter}\\b`).test(setterRefText);
+        const setterUsed = identifierPattern(signal.setter).test(setterRefText);
         if (setterUsed) {
-          lines.push(`  const ${signal.setter} = (..._args: any[]) => {}`);
+          const setterType = preserveTypes && signal.type.kind !== "unknown" ? `(valueOrFn: ${signal.type.raw} | ((prev: ${signal.type.raw}) => ${signal.type.raw})) => void` : null;
+          lines.push(setterType ? `  const ${signal.setter}: ${setterType} = () => {}` : `  const ${signal.setter} = (..._args: any[]) => {}`);
         }
       }
     }
@@ -199055,6 +199172,7 @@ class JsxAdapter extends BaseAdapter {
 }
 
 // ../jsx/src/adapters/template-imports.ts
+var import_typescript26 = __toESM(require_typescript(), 1);
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
   "@barefootjs/client/runtime"
@@ -199193,7 +199311,8 @@ export default ${this.componentName}` : "";
     const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
     const lines = [];
     const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
-    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    const typeParameters = ir.metadata.typeParameters ?? "";
+    lines.push(`${exportPrefix}function ${name}${typeParameters}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
     if (hasClientInteractivity) {
       lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
     } else {
@@ -199444,9 +199563,9 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-var import_typescript25 = __toESM(require_typescript(), 1);
+var import_typescript27 = __toESM(require_typescript(), 1);
 // ../jsx/src/debug.ts
-var import_typescript26 = __toESM(require_typescript(), 1);
+var import_typescript28 = __toESM(require_typescript(), 1);
 function escapeForIdBoundary(name) {
   return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -199538,7 +199657,7 @@ function resolveSetters(handler, setterToSignal, fnSetters) {
   return refs;
 }
 // ../jsx/src/profiler.ts
-var import_typescript27 = __toESM(require_typescript(), 1);
+var import_typescript29 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();