@geajs/vite-plugin 1.0.5 → 1.0.6

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import babelGenerator from "@babel/generator";
-import babelTraverse from "@babel/traverse";
+import babelGenerator2 from "@babel/generator";
+import babelTraverse2 from "@babel/traverse";
 
 // src/parse.ts
 import { parse } from "@babel/parser";
@@ -183,8 +183,10 @@ import * as t3 from "@babel/types";
 import { id as id2, js, jsExpr } from "eszter";
 
 // src/utils.ts
+import babelTraverse from "@babel/traverse";
 import * as t2 from "@babel/types";
 import { id, jsImport } from "eszter";
+var traverse2 = typeof babelTraverse.default === "function" ? babelTraverse.default : babelTraverse;
 function getJSXTagName(name) {
   if (t2.isJSXIdentifier(name)) return name.name;
   if (t2.isJSXMemberExpression(name)) {
@@ -238,31 +240,31 @@ function getDirectChildElements(children) {
   });
 }
 function ensureImport(ast, source, specifier, isDefault = false) {
-  const program9 = ast.program;
+  const program10 = ast.program;
   const buildSpecifier = () => isDefault ? t2.importDefaultSpecifier(t2.identifier(specifier)) : t2.importSpecifier(t2.identifier(specifier), t2.identifier(specifier));
   if (isDefault) {
-    const alreadyHasDefault = program9.body.some(
+    const alreadyHasDefault = program10.body.some(
       (node) => t2.isImportDeclaration(node) && node.source.value === source && node.specifiers.some((s) => t2.isImportDefaultSpecifier(s))
     );
     if (alreadyHasDefault) return false;
     const insertIndex = Math.max(
       0,
-      program9.body.reduce((idx, node, i) => t2.isImportDeclaration(node) ? i + 1 : idx, 0)
+      program10.body.reduce((idx, node, i) => t2.isImportDeclaration(node) ? i + 1 : idx, 0)
     );
-    program9.body.splice(
+    program10.body.splice(
       insertIndex,
       0,
       isDefault ? jsImport`import ${id(specifier)} from ${source};` : jsImport`import { ${id(specifier)} } from ${source};`
     );
     return true;
   }
-  const declaration = program9.body.find((node) => t2.isImportDeclaration(node) && node.source.value === source);
+  const declaration = program10.body.find((node) => t2.isImportDeclaration(node) && node.source.value === source);
   if (!declaration) {
     const insertIndex = Math.max(
       0,
-      program9.body.reduce((idx, node, i) => t2.isImportDeclaration(node) ? i + 1 : idx, 0)
+      program10.body.reduce((idx, node, i) => t2.isImportDeclaration(node) ? i + 1 : idx, 0)
     );
-    program9.body.splice(insertIndex, 0, jsImport`import { ${id(specifier)} } from ${source};`);
+    program10.body.splice(insertIndex, 0, jsImport`import { ${id(specifier)} } from ${source};`);
     return true;
   }
   const exists = declaration.specifiers.some(
@@ -345,11 +347,7 @@ function resolvePath(expr, stateRefs, context = {}) {
     return { parts: [] };
   }
   if (t2.isCallExpression(expr) && t2.isMemberExpression(expr.callee)) {
-    return resolvePath(
-      expr.callee.object,
-      stateRefs,
-      context
-    );
+    return resolvePath(expr.callee.object, stateRefs, context);
   }
   if (t2.isMemberExpression(expr)) {
     const objectResult = resolvePath(
@@ -450,6 +448,10 @@ function collectAllIdentifierNames(statements, fromIndex, additionalNodes) {
       walk(node.object);
       return;
     }
+    if (t2.isVariableDeclarator(node)) {
+      walk(node.init);
+      return;
+    }
     for (const key of t2.VISITOR_KEYS[node.type] || []) {
       const child = node[key];
       if (Array.isArray(child)) {
@@ -489,6 +491,418 @@ function pruneUnusedSetupDestructuring(setupStatements, bodyNodes) {
 function replacePropRefsInExpression(expr, propNames, wholeParamName, propDefaults) {
   return replacePropRefsInNode(expr, propNames, wholeParamName, propDefaults);
 }
+function isThisPropsMember(node) {
+  return t2.isMemberExpression(node) && !node.computed && t2.isThisExpression(node.object) && t2.isIdentifier(node.property, { name: "props" });
+}
+function replaceThisPropsRootWithValueParam(expr, propName) {
+  const visit = (e) => {
+    if (t2.isMemberExpression(e) && !e.computed && isThisPropsMember(e.object) && t2.isIdentifier(e.property, { name: propName })) {
+      return t2.identifier("value");
+    }
+    if (t2.isMemberExpression(e)) {
+      return t2.memberExpression(visit(e.object), e.property, e.computed);
+    }
+    if (t2.isOptionalMemberExpression(e)) {
+      return t2.optionalMemberExpression(
+        visit(e.object),
+        e.property,
+        e.computed,
+        e.optional
+      );
+    }
+    if (t2.isOptionalCallExpression(e)) {
+      return t2.optionalCallExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a),
+        e.optional
+      );
+    }
+    if (t2.isCallExpression(e)) {
+      return t2.callExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    if (t2.isConditionalExpression(e)) {
+      return t2.conditionalExpression(visit(e.test), visit(e.consequent), visit(e.alternate));
+    }
+    if (t2.isLogicalExpression(e)) {
+      return t2.logicalExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isBinaryExpression(e)) {
+      return t2.binaryExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isUnaryExpression(e)) {
+      return t2.unaryExpression(e.operator, visit(e.argument), e.prefix);
+    }
+    if (t2.isSequenceExpression(e)) {
+      return t2.sequenceExpression(e.expressions.map((x) => visit(x)));
+    }
+    if (t2.isAssignmentExpression(e)) {
+      return t2.assignmentExpression(e.operator, e.left, visit(e.right));
+    }
+    if (t2.isArrayExpression(e)) {
+      return t2.arrayExpression(
+        e.elements.map((el) => {
+          if (el === null) return null;
+          if (t2.isSpreadElement(el)) return t2.spreadElement(visit(el.argument));
+          return visit(el);
+        })
+      );
+    }
+    if (t2.isObjectExpression(e)) {
+      return t2.objectExpression(
+        e.properties.map((p) => {
+          if (t2.isSpreadElement(p)) return t2.spreadElement(visit(p.argument));
+          if (t2.isObjectProperty(p)) {
+            return t2.objectProperty(
+              p.computed ? visit(p.key) : p.key,
+              visit(p.value),
+              p.computed,
+              p.shorthand
+            );
+          }
+          return p;
+        })
+      );
+    }
+    if (t2.isTemplateLiteral(e)) {
+      return t2.templateLiteral(
+        e.quasis,
+        e.expressions.map((x) => visit(x))
+      );
+    }
+    if (t2.isTaggedTemplateExpression(e)) {
+      return t2.taggedTemplateExpression(visit(e.tag), visit(e.quasi));
+    }
+    if (t2.isNewExpression(e)) {
+      return t2.newExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    return e;
+  };
+  return visit(expr);
+}
+function derivedExprGuardsValueWhenNullish(expr) {
+  if (!t2.isConditionalExpression(expr)) return false;
+  return testBranchesOnValueNullish(expr.test);
+}
+function unwrapExpressionRoot(e) {
+  let x = e;
+  while (t2.isParenthesizedExpression(x)) x = x.expression;
+  while (t2.isTSAsExpression(x) || t2.isTSSatisfiesExpression(x)) x = x.expression;
+  return x;
+}
+function expressionAccessesValueProperties(expr, setupStmts, valueId = "value") {
+  const body = [...setupStmts ?? []];
+  if (expr) body.push(t2.expressionStatement(expr));
+  const program10 = t2.program([t2.blockStatement(body)]);
+  let found = false;
+  traverse2(program10, {
+    noScope: true,
+    MemberExpression(path) {
+      if (found) return;
+      const obj = unwrapExpressionRoot(path.node.object);
+      if (t2.isIdentifier(obj, { name: valueId })) {
+        found = true;
+        path.stop();
+      }
+    }
+  });
+  return found;
+}
+function earlyReturnFalsyBindingName(guard) {
+  if (t2.isUnaryExpression(guard) && guard.operator === "!" && t2.isIdentifier(guard.argument)) {
+    return guard.argument.name;
+  }
+  if (t2.isBinaryExpression(guard) && (guard.operator === "==" || guard.operator === "===")) {
+    const nullish = (e) => t2.isNullLiteral(e) || t2.isIdentifier(e) && e.name === "undefined";
+    if (t2.isIdentifier(guard.left) && nullish(guard.right)) return guard.left.name;
+    if (t2.isIdentifier(guard.right) && nullish(guard.left)) return guard.right.name;
+  }
+  if (t2.isLogicalExpression(guard) && guard.operator === "||") {
+    return earlyReturnFalsyBindingName(guard.left) || earlyReturnFalsyBindingName(guard.right);
+  }
+  return null;
+}
+function optionalizeMemberChainsFromBindingRoot(expr, rootName) {
+  const visit = (e) => {
+    if (t2.isMemberExpression(e) && !e.computed) {
+      const obj = visit(e.object);
+      if (t2.isIdentifier(e.object, { name: rootName })) {
+        return t2.optionalMemberExpression(e.object, e.property, false, true);
+      }
+      if (t2.isOptionalMemberExpression(obj)) {
+        return t2.optionalMemberExpression(obj, e.property, false, true);
+      }
+      return t2.memberExpression(obj, e.property, false);
+    }
+    if (t2.isOptionalMemberExpression(e)) {
+      return t2.optionalMemberExpression(
+        visit(e.object),
+        e.property,
+        e.computed,
+        e.optional
+      );
+    }
+    if (t2.isOptionalCallExpression(e)) {
+      return t2.optionalCallExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a),
+        e.optional
+      );
+    }
+    if (t2.isCallExpression(e)) {
+      return t2.callExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    if (t2.isConditionalExpression(e)) {
+      return t2.conditionalExpression(visit(e.test), visit(e.consequent), visit(e.alternate));
+    }
+    if (t2.isLogicalExpression(e)) {
+      return t2.logicalExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isBinaryExpression(e)) {
+      return t2.binaryExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isUnaryExpression(e)) {
+      return t2.unaryExpression(e.operator, visit(e.argument), e.prefix);
+    }
+    if (t2.isSequenceExpression(e)) {
+      return t2.sequenceExpression(e.expressions.map((x) => visit(x)));
+    }
+    if (t2.isAssignmentExpression(e)) {
+      return t2.assignmentExpression(e.operator, e.left, visit(e.right));
+    }
+    if (t2.isArrayExpression(e)) {
+      return t2.arrayExpression(
+        e.elements.map((el) => {
+          if (el === null) return null;
+          if (t2.isSpreadElement(el)) return t2.spreadElement(visit(el.argument));
+          return visit(el);
+        })
+      );
+    }
+    if (t2.isObjectExpression(e)) {
+      return t2.objectExpression(
+        e.properties.map((p) => {
+          if (t2.isSpreadElement(p)) return t2.spreadElement(visit(p.argument));
+          if (t2.isObjectProperty(p)) {
+            return t2.objectProperty(
+              p.computed ? visit(p.key) : p.key,
+              visit(p.value),
+              p.computed,
+              p.shorthand
+            );
+          }
+          return p;
+        })
+      );
+    }
+    if (t2.isTemplateLiteral(e)) {
+      return t2.templateLiteral(
+        e.quasis,
+        e.expressions.map((x) => visit(x))
+      );
+    }
+    if (t2.isTaggedTemplateExpression(e)) {
+      return t2.taggedTemplateExpression(visit(e.tag), visit(e.quasi));
+    }
+    if (t2.isNewExpression(e)) {
+      return t2.newExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    return e;
+  };
+  return visit(expr);
+}
+function optionalizeBindingRootInStatements(stmts, rootName) {
+  const mapStmt = (s) => {
+    if (t2.isVariableDeclaration(s)) {
+      return t2.variableDeclaration(
+        s.kind,
+        s.declarations.map(
+          (d) => t2.variableDeclarator(d.id, d.init ? optionalizeMemberChainsFromBindingRoot(d.init, rootName) : null)
+        )
+      );
+    }
+    if (t2.isExpressionStatement(s)) {
+      return t2.expressionStatement(optionalizeMemberChainsFromBindingRoot(s.expression, rootName));
+    }
+    if (t2.isReturnStatement(s)) {
+      return t2.returnStatement(s.argument ? optionalizeMemberChainsFromBindingRoot(s.argument, rootName) : null);
+    }
+    if (t2.isBlockStatement(s)) {
+      return t2.blockStatement(s.body.map(mapStmt));
+    }
+    if (t2.isIfStatement(s)) {
+      return t2.ifStatement(
+        optionalizeMemberChainsFromBindingRoot(s.test, rootName),
+        mapStmt(s.consequent),
+        s.alternate ? mapStmt(s.alternate) : null
+      );
+    }
+    return s;
+  };
+  return stmts.map((s) => mapStmt(t2.cloneNode(s, true)));
+}
+function optionalizeMemberChainsAfterComputedItemKey(expr, itemKeyName) {
+  const visit = (e) => {
+    if (t2.isMemberExpression(e) && !e.computed) {
+      const origObj = e.object;
+      const inner = visit(origObj);
+      if (t2.isMemberExpression(origObj) && origObj.computed && t2.isIdentifier(origObj.property, { name: itemKeyName })) {
+        return t2.optionalMemberExpression(inner, e.property, false, true);
+      }
+      if (t2.isOptionalMemberExpression(inner)) {
+        return t2.optionalMemberExpression(inner, e.property, false, true);
+      }
+      return t2.memberExpression(inner, e.property, false);
+    }
+    if (t2.isMemberExpression(e) && e.computed) {
+      return t2.memberExpression(
+        visit(e.object),
+        visit(e.property),
+        true
+      );
+    }
+    if (t2.isOptionalMemberExpression(e)) {
+      return t2.optionalMemberExpression(
+        visit(e.object),
+        e.property,
+        e.computed,
+        e.optional
+      );
+    }
+    if (t2.isOptionalCallExpression(e)) {
+      return t2.optionalCallExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a),
+        e.optional
+      );
+    }
+    if (t2.isCallExpression(e)) {
+      return t2.callExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    if (t2.isConditionalExpression(e)) {
+      return t2.conditionalExpression(visit(e.test), visit(e.consequent), visit(e.alternate));
+    }
+    if (t2.isLogicalExpression(e)) {
+      return t2.logicalExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isBinaryExpression(e)) {
+      return t2.binaryExpression(e.operator, visit(e.left), visit(e.right));
+    }
+    if (t2.isUnaryExpression(e)) {
+      return t2.unaryExpression(e.operator, visit(e.argument), e.prefix);
+    }
+    if (t2.isSequenceExpression(e)) {
+      return t2.sequenceExpression(e.expressions.map((x) => visit(x)));
+    }
+    if (t2.isAssignmentExpression(e)) {
+      return t2.assignmentExpression(e.operator, e.left, visit(e.right));
+    }
+    if (t2.isArrayExpression(e)) {
+      return t2.arrayExpression(
+        e.elements.map((el) => {
+          if (el === null) return null;
+          if (t2.isSpreadElement(el)) return t2.spreadElement(visit(el.argument));
+          return visit(el);
+        })
+      );
+    }
+    if (t2.isObjectExpression(e)) {
+      return t2.objectExpression(
+        e.properties.map((p) => {
+          if (t2.isSpreadElement(p)) return t2.spreadElement(visit(p.argument));
+          if (t2.isObjectProperty(p)) {
+            return t2.objectProperty(
+              p.computed ? visit(p.key) : p.key,
+              visit(p.value),
+              p.computed,
+              p.shorthand
+            );
+          }
+          return p;
+        })
+      );
+    }
+    if (t2.isTemplateLiteral(e)) {
+      return t2.templateLiteral(
+        e.quasis,
+        e.expressions.map((x) => visit(x))
+      );
+    }
+    if (t2.isTaggedTemplateExpression(e)) {
+      return t2.taggedTemplateExpression(visit(e.tag), visit(e.quasi));
+    }
+    if (t2.isNewExpression(e)) {
+      return t2.newExpression(
+        visit(e.callee),
+        e.arguments.map((a) => t2.isExpression(a) ? visit(a) : a)
+      );
+    }
+    if (t2.isParenthesizedExpression(e)) {
+      return t2.parenthesizedExpression(visit(e.expression));
+    }
+    return e;
+  };
+  return visit(expr);
+}
+function optionalizeComputedItemKeyInStatements(stmts, itemKeyName) {
+  const mapStmt = (s) => {
+    if (t2.isVariableDeclaration(s)) {
+      return t2.variableDeclaration(
+        s.kind,
+        s.declarations.map(
+          (d) => t2.variableDeclarator(d.id, d.init ? optionalizeMemberChainsAfterComputedItemKey(d.init, itemKeyName) : null)
+        )
+      );
+    }
+    if (t2.isExpressionStatement(s)) {
+      return t2.expressionStatement(optionalizeMemberChainsAfterComputedItemKey(s.expression, itemKeyName));
+    }
+    if (t2.isReturnStatement(s)) {
+      return t2.returnStatement(s.argument ? optionalizeMemberChainsAfterComputedItemKey(s.argument, itemKeyName) : null);
+    }
+    if (t2.isBlockStatement(s)) {
+      return t2.blockStatement(s.body.map(mapStmt));
+    }
+    if (t2.isIfStatement(s)) {
+      return t2.ifStatement(
+        optionalizeMemberChainsAfterComputedItemKey(s.test, itemKeyName),
+        mapStmt(s.consequent),
+        s.alternate ? mapStmt(s.alternate) : null
+      );
+    }
+    return s;
+  };
+  return stmts.map((s) => mapStmt(t2.cloneNode(s, true)));
+}
+function testBranchesOnValueNullish(test) {
+  if (t2.isIdentifier(test, { name: "value" })) return true;
+  if (t2.isBinaryExpression(test) && ["==", "===", "!=", "!=="].includes(test.operator)) {
+    const isValue = (e) => t2.isIdentifier(e, { name: "value" });
+    const isNullishLit = (e) => t2.isNullLiteral(e) || t2.isIdentifier(e) && e.name === "undefined";
+    return isValue(test.left) && isNullishLit(test.right) || isValue(test.right) && isNullishLit(test.left);
+  }
+  if (t2.isUnaryExpression(test) && test.operator === "!" && t2.isIdentifier(test.argument, { name: "value" })) {
+    return true;
+  }
+  if (t2.isLogicalExpression(test)) {
+    return testBranchesOnValueNullish(test.left) || testBranchesOnValueNullish(test.right);
+  }
+  return false;
+}
 function replacePropRefsInNode(node, propNames, wholeParamName, propDefaults) {
   if (t2.isIdentifier(node) && wholeParamName && node.name === wholeParamName) {
     return t2.memberExpression(t2.thisExpression(), t2.identifier("props"));
@@ -874,7 +1288,8 @@ function normalizeDestructuredMapCallback(arrowFn) {
     const rewriteNode2 = (node) => {
       if (!node || typeof node !== "object") return;
       for (const key of Object.keys(node)) {
-        if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+        if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments")
+          continue;
         const child = node[key];
         if (Array.isArray(child)) {
           for (let i = 0; i < child.length; i++) {
@@ -882,7 +1297,11 @@ function normalizeDestructuredMapCallback(arrowFn) {
               if (t4.isIdentifier(child[i]) && indexMap.has(child[i].name)) {
                 if (t4.isMemberExpression(node) && key === "property" && !node.computed) continue;
                 if (t4.isObjectProperty(node) && key === "key") continue;
-                child[i] = t4.memberExpression(t4.identifier(itemName), t4.numericLiteral(indexMap.get(child[i].name)), true);
+                child[i] = t4.memberExpression(
+                  t4.identifier(itemName),
+                  t4.numericLiteral(indexMap.get(child[i].name)),
+                  true
+                );
               } else {
                 rewriteNode2(child[i]);
               }
@@ -892,7 +1311,11 @@ function normalizeDestructuredMapCallback(arrowFn) {
           if (t4.isIdentifier(child) && indexMap.has(child.name)) {
             if (t4.isMemberExpression(node) && key === "property" && !node.computed) continue;
             if (t4.isObjectProperty(node) && key === "key") continue;
-            node[key] = t4.memberExpression(t4.identifier(itemName), t4.numericLiteral(indexMap.get(child.name)), true);
+            node[key] = t4.memberExpression(
+              t4.identifier(itemName),
+              t4.numericLiteral(indexMap.get(child.name)),
+              true
+            );
           } else {
             rewriteNode2(child);
           }
@@ -915,7 +1338,8 @@ function normalizeDestructuredMapCallback(arrowFn) {
   const rewriteNode = (node) => {
     if (!node || typeof node !== "object") return;
     for (const key of Object.keys(node)) {
-      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments")
+        continue;
       const child = node[key];
       if (Array.isArray(child)) {
         for (let i = 0; i < child.length; i++) {
@@ -1021,7 +1445,7 @@ function detectContainerSelector(node, tagName) {
 // src/analyze-map.ts
 import { createRequire as createRequire3 } from "module";
 var require4 = createRequire3(import.meta.url);
-var traverse2 = require4("@babel/traverse").default;
+var traverse3 = require4("@babel/traverse").default;
 function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindings, conditionalBindings, elementPath, isImportedState, itemIdProperty, stateRefs, childIndices = [], storeVar) {
   const context = { inMap: true, mapItemVar: itemVar };
   node.openingElement.attributes.forEach((attr) => {
@@ -1224,8 +1648,8 @@ function analyzeItemTemplateLiteral(expr, arrayPath, itemVar, itemBindings, rela
 function collectConditionalBindings(expr, type, attributeName, conditionalBindings, arrayPath, itemVar, elementPath, childPath, stateRefs, storeVar) {
   const dependencies = /* @__PURE__ */ new Map();
   const requiresRerender = conditionalExpressionRequiresRerender(expr);
-  const program9 = t5.program([t5.expressionStatement(t5.cloneNode(expr, true))]);
-  traverse2(program9, {
+  const program10 = t5.program([t5.expressionStatement(t5.cloneNode(expr, true))]);
+  traverse3(program10, {
     noScope: true,
     MemberExpression(path) {
       const parent = path.parentPath;
@@ -1268,8 +1692,8 @@ function collectConditionalBindings(expr, type, attributeName, conditionalBindin
 }
 function conditionalExpressionRequiresRerender(expr) {
   let needsRerender = false;
-  const program9 = t5.program([t5.expressionStatement(t5.cloneNode(expr, true))]);
-  traverse2(program9, {
+  const program10 = t5.program([t5.expressionStatement(t5.cloneNode(expr, true))]);
+  traverse3(program10, {
     noScope: true,
     JSXElement(path) {
       needsRerender = true;
@@ -1364,7 +1788,7 @@ function extractClassName(node) {
 import * as t6 from "@babel/types";
 import { createRequire as createRequire4 } from "module";
 var require5 = createRequire4(import.meta.url);
-var traverse3 = require5("@babel/traverse").default;
+var traverse4 = require5("@babel/traverse").default;
 function buildComponentPropsExpression(jsxElement, imports, componentInstances, eventHandlers, stateRefs, templateSetupContext, transformExpression, transformFragment) {
   const props = [];
   const dependencies = /* @__PURE__ */ new Map();
@@ -1377,7 +1801,9 @@ function buildComponentPropsExpression(jsxElement, imports, componentInstances,
     else if (t6.isJSXExpressionContainer(attr.value) && !t6.isJSXEmptyExpression(attr.value.expression)) {
       const expr = attr.value.expression;
       propValue = transformExpression(expr);
-      if (propValue && (/^on[A-Z]/.test(propName) || /^(click|input|change|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave|touchstart|touchend|touchmove|pointerdown|pointerup|pointermove|scroll|resize|drag|dragstart|dragend|dragover|drop|reset)$/.test(propName)) && t6.isMemberExpression(propValue)) {
+      if (propValue && (/^on[A-Z]/.test(propName) || /^(click|input|change|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave|touchstart|touchend|touchmove|pointerdown|pointerup|pointermove|scroll|resize|drag|dragstart|dragend|dragover|drop|reset)$/.test(
+        propName
+      )) && t6.isMemberExpression(propValue)) {
         const argsId = t6.identifier("args");
         propValue = t6.arrowFunctionExpression(
           [t6.restElement(argsId)],
@@ -1449,11 +1875,11 @@ function collectExpressionDependenciesInto(expr, stateRefs, dependencies, setupS
       });
     });
   });
-  const program9 = t6.program([
+  const program10 = t6.program([
     ...setupStatements.map((statement) => t6.cloneNode(statement, true)),
     t6.expressionStatement(t6.cloneNode(expr, true))
   ]);
-  traverse3(program9, {
+  traverse4(program10, {
     noScope: true,
     MemberExpression(path) {
       const parent = path.parentPath;
@@ -1533,6 +1959,28 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
   };
   collectReferencedIdentifiers(expr).forEach(includeName);
   ordered.sort((a, b) => a.index - b.index);
+  const barrier = templateSetupContext.earlyReturnBarrierIndex;
+  if (barrier !== void 0 && ordered.length > 0) {
+    const stmtIndices = ordered.filter((e) => e.index >= 0).map((e) => e.index);
+    if (stmtIndices.length > 0) {
+      const maxIdx = Math.max(...stmtIndices);
+      const minIdx = Math.min(...stmtIndices);
+      if (maxIdx > barrier || minIdx <= barrier) {
+        const have = new Set(ordered.map((e) => e.index));
+        const extra = [];
+        for (let bi = 0; bi <= barrier; bi++) {
+          if (!have.has(bi)) {
+            extra.push({
+              index: bi,
+              statement: t6.cloneNode(templateSetupContext.statements[bi], true)
+            });
+          }
+        }
+        ordered.push(...extra);
+        ordered.sort((a, b) => a.index - b.index);
+      }
+    }
+  }
   for (const entry of ordered) {
     if (entry.index !== -1) continue;
     if (!t6.isVariableDeclaration(entry.statement)) continue;
@@ -1578,10 +2026,10 @@ function collectPatternIdentifiers(pattern) {
 }
 function collectReferencedIdentifiers(node) {
   const names = /* @__PURE__ */ new Set();
-  const program9 = t6.program([
+  const program10 = t6.program([
     t6.isStatement(node) ? t6.cloneNode(node, true) : t6.expressionStatement(t6.cloneNode(node, true))
   ]);
-  traverse3(program9, {
+  traverse4(program10, {
     noScope: true,
     Identifier(path) {
       if (!path.isReferencedIdentifier()) return;
@@ -1594,7 +2042,7 @@ function collectReferencedIdentifiers(node) {
 // src/analyze.ts
 import { createRequire as createRequire5 } from "module";
 var require6 = createRequire5(import.meta.url);
-var traverse4 = require6("@babel/traverse").default;
+var traverse5 = require6("@babel/traverse").default;
 function buildTextTemplateExpressionFromParts(textTemplate, textExpressions) {
   const templateParts = textTemplate.split(/\$\{(\d+)\}/g);
   const quasis = [];
@@ -1687,16 +2135,8 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
       conditionalSlotScopedStoreKeys: /* @__PURE__ */ new Set(),
       conditionalSlotNodeMap: /* @__PURE__ */ new Map()
     };
-  let earlyReturnGuard;
   const bodyStmts = templateMethod.body.body;
-  for (let i = 0; i < bodyStmts.length - 1; i++) {
-    const s = bodyStmts[i];
-    if (t7.isIfStatement(s) && !s.alternate && t7.isBlockStatement(s.consequent) && s.consequent.body.length === 1 && t7.isReturnStatement(s.consequent.body[0]) && s.consequent.body[0].argument && t7.isReturnStatement(bodyStmts[i + 1])) {
-      earlyReturnGuard = t7.cloneNode(s.test, true);
-      break;
-    }
-  }
-  const returnStmt = templateMethod.body.body.find((s) => t7.isReturnStatement(s) && s.argument !== null);
+  const returnStmt = bodyStmts.find((s) => t7.isReturnStatement(s) && s.argument !== null);
   if (!returnStmt?.argument)
     return {
       bindings,
@@ -1712,7 +2152,25 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
       conditionalSlotScopedStoreKeys: /* @__PURE__ */ new Set(),
       conditionalSlotNodeMap: /* @__PURE__ */ new Map()
     };
-  const returnIndex = templateMethod.body.body.indexOf(returnStmt);
+  const returnIndex = bodyStmts.indexOf(returnStmt);
+  let earlyReturnGuard;
+  let earlyReturnBarrierIndex;
+  const earlyReturnFromIf = (s) => {
+    if (t7.isReturnStatement(s.consequent) && s.consequent.argument) return s.consequent;
+    if (t7.isBlockStatement(s.consequent) && s.consequent.body.length === 1 && t7.isReturnStatement(s.consequent.body[0]) && s.consequent.body[0].argument) {
+      return s.consequent.body[0];
+    }
+    return null;
+  };
+  for (let i = 0; i < returnIndex; i++) {
+    const s = bodyStmts[i];
+    if (!t7.isIfStatement(s) || s.alternate) continue;
+    const earlyRet = earlyReturnFromIf(s);
+    if (!earlyRet?.argument) continue;
+    earlyReturnGuard = t7.cloneNode(s.test, true);
+    earlyReturnBarrierIndex = i;
+    break;
+  }
   const templateSetupContext = {
     params: templateMethod.params.filter(
       (param) => !t7.isTSParameterProperty(param)
@@ -1837,7 +2295,8 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
     elementPathToBindingId,
     conditionalSlotScopedStoreKeys,
     conditionalSlotNodeMap,
-    earlyReturnGuard
+    earlyReturnGuard,
+    earlyReturnBarrierIndex
   };
 }
 function computeConditionalSlotScopedStoreKeys(conditionalSlots, stateProps, stateRefs, templateSetupContext) {
@@ -2158,8 +2617,8 @@ function isMapCall(expr) {
 function collectNestedMapCalls(expr) {
   if (t7.isJSXEmptyExpression(expr)) return [];
   const maps = [];
-  const program9 = t7.program([t7.expressionStatement(t7.cloneNode(expr, true))]);
-  traverse4(program9, {
+  const program10 = t7.program([t7.expressionStatement(t7.cloneNode(expr, true))]);
+  traverse5(program10, {
     noScope: true,
     CallExpression(path) {
       if (isMapCall(path.node)) {
@@ -2658,12 +3117,12 @@ function buildDerivedPropBindings(expr, type, attributeName, elementPath, propsP
 }
 function collectDependentPropNames(expr, setupStatements, propsParamName, destructuredPropNames, classBody2) {
   const names = /* @__PURE__ */ new Set();
-  const program9 = t7.program([
+  const program10 = t7.program([
     ...setupStatements.map((statement) => t7.cloneNode(statement, true)),
     t7.expressionStatement(t7.cloneNode(expr, true))
   ]);
   const getterNamesToExpand = /* @__PURE__ */ new Set();
-  traverse4(program9, {
+  traverse5(program10, {
     noScope: true,
     Identifier(path) {
       if (!path.isReferencedIdentifier()) return;
@@ -2682,7 +3141,7 @@ function collectDependentPropNames(expr, setupStatements, propsParamName, destru
       if (!t7.isClassMethod(member) || member.kind !== "get" || !t7.isIdentifier(member.key) || !getterNamesToExpand.has(member.key.name))
         continue;
       const getterProgram = t7.program(member.body.body.map((s) => t7.cloneNode(s, true)));
-      traverse4(getterProgram, {
+      traverse5(getterProgram, {
         noScope: true,
         Identifier(path) {
           if (!path.isReferencedIdentifier()) return;
@@ -2706,7 +3165,7 @@ function collectDependentPropNames(expr, setupStatements, propsParamName, destru
 function collectAllStateAccesses(templateMethod, stateRefs, stateProps) {
   const params = templateMethod.params.filter((param) => !t7.isTSParameterProperty(param));
   const prog = t7.program([t7.expressionStatement(t7.arrowFunctionExpression(params, templateMethod.body))]);
-  traverse4(prog, {
+  traverse5(prog, {
     noScope: true,
     Identifier(path) {
       if (!stateRefs.has(path.node.name)) return;
@@ -2766,7 +3225,7 @@ function collectAllStateAccesses(templateMethod, stateRefs, stateProps) {
 function collectItemTemplateStoreDependencies(itemTemplate, itemVar, stateRefs, dependencies) {
   if (!itemTemplate) return;
   const prog = t7.program([t7.expressionStatement(t7.cloneNode(itemTemplate, true))]);
-  traverse4(prog, {
+  traverse5(prog, {
     noScope: true,
     MemberExpression(path) {
       let root = path.node;
@@ -2926,7 +3385,8 @@ function extractSingleCallExpression(expr) {
 }
 function getHoistableRootEvent(attrName, expr, elementPath, context, selector) {
   if (elementPath.length !== 0 || !selector) return null;
-  if (attrName.startsWith("data-") || attrName === "class" || attrName === "className" || attrName === "style" || attrName === "id") return null;
+  if (attrName.startsWith("data-") || attrName === "class" || attrName === "className" || attrName === "style" || attrName === "id")
+    return null;
   const eventType = toGeaEventType(attrName);
   const directProp = resolvePropCallbackName(expr, context);
   if (directProp) return { eventType, propName: directProp, selector };
@@ -3215,12 +3675,7 @@ function buildClassObjectExpression(expr) {
           ),
           t9.identifier("map")
         ),
-        [
-          t9.arrowFunctionExpression(
-            [t9.arrayPattern([t9.identifier("__k")])],
-            t9.identifier("__k")
-          )
-        ]
+        [t9.arrowFunctionExpression([t9.arrayPattern([t9.identifier("__k")])], t9.identifier("__k"))]
       ),
       t9.identifier("join")
     ),
@@ -3257,10 +3712,10 @@ function buildStyleObjectExpression(expr) {
             t9.templateElement({ raw: "", cooked: "" }, true)
           ],
           [
-            t9.callExpression(
-              t9.memberExpression(t9.identifier("__k"), t9.identifier("replace")),
-              [t9.regExpLiteral("[A-Z]", "g"), t9.stringLiteral("-$&")]
-            ),
+            t9.callExpression(t9.memberExpression(t9.identifier("__k"), t9.identifier("replace")), [
+              t9.regExpLiteral("[A-Z]", "g"),
+              t9.stringLiteral("-$&")
+            ]),
             t9.conditionalExpression(
               t9.logicalExpression(
                 "&&",
@@ -3332,6 +3787,7 @@ function canBeBoolean(expr) {
 }
 function isAlwaysTruthy(expr) {
   if (t9.isStringLiteral(expr) || t9.isNumericLiteral(expr) || t9.isTemplateLiteral(expr)) return true;
+  if (t9.isObjectExpression(expr) || t9.isArrayExpression(expr)) return true;
   if (t9.isConditionalExpression(expr)) return isAlwaysTruthy(expr.consequent) && isAlwaysTruthy(expr.alternate);
   return false;
 }
@@ -3581,10 +4037,7 @@ function replaceJSXInExpression(node, mapJSXNodes, ctx) {
       );
     }
     const newBody = replaceJSXInExpression(callee.body, mapJSXNodes, ctx);
-    return t9.callExpression(
-      t9.arrowFunctionExpression(callee.params, newBody, callee.async),
-      node.arguments
-    );
+    return t9.callExpression(t9.arrowFunctionExpression(callee.params, newBody, callee.async), node.arguments);
   }
   return node;
 }
@@ -3962,21 +4415,27 @@ function processElement(node, parts, ctx, elementPath = []) {
             [t9.stringLiteral("; ")]
           );
           const skipCondition2 = buildAttrSkipCondition(styleExpr, rawExpr);
-          parts.push({
-            type: "expression",
-            value: t9.conditionalExpression(
-              skipCondition2,
-              t9.stringLiteral(""),
-              t9.templateLiteral(
-                [
-                  t9.templateElement({ raw: ' style="', cooked: ' style="' }, false),
-                  t9.templateElement({ raw: '"', cooked: '"' }, true)
-                ],
-                [styleExpr]
+          if (t9.isBooleanLiteral(skipCondition2) && !skipCondition2.value) {
+            parts.push({ type: "string", value: ` style="` });
+            parts.push({ type: "expression", value: styleExpr });
+            html = '"';
+          } else {
+            parts.push({
+              type: "expression",
+              value: t9.conditionalExpression(
+                skipCondition2,
+                t9.stringLiteral(""),
+                t9.templateLiteral(
+                  [
+                    t9.templateElement({ raw: ' style="', cooked: ' style="' }, false),
+                    t9.templateElement({ raw: '"', cooked: '"' }, true)
+                  ],
+                  [styleExpr]
+                )
               )
-            )
-          });
-          html = "";
+            });
+            html = "";
+          }
           return;
         }
         parts.push({ type: "string", value: html });
@@ -4209,16 +4668,7 @@ function ensureMapItemHelper(classBody2, ctx, helperName) {
     if (ctx.arrayPathParts.length === 0) return base;
     const [, ...rest] = ctx.arrayPathParts;
     const isIndex = /^\d+$/.test(first);
-    const optionalFirst = ctx.isImportedState ? t10.memberExpression(
-      base,
-      isIndex ? t10.numericLiteral(Number(first)) : t10.identifier(first),
-      isIndex
-    ) : t10.optionalMemberExpression(
-      base,
-      isIndex ? t10.numericLiteral(Number(first)) : t10.identifier(first),
-      isIndex,
-      true
-    );
+    const optionalFirst = ctx.isImportedState ? t10.memberExpression(base, isIndex ? t10.numericLiteral(Number(first)) : t10.identifier(first), isIndex) : t10.optionalMemberExpression(base, isIndex ? t10.numericLiteral(Number(first)) : t10.identifier(first), isIndex, true);
     return rest.length > 0 ? buildMemberChainFromParts(optionalFirst, rest) : optionalFirst;
   })();
   const findPredicate = ctx.itemIdProperty && ctx.itemIdProperty !== ITEM_IS_KEY ? t10.arrowFunctionExpression(
@@ -4239,7 +4689,11 @@ function ensureMapItemHelper(classBody2, ctx, helperName) {
     )
   ) : t10.arrowFunctionExpression(
     [t10.identifier("_"), t10.identifier("__i")],
-    t10.binaryExpression("===", t10.callExpression(t10.identifier("String"), [t10.identifier("__i")]), t10.identifier("__itemId"))
+    t10.binaryExpression(
+      "===",
+      t10.callExpression(t10.identifier("String"), [t10.identifier("__i")]),
+      t10.identifier("__itemId")
+    )
   );
   const method = jsMethod`${id3(helperName)}(e) {
     const __el = e.target.closest('[data-gea-item-id]');
@@ -4571,7 +5025,7 @@ function childHasNoProps(child) {
   return t11.isObjectExpression(child.propsExpression) && child.propsExpression.properties.length === 0;
 }
 var require7 = createRequire6(import.meta.url);
-var traverse5 = require7("@babel/traverse").default;
+var traverse6 = require7("@babel/traverse").default;
 function getDirectPropMappings(child, templatePropNames) {
   if (!child.propsExpression || !t11.isObjectExpression(child.propsExpression)) return null;
   const mappings = [];
@@ -4592,7 +5046,7 @@ function injectChildComponents(ast, componentInstances, directForwardingChildren
   const instanceStatements = buildInstanceStatements(constructionOrder, directForwardingChildren);
   const lazyChildren = constructionOrder.filter((child) => child.lazy);
   let injected = false;
-  traverse5(ast, {
+  traverse6(ast, {
     ClassDeclaration(path) {
       if (!t11.isIdentifier(path.node.superClass)) return;
       const existingCtor = path.node.body.body.find(
@@ -4671,7 +5125,7 @@ function injectChildComponents(ast, componentInstances, directForwardingChildren
   });
 }
 function injectComponentRegistrations(ast, componentInstances) {
-  traverse5(ast, {
+  traverse6(ast, {
     ClassMethod(path) {
       if (!t11.isIdentifier(path.node.key) || path.node.key.name !== "template") return;
       const registrations = Array.from(componentInstances.keys()).map(
@@ -4801,6 +5255,7 @@ function buildPropsBuilderMethod(child) {
 }
 
 // src/apply-reactivity.ts
+import babelGenerator from "@babel/generator";
 import * as t18 from "@babel/types";
 import { appendToBody as appendToBody5, id as id11, js as js7, jsBlockBody as jsBlockBody4, jsExpr as jsExpr4, jsMethod as jsMethod8 } from "eszter";
 
@@ -4813,7 +5268,7 @@ import * as t12 from "@babel/types";
 import { id as id5, js as js3, jsBlockBody as jsBlockBody2, jsExpr as jsExpr2 } from "eszter";
 import { createRequire as createRequire7 } from "module";
 var require8 = createRequire7(import.meta.url);
-var traverse6 = require8("@babel/traverse").default;
+var traverse7 = require8("@babel/traverse").default;
 function buildPathPartsEquals(expr, parts) {
   return parts.reduce(
     (acc, part, index) => t12.logicalExpression(
@@ -4859,10 +5314,7 @@ function buildValueExpression(textExpr, stateRefs) {
   }
   if (textExpr.isImportedState && textExpr.storeVar) {
     return buildMemberChainFromParts(
-      t12.memberExpression(
-        t12.identifier(textExpr.storeVar),
-        t12.identifier("__store")
-      ),
+      t12.memberExpression(t12.identifier(textExpr.storeVar), t12.identifier("__store")),
       textExpr.pathParts
     );
   }
@@ -4870,7 +5322,7 @@ function buildValueExpression(textExpr, stateRefs) {
 }
 function rewriteStateRefs(expr, stateRefs) {
   const prog = t12.program([t12.expressionStatement(expr)]);
-  traverse6(prog, {
+  traverse7(prog, {
     noScope: true,
     Identifier(path) {
       if (path.parentPath && t12.isMemberExpression(path.parentPath.node) && path.parentPath.node.property === path.node)
@@ -4888,17 +5340,10 @@ function rewriteStateRefs(expr, stateRefs) {
         );
         path.skip();
       } else if (ref.kind === "local-destructured" && ref.propName) {
-        path.replaceWith(
-          t12.memberExpression(t12.thisExpression(), t12.identifier(ref.propName))
-        );
+        path.replaceWith(t12.memberExpression(t12.thisExpression(), t12.identifier(ref.propName)));
         path.skip();
       } else {
-        path.replaceWith(
-          t12.memberExpression(
-            t12.identifier(path.node.name),
-            t12.identifier("__store")
-          )
-        );
+        path.replaceWith(t12.memberExpression(t12.identifier(path.node.name), t12.identifier("__store")));
         path.skip();
       }
     }
@@ -5080,7 +5525,7 @@ import * as t14 from "@babel/types";
 import { appendToBody as appendToBody2, id as id7, js as js4, jsMethod as jsMethod4 } from "eszter";
 import { createRequire as createRequire8 } from "module";
 var require9 = createRequire8(import.meta.url);
-var traverse7 = require9("@babel/traverse").default;
+var traverse8 = require9("@babel/traverse").default;
 var EVENT_NAMES = /* @__PURE__ */ new Set([
   "click",
   "dblclick",
@@ -5113,23 +5558,50 @@ var EVENT_NAMES = /* @__PURE__ */ new Set([
   "dragleave",
   "drop"
 ]);
-function collectItemTemplateProps(template, itemVar) {
-  const props = /* @__PURE__ */ new Set();
-  const program9 = t14.program([t14.expressionStatement(t14.cloneNode(template, true))]);
-  traverse7(program9, {
+function collectItemTemplatePropTree(template, itemVar) {
+  const tree = {};
+  const program10 = t14.program([t14.expressionStatement(t14.cloneNode(template, true))]);
+  traverse8(program10, {
     noScope: true,
     MemberExpression(path) {
-      if (!t14.isIdentifier(path.node.object, { name: itemVar })) return;
-      if (!t14.isIdentifier(path.node.property) || path.node.computed) return;
-      props.add(path.node.property.name);
+      const chain = [];
+      let node = path.node;
+      while (t14.isMemberExpression(node) && !node.computed && t14.isIdentifier(node.property)) {
+        chain.unshift(node.property.name);
+        node = node.object;
+      }
+      if (!t14.isIdentifier(node, { name: itemVar }) || chain.length === 0) return;
+      let cursor = tree;
+      for (let i = 0; i < chain.length; i++) {
+        const key = chain[i];
+        if (i === chain.length - 1) {
+          if (!(key in cursor)) cursor[key] = true;
+        } else {
+          if (!(key in cursor) || cursor[key] === true) cursor[key] = {};
+          cursor = cursor[key];
+        }
+      }
     }
   });
-  return Array.from(props);
+  return tree;
+}
+function buildDummyFromTree(tree, keyProp) {
+  const props = [];
+  for (const [key, value] of Object.entries(tree)) {
+    if (key === keyProp) {
+      props.push(t14.objectProperty(t14.identifier(key), t14.numericLiteral(0)));
+    } else if (value === true) {
+      props.push(t14.objectProperty(t14.identifier(key), t14.stringLiteral("")));
+    } else {
+      props.push(t14.objectProperty(t14.identifier(key), buildDummyFromTree(value, null)));
+    }
+  }
+  return t14.objectExpression(props);
 }
 function collectPatchEntries(arrayMap) {
   const cloned = t14.cloneNode(arrayMap.itemTemplate, true);
   const tempFile = t14.file(t14.program([t14.expressionStatement(cloned)]));
-  traverse7(tempFile, {
+  traverse8(tempFile, {
     Identifier(path) {
       if (path.node.name === arrayMap.itemVariable) path.node.name = "item";
       else if (arrayMap.indexVariable && path.node.name === arrayMap.indexVariable) path.node.name = "__idx";
@@ -5143,6 +5615,9 @@ function collectPatchEntries(arrayMap) {
     const rootIsComponent = isComponentTag(rootTagName);
     walkJSXForPatch(modified, [], entries, rootIsComponent);
   }
+  for (const ent of entries) {
+    ent.expression = optionalizeMemberChainsAfterComputedItemKey(ent.expression, "item");
+  }
   return { entries, requiresRerender };
 }
 function walkJSXForPatch(node, path, entries, rootIsComponent = false) {
@@ -5238,8 +5713,8 @@ function hoistStoreReads(entries, storeVar) {
   let counter = 0;
   function replaceStoreReads(expr) {
     const cloned = t14.cloneNode(expr, true);
-    const program9 = t14.program([t14.expressionStatement(cloned)]);
-    traverse7(program9, {
+    const program10 = t14.program([t14.expressionStatement(cloned)]);
+    traverse8(program10, {
       noScope: true,
       MemberExpression(path) {
         if (!t14.isIdentifier(path.node.object, { name: storeVar })) return;
@@ -5254,7 +5729,7 @@ function hoistStoreReads(entries, storeVar) {
         path.replaceWith(t14.identifier(hoist.varName));
       }
     });
-    return program9.body[0].expression;
+    return program10.body[0].expression;
   }
   const patchedEntries = entries.map((entry) => ({
     ...entry,
@@ -5294,7 +5769,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
     if (setupVarNames.size > 0) {
       const freeVars = /* @__PURE__ */ new Set();
       for (const entry of entries) {
-        traverse7(t14.expressionStatement(t14.cloneNode(entry.expression, true)), {
+        traverse8(t14.expressionStatement(t14.cloneNode(entry.expression, true)), {
           noScope: true,
           Identifier(p) {
             if (t14.isMemberExpression(p.parent) && p.parent.property === p.node && !p.parent.computed) return;
@@ -5347,7 +5822,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
         if (!t14.isJSXExpressionContainer(attr.value) || t14.isJSXEmptyExpression(attr.value.expression)) continue;
         const exprClone = t14.cloneNode(attr.value.expression, true);
         const tempProg = t14.file(t14.program([t14.expressionStatement(exprClone)]));
-        traverse7(tempProg, {
+        traverse8(tempProg, {
           Identifier(path) {
             if (path.node.name === arrayMap.itemVariable) path.node.name = "item";
             else if (arrayMap.indexVariable && path.node.name === arrayMap.indexVariable) path.node.name = "__idx";
@@ -5366,7 +5841,8 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
                 else if (t14.isObjectPattern(decl.id)) {
                   for (const prop of decl.id.properties) {
                     if (t14.isObjectProperty(prop) && t14.isIdentifier(prop.value)) setupVarNames.add(prop.value.name);
-                    else if (t14.isRestElement(prop) && t14.isIdentifier(prop.argument)) setupVarNames.add(prop.argument.name);
+                    else if (t14.isRestElement(prop) && t14.isIdentifier(prop.argument))
+                      setupVarNames.add(prop.argument.name);
                   }
                 }
               }
@@ -5374,7 +5850,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
           }
           const propsRefsFreeVars = /* @__PURE__ */ new Set();
           for (const prop of propsProperties) {
-            traverse7(t14.expressionStatement(t14.cloneNode(prop.value, true)), {
+            traverse8(t14.expressionStatement(t14.cloneNode(prop.value, true)), {
               noScope: true,
               Identifier(p) {
                 if (t14.isMemberExpression(p.parent) && p.parent.property === p.node && !p.parent.computed) return;
@@ -5394,7 +5870,11 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
             for (const stmt of templateSetupContext.statements) {
               let clonedStmt = t14.cloneNode(stmt, true);
               if (propRefsNames.size > 0 || wholeParamName) {
-                clonedStmt = replacePropRefsInExpression(clonedStmt, propRefsNames, wholeParamName);
+                clonedStmt = replacePropRefsInExpression(
+                  clonedStmt,
+                  propRefsNames,
+                  wholeParamName
+                );
               }
               rerenderBody.push(clonedStmt);
             }
@@ -5416,7 +5896,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
   }
   if (entries.length === 0) return null;
   const { hoists, patchedEntries } = hoistStoreReads(entries, arrayMap.storeVar);
-  const itemProps = collectItemTemplateProps(arrayMap.itemTemplate, arrayMap.itemVariable);
+  const propTree = collectItemTemplatePropTree(arrayMap.itemTemplate, arrayMap.itemVariable);
   const containerRef = t14.memberExpression(t14.thisExpression(), t14.identifier(containerProp));
   const cVar = t14.identifier("__c");
   const elVar = t14.identifier("el");
@@ -5424,25 +5904,16 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
   body.push(t14.variableDeclaration("var", [t14.variableDeclarator(cVar, containerRef)]));
   const isPrimitiveKey = !itemIdProperty || itemIdProperty === ITEM_IS_KEY;
   const dummyItem = isPrimitiveKey ? t14.stringLiteral("__dummy__") : (() => {
-    const dummyProps = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const prop of [itemIdProperty, ...itemProps]) {
-      if (seen.has(prop)) continue;
-      seen.add(prop);
-      dummyProps.push(
-        t14.objectProperty(t14.identifier(prop), prop === itemIdProperty ? t14.numericLiteral(0) : t14.stringLiteral(""))
-      );
-    }
-    return t14.objectExpression(dummyProps);
+    if (itemIdProperty && !(itemIdProperty in propTree)) propTree[itemIdProperty] = true;
+    return buildDummyFromTree(propTree, itemIdProperty);
   })();
   const tplInit = [
     t14.variableDeclaration("var", [
       t14.variableDeclarator(
         t14.identifier("__tw"),
-        t14.callExpression(
-          t14.memberExpression(t14.identifier("document"), t14.identifier("createElement")),
-          [t14.stringLiteral("template")]
-        )
+        t14.callExpression(t14.memberExpression(t14.identifier("document"), t14.identifier("createElement")), [
+          t14.stringLiteral("template")
+        ])
       )
     ]),
     t14.expressionStatement(
@@ -5508,10 +5979,9 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
         t14.variableDeclaration("var", [
           t14.variableDeclarator(
             t14.identifier("__fw"),
-            t14.callExpression(
-              t14.memberExpression(t14.identifier("document"), t14.identifier("createElement")),
-              [t14.stringLiteral("template")]
-            )
+            t14.callExpression(t14.memberExpression(t14.identifier("document"), t14.identifier("createElement")), [
+              t14.stringLiteral("template")
+            ])
           )
         ]),
         t14.expressionStatement(
@@ -5547,13 +6017,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
     const refName = childPathRefName(entry.childPath);
     const navExpr = buildElementNavExpr(elVar, entry.childPath);
     body.push(
-      t14.expressionStatement(
-        t14.assignmentExpression(
-          "=",
-          t14.memberExpression(elVar, t14.identifier(refName)),
-          navExpr
-        )
-      )
+      t14.expressionStatement(t14.assignmentExpression("=", t14.memberExpression(elVar, t14.identifier(refName)), navExpr))
     );
     refMap.set(key, t14.memberExpression(elVar, t14.identifier(refName)));
   }
@@ -5600,17 +6064,26 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
                       t14.memberExpression(
                         t14.callExpression(
                           t14.memberExpression(
-                            t14.callExpression(t14.memberExpression(t14.identifier("Object"), t14.identifier("entries")), [attrVal]),
+                            t14.callExpression(t14.memberExpression(t14.identifier("Object"), t14.identifier("entries")), [
+                              attrVal
+                            ]),
                             t14.identifier("map")
                           ),
                           [
                             t14.arrowFunctionExpression(
                               [t14.arrayPattern([t14.identifier("k"), t14.identifier("v")])],
-                              t14.binaryExpression("+", t14.binaryExpression(
+                              t14.binaryExpression(
                                 "+",
-                                t14.callExpression(t14.memberExpression(t14.identifier("k"), t14.identifier("replace")), [t14.regExpLiteral("[A-Z]", "g"), t14.stringLiteral("-$&")]),
-                                t14.stringLiteral(": ")
-                              ), t14.identifier("v"))
+                                t14.binaryExpression(
+                                  "+",
+                                  t14.callExpression(t14.memberExpression(t14.identifier("k"), t14.identifier("replace")), [
+                                    t14.regExpLiteral("[A-Z]", "g"),
+                                    t14.stringLiteral("-$&")
+                                  ]),
+                                  t14.stringLiteral(": ")
+                                ),
+                                t14.identifier("v")
+                              )
                             )
                           ]
                         ),
@@ -5686,7 +6159,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
       if (!t14.isJSXExpressionContainer(attr.value) || t14.isJSXEmptyExpression(attr.value.expression)) continue;
       const exprClone = t14.cloneNode(attr.value.expression, true);
       const tempProg = t14.file(t14.program([t14.expressionStatement(exprClone)]));
-      traverse7(tempProg, {
+      traverse8(tempProg, {
         Identifier(path) {
           if (path.node.name === arrayMap.itemVariable) path.node.name = "item";
           else if (arrayMap.indexVariable && path.node.name === arrayMap.indexVariable) path.node.name = "__idx";
@@ -5721,7 +6194,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
 }
 function templateRequiresRerender(file2) {
   let requiresRerender = false;
-  traverse7(file2, {
+  traverse8(file2, {
     noScope: true,
     ConditionalExpression(path) {
       if (branchContainsJSX(path.node.consequent) || branchContainsJSX(path.node.alternate)) {
@@ -5740,8 +6213,8 @@ function templateRequiresRerender(file2) {
 }
 function branchContainsJSX(expr) {
   let containsJSX = false;
-  const program9 = t14.program([t14.expressionStatement(t14.cloneNode(expr, true))]);
-  traverse7(program9, {
+  const program10 = t14.program([t14.expressionStatement(t14.cloneNode(expr, true))]);
+  traverse8(program10, {
     noScope: true,
     JSXElement(path) {
       containsJSX = true;
@@ -5758,7 +6231,7 @@ function branchContainsJSX(expr) {
 // src/generate-array.ts
 import { createRequire as createRequire9 } from "module";
 var require10 = createRequire9(import.meta.url);
-var traverse8 = require10("@babel/traverse").default;
+var traverse9 = require10("@babel/traverse").default;
 function getArrayPathParts(arrayMap) {
   return arrayMap.arrayPathParts || normalizePathParts(arrayMap.arrayPath || "");
 }
@@ -5827,22 +6300,35 @@ function buildPropPatcherFunction(binding, propName) {
         "=",
         t15.memberExpression(t15.memberExpression(target, t15.identifier("style")), t15.identifier("cssText")),
         t15.conditionalExpression(
-          t15.binaryExpression("===", t15.unaryExpression("typeof", t15.identifier("__attrValue")), t15.stringLiteral("object")),
+          t15.binaryExpression(
+            "===",
+            t15.unaryExpression("typeof", t15.identifier("__attrValue")),
+            t15.stringLiteral("object")
+          ),
           t15.callExpression(
             t15.memberExpression(
               t15.callExpression(
                 t15.memberExpression(
-                  t15.callExpression(t15.memberExpression(t15.identifier("Object"), t15.identifier("entries")), [t15.identifier("__attrValue")]),
+                  t15.callExpression(t15.memberExpression(t15.identifier("Object"), t15.identifier("entries")), [
+                    t15.identifier("__attrValue")
+                  ]),
                   t15.identifier("map")
                 ),
                 [
                   t15.arrowFunctionExpression(
                     [t15.arrayPattern([t15.identifier("k"), t15.identifier("v")])],
-                    t15.binaryExpression("+", t15.binaryExpression(
+                    t15.binaryExpression(
                       "+",
-                      t15.callExpression(t15.memberExpression(t15.identifier("k"), t15.identifier("replace")), [t15.regExpLiteral("[A-Z]", "g"), t15.stringLiteral("-$&")]),
-                      t15.stringLiteral(": ")
-                    ), t15.identifier("v"))
+                      t15.binaryExpression(
+                        "+",
+                        t15.callExpression(t15.memberExpression(t15.identifier("k"), t15.identifier("replace")), [
+                          t15.regExpLiteral("[A-Z]", "g"),
+                          t15.stringLiteral("-$&")
+                        ]),
+                        t15.stringLiteral(": ")
+                      ),
+                      t15.identifier("v")
+                    )
                   )
                 ]
               ),
@@ -5908,8 +6394,8 @@ function buildPropPatcherFunction(binding, propName) {
 }
 function collectItemExpressionKeys(expr) {
   const keys = /* @__PURE__ */ new Set();
-  const program9 = t15.program([t15.expressionStatement(t15.cloneNode(expr, true))]);
-  traverse8(program9, {
+  const program10 = t15.program([t15.expressionStatement(t15.cloneNode(expr, true))]);
+  traverse9(program10, {
     noScope: true,
     MemberExpression(path) {
       if (!t15.isIdentifier(path.node.object, { name: "item" })) return;
@@ -5951,22 +6437,35 @@ function buildPatchEntryPropPatcher(entry) {
         "=",
         t15.memberExpression(t15.memberExpression(target, t15.identifier("style")), t15.identifier("cssText")),
         t15.conditionalExpression(
-          t15.binaryExpression("===", t15.unaryExpression("typeof", t15.identifier("__attrValue")), t15.stringLiteral("object")),
+          t15.binaryExpression(
+            "===",
+            t15.unaryExpression("typeof", t15.identifier("__attrValue")),
+            t15.stringLiteral("object")
+          ),
           t15.callExpression(
             t15.memberExpression(
               t15.callExpression(
                 t15.memberExpression(
-                  t15.callExpression(t15.memberExpression(t15.identifier("Object"), t15.identifier("entries")), [t15.identifier("__attrValue")]),
+                  t15.callExpression(t15.memberExpression(t15.identifier("Object"), t15.identifier("entries")), [
+                    t15.identifier("__attrValue")
+                  ]),
                   t15.identifier("map")
                 ),
                 [
                   t15.arrowFunctionExpression(
                     [t15.arrayPattern([t15.identifier("k"), t15.identifier("v")])],
-                    t15.binaryExpression("+", t15.binaryExpression(
+                    t15.binaryExpression(
                       "+",
-                      t15.callExpression(t15.memberExpression(t15.identifier("k"), t15.identifier("replace")), [t15.regExpLiteral("[A-Z]", "g"), t15.stringLiteral("-$&")]),
-                      t15.stringLiteral(": ")
-                    ), t15.identifier("v"))
+                      t15.binaryExpression(
+                        "+",
+                        t15.callExpression(t15.memberExpression(t15.identifier("k"), t15.identifier("replace")), [
+                          t15.regExpLiteral("[A-Z]", "g"),
+                          t15.stringLiteral("-$&")
+                        ]),
+                        t15.stringLiteral(": ")
+                      ),
+                      t15.identifier("v")
+                    )
                   )
                 ]
               ),
@@ -6199,10 +6698,7 @@ function generateArrayConditionalPatchObserver(arrayMap, bindings, methodName) {
   const containerName = `__${arrayPath.replace(/\./g, "_")}_container`;
   const containerRef = t15.memberExpression(t15.thisExpression(), t15.identifier(containerName));
   const proxiedArr = arrayMap.isImportedState ? buildMemberChain(
-    t15.memberExpression(
-      t15.identifier(arrayMap.storeVar || "store"),
-      t15.identifier("__store")
-    ),
+    t15.memberExpression(t15.identifier(arrayMap.storeVar || "store"), t15.identifier("__store")),
     arrayPath
   ) : buildMemberChain(t15.thisExpression(), arrayPath);
   const rawArrExpr = t15.logicalExpression(
@@ -6260,10 +6756,7 @@ function generateArrayConditionalRerenderObserver(arrayMap, methodName) {
   const containerRef = t15.memberExpression(t15.thisExpression(), t15.identifier(containerName));
   const configRef = t15.memberExpression(t15.thisExpression(), t15.identifier(getArrayConfigPropName(arrayMap)));
   const proxiedArr = arrayMap.isImportedState ? buildMemberChain(
-    t15.memberExpression(
-      t15.identifier(arrayMap.storeVar || "store"),
-      t15.identifier("__store")
-    ),
+    t15.memberExpression(t15.identifier(arrayMap.storeVar || "store"), t15.identifier("__store")),
     arrayPath
   ) : buildMemberChain(t15.thisExpression(), arrayPath);
   const rawArrExpr = t15.logicalExpression(
@@ -6407,14 +6900,14 @@ function buildConditionalPatchStatement(binding, target, itemVariable) {
 }
 function renameItemVariable(expr, itemVariable) {
   const cloned = t15.cloneNode(expr, true);
-  const program9 = t15.program([t15.expressionStatement(cloned)]);
-  traverse8(program9, {
+  const program10 = t15.program([t15.expressionStatement(cloned)]);
+  traverse9(program10, {
     noScope: true,
     Identifier(path) {
       if (path.node.name === itemVariable) path.node.name = "item";
     }
   });
-  return program9.body[0].expression;
+  return program10.body[0].expression;
 }
 function buildRelationalClassStatements(rowExpr, bindings, isMatch, phase) {
   return bindings.flatMap((binding, index) => {
@@ -6681,7 +7174,8 @@ function unwrapComparisonOperands(node) {
 }
 function generateRenderItemMethod(arrayMap, imports, eventHandlers, eventIdCounter, classBody2, templateSetupContext) {
   const renderEventHandlers = [];
-  if (!arrayMap.itemTemplate) return { method: null, handlers: renderEventHandlers, handlerPropsInMap: [], needsUnwrapHelper: false };
+  if (!arrayMap.itemTemplate)
+    return { method: null, handlers: renderEventHandlers, handlerPropsInMap: [], needsUnwrapHelper: false };
   const arrayPath = pathPartsToString(arrayMap.arrayPathParts || normalizePathParts(arrayMap.arrayPath || ""));
   const modified = t16.cloneNode(arrayMap.itemTemplate, true);
   const handlerPropsInMap = [];
@@ -6719,8 +7213,12 @@ function generateRenderItemMethod(arrayMap, imports, eventHandlers, eventIdCount
       wholeParam = templateMethod.params[0].name;
     }
   }
+  const itemKey = arrayMap.itemVariable;
   wrapped.expressions = wrapped.expressions.map(
-    (expr) => replacePropRefsInExpression(unwrapComparisonOperands(expr), propNames, wholeParam)
+    (expr) => optionalizeMemberChainsAfterComputedItemKey(
+      replacePropRefsInExpression(unwrapComparisonOperands(expr), propNames, wholeParam),
+      itemKey
+    )
   );
   const handlerRegStmts = buildHandlerRegistrationStatements(
     handlerPropsInMap,
@@ -6734,8 +7232,14 @@ function generateRenderItemMethod(arrayMap, imports, eventHandlers, eventIdCount
     t16.expressionStatement(wrapped)
   ]) : wrapped;
   const setupStmts = collectTemplateSetupStatements(setupScope, templateSetupContext);
-  const rewrittenSetup = setupStmts.map((stmt) => replacePropRefsInStatements([t16.cloneNode(stmt, true)], propNames, wholeParam)).flat();
-  const rewrittenCallbackBody = callbackBodyStmts.map((stmt) => replacePropRefsInStatements([t16.cloneNode(stmt, true)], propNames, wholeParam)).flat();
+  const rewrittenSetup = optionalizeComputedItemKeyInStatements(
+    setupStmts.map((stmt) => replacePropRefsInStatements([t16.cloneNode(stmt, true)], propNames, wholeParam)).flat(),
+    itemKey
+  );
+  const rewrittenCallbackBody = optionalizeComputedItemKeyInStatements(
+    callbackBodyStmts.map((stmt) => replacePropRefsInStatements([t16.cloneNode(stmt, true)], propNames, wholeParam)).flat(),
+    itemKey
+  );
   const baseMethod = jsMethod6`${id9(methodName)}(${id9(arrayMap.itemVariable)}) {}`;
   if (arrayMap.indexVariable) {
     baseMethod.params.push(t16.identifier(arrayMap.indexVariable));
@@ -6756,13 +7260,7 @@ function generateRenderItemMethod(arrayMap, imports, eventHandlers, eventIdCount
     return false;
   }
   const needsUnwrapHelper = [...rewrittenCallbackBody, returnStmt].some((stmt) => containsVCall(stmt));
-  const method = appendToBody4(
-    baseMethod,
-    ...rewrittenSetup,
-    ...rewrittenCallbackBody,
-    ...handlerRegStmts,
-    returnStmt
-  );
+  const method = appendToBody4(baseMethod, ...rewrittenSetup, ...rewrittenCallbackBody, ...handlerRegStmts, returnStmt);
   if (handlerPropsInMap.length > 0 && classBody2) {
     const handleItemHandler = jsMethod6`__handleItemHandler(itemId, e) {
     const fn = this.__itemHandlers_?.[itemId];
@@ -6790,7 +7288,7 @@ import * as t17 from "@babel/types";
 import { id as id10, jsMethod as jsMethod7 } from "eszter";
 import { createRequire as createRequire10 } from "module";
 var require11 = createRequire10(import.meta.url);
-var traverse9 = require11("@babel/traverse").default;
+var traverse10 = require11("@babel/traverse").default;
 function isUnresolvedMapWithComponentChild(um, imports) {
   const template = um.itemTemplate;
   if (!template) return null;
@@ -6844,7 +7342,7 @@ function generateComponentArrayResult(um, arrayPropName, imports, propNames, _cl
   let finalPropsExpr = propsExpr;
   if (needsRename || needsIndexRename) {
     const cloned = t17.cloneNode(propsExpr, true);
-    traverse9(cloned, {
+    traverse10(cloned, {
       noScope: true,
       Identifier(path) {
         if (needsRename && path.node.name === itemVar) {
@@ -6928,27 +7426,17 @@ function generateComponentArrayResult(um, arrayPropName, imports, propNames, _cl
   const keyExpr = itemIdProp && itemIdProp !== ITEM_IS_KEY ? t17.callExpression(t17.identifier("String"), [t17.memberExpression(t17.identifier("opt"), t17.identifier(itemIdProp))]) : itemIdProp === ITEM_IS_KEY ? t17.callExpression(t17.identifier("String"), [t17.identifier("opt")]) : t17.binaryExpression("+", t17.stringLiteral("__idx_"), t17.identifier("__k"));
   const mapParams = [t17.identifier("opt")];
   if (indexVar || !itemIdProp) mapParams.push(t17.identifier("__k"));
-  const childCall = t17.callExpression(
-    t17.memberExpression(t17.thisExpression(), t17.identifier("__child")),
-    [
-      t17.identifier(comp.componentTag),
-      t17.cloneNode(itemPropsCall, true),
-      t17.cloneNode(keyExpr, true)
-    ]
-  );
+  const childCall = t17.callExpression(t17.memberExpression(t17.thisExpression(), t17.identifier("__child")), [
+    t17.identifier(comp.componentTag),
+    t17.cloneNode(itemPropsCall, true),
+    t17.cloneNode(keyExpr, true)
+  ]);
   const mapCallback = t17.arrowFunctionExpression(mapParams, childCall);
   const nullishCoalesce = t17.logicalExpression("??", t17.cloneNode(arrAccessExpr, true), t17.arrayExpression([]));
   const parenthesized = t17.parenthesizedExpression ? t17.parenthesizedExpression(nullishCoalesce) : nullishCoalesce;
-  const mapCallExpr = t17.callExpression(
-    t17.memberExpression(parenthesized, t17.identifier("map")),
-    [mapCallback]
-  );
+  const mapCallExpr = t17.callExpression(t17.memberExpression(parenthesized, t17.identifier("map")), [mapCallback]);
   const constructorInit = t17.expressionStatement(
-    t17.assignmentExpression(
-      "=",
-      t17.memberExpression(t17.thisExpression(), t17.identifier(itemsName)),
-      mapCallExpr
-    )
+    t17.assignmentExpression("=", t17.memberExpression(t17.thisExpression(), t17.identifier(itemsName)), mapCallExpr)
   );
   return {
     itemPropsMethod,
@@ -6963,8 +7451,9 @@ function generateComponentArrayResult(um, arrayPropName, imports, propNames, _cl
 
 // src/apply-reactivity.ts
 import { createRequire as createRequire11 } from "module";
+var generate2 = "default" in babelGenerator ? babelGenerator.default : babelGenerator;
 var require12 = createRequire11(import.meta.url);
-var traverse10 = require12("@babel/traverse").default;
+var traverse11 = require12("@babel/traverse").default;
 var BOOLEAN_HTML_ATTRS = /* @__PURE__ */ new Set([
   "disabled",
   "hidden",
@@ -7010,14 +7499,11 @@ function generateCreatedHooks(stores, hasArrayConfigs, observeListConfigs = [])
       if (handlers.length === 1 && !handlers[0].isVia) {
         body.push(
           t18.expressionStatement(
-            t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")),
-              [
-                storeVarExpr,
-                pathArray,
-                t18.memberExpression(t18.thisExpression(), t18.identifier(handlers[0].methodName))
-              ]
-            )
+            t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")), [
+              storeVarExpr,
+              pathArray,
+              t18.memberExpression(t18.thisExpression(), t18.identifier(handlers[0].methodName))
+            ])
           )
         );
       } else {
@@ -7028,36 +7514,27 @@ function generateCreatedHooks(stores, hasArrayConfigs, observeListConfigs = [])
           if (h.isVia && h.rereadExpr) {
             callStmts.push(
               t18.expressionStatement(
-                t18.callExpression(
-                  t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)),
-                  [t18.cloneNode(h.rereadExpr, true), t18.nullLiteral()]
-                )
+                t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)), [
+                  t18.cloneNode(h.rereadExpr, true),
+                  t18.nullLiteral()
+                ])
               )
             );
           } else {
             callStmts.push(
               t18.expressionStatement(
-                t18.callExpression(
-                  t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)),
-                  [vParam, cParam]
-                )
+                t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)), [vParam, cParam])
               )
             );
           }
         }
         body.push(
           t18.expressionStatement(
-            t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")),
-              [
-                storeVarExpr,
-                pathArray,
-                t18.arrowFunctionExpression(
-                  [vParam, cParam],
-                  t18.blockStatement(callStmts)
-                )
-              ]
-            )
+            t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")), [
+              storeVarExpr,
+              pathArray,
+              t18.arrowFunctionExpression([vParam, cParam], t18.blockStatement(callStmts))
+            ])
           )
         );
       }
@@ -7067,22 +7544,15 @@ function generateCreatedHooks(stores, hasArrayConfigs, observeListConfigs = [])
       const itemsName = getComponentArrayItemsName(config.arrayPropName);
       const itemPropsMethodName = `__itemProps_${config.arrayPropName}`;
       const configProps = [
-        t18.objectProperty(
-          t18.identifier("items"),
-          t18.memberExpression(t18.thisExpression(), t18.identifier(itemsName))
-        ),
-        t18.objectProperty(
-          t18.identifier("itemsKey"),
-          t18.stringLiteral(itemsName)
-        ),
+        t18.objectProperty(t18.identifier("items"), t18.memberExpression(t18.thisExpression(), t18.identifier(itemsName))),
+        t18.objectProperty(t18.identifier("itemsKey"), t18.stringLiteral(itemsName)),
         t18.objectProperty(
           t18.identifier("container"),
           t18.arrowFunctionExpression(
             [],
-            config.containerBindingId ? t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier("__el")),
-              [t18.stringLiteral(config.containerBindingId)]
-            ) : jsExpr4`this.$(":scope")`
+            config.containerBindingId ? t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__el")), [
+              t18.stringLiteral(config.containerBindingId)
+            ]) : jsExpr4`this.$(":scope")`
           )
         ),
         t18.objectProperty(t18.identifier("Ctor"), t18.identifier(config.componentTag)),
@@ -7090,10 +7560,10 @@ function generateCreatedHooks(stores, hasArrayConfigs, observeListConfigs = [])
           t18.identifier("props"),
           t18.arrowFunctionExpression(
             [t18.identifier("opt"), t18.identifier("__k")],
-            t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier(itemPropsMethodName)),
-              [t18.identifier("opt"), t18.identifier("__k")]
-            )
+            t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(itemPropsMethodName)), [
+              t18.identifier("opt"),
+              t18.identifier("__k")
+            ])
           )
         ),
         t18.objectProperty(
@@ -7117,31 +7587,26 @@ function generateCreatedHooks(stores, hasArrayConfigs, observeListConfigs = [])
       if (samePathHandlers.length > 0) {
         const onchangeStmts = samePathHandlers.map(
           (h) => t18.expressionStatement(
-            h.isVia && h.rereadExpr ? t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)),
-              [t18.cloneNode(h.rereadExpr, true), t18.nullLiteral()]
-            ) : t18.callExpression(
-              t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)),
-              [
-                t18.memberExpression(t18.identifier(config.storeVar), t18.identifier(config.pathParts[0])),
-                t18.nullLiteral()
-              ]
-            )
+            h.isVia && h.rereadExpr ? t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)), [
+              t18.cloneNode(h.rereadExpr, true),
+              t18.nullLiteral()
+            ]) : t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(h.methodName)), [
+              t18.memberExpression(t18.identifier(config.storeVar), t18.identifier(config.pathParts[0])),
+              t18.nullLiteral()
+            ])
           )
         );
         configProps.push(
-          t18.objectProperty(
-            t18.identifier("onchange"),
-            t18.arrowFunctionExpression([], t18.blockStatement(onchangeStmts))
-          )
+          t18.objectProperty(t18.identifier("onchange"), t18.arrowFunctionExpression([], t18.blockStatement(onchangeStmts)))
         );
       }
       body.push(
         t18.expressionStatement(
-          t18.callExpression(
-            t18.memberExpression(t18.thisExpression(), t18.identifier("__observeList")),
-            [storeVarExpr, pathArray, t18.objectExpression(configProps)]
-          )
+          t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__observeList")), [
+            storeVarExpr,
+            pathArray,
+            t18.objectExpression(configProps)
+          ])
         )
       );
     }
@@ -7160,14 +7625,11 @@ function generateLocalStateObserverSetup(observeHandlers, hasArrayConfigs) {
   for (const observeHandler of observeHandlers) {
     body.push(
       t18.expressionStatement(
-        t18.callExpression(
-          t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")),
-          [
-            t18.thisExpression(),
-            t18.arrayExpression(observeHandler.pathParts.map((part) => t18.stringLiteral(part))),
-            t18.memberExpression(t18.thisExpression(), t18.identifier(observeHandler.methodName))
-          ]
-        )
+        t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__observe")), [
+          t18.thisExpression(),
+          t18.arrayExpression(observeHandler.pathParts.map((part) => t18.stringLiteral(part))),
+          t18.memberExpression(t18.thisExpression(), t18.identifier(observeHandler.methodName))
+        ])
       )
     );
   }
@@ -7185,7 +7647,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
     const classBody2 = t18.isClassBody(origPath.parent) ? origPath.parent : void 0;
     return analyzeTemplate(origPath.node, stateRefs, classBody2);
   };
-  traverse10(astToTraverse, {
+  traverse11(astToTraverse, {
     ClassMethod(origPath) {
       if (!t18.isIdentifier(origPath.node.key) || origPath.node.key.name !== "template") return;
       const analysis = getAnalysis(className, origPath);
@@ -7193,7 +7655,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
       const hasCompiledChildStoreDeps = compiledChildren.some((child) => child.dependencies.some((dep) => dep.storeVar));
       if (analysis.bindings.length === 0 && analysis.propBindings.length === 0 && analysis.arrayMaps.length === 0 && analysis.stateProps.size === 0 && analysis.unresolvedMaps.length === 0 && !hasCompiledChildStoreDeps)
         return;
-      traverse10(ast, {
+      traverse11(ast, {
         ClassDeclaration(classPath) {
           if (!t18.isIdentifier(classPath.node.id) || classPath.node.id.name !== className) return;
           const templateMethod = classPath.node.body.body.find(
@@ -7225,7 +7687,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             }
             if (renameMap.size === 0) return bodyStatements;
             const tempProgram = t18.program(bodyStatements);
-            traverse10(tempProgram, {
+            traverse11(tempProgram, {
               noScope: true,
               Identifier(path) {
                 const nextName = renameMap.get(path.node.name);
@@ -7343,10 +7805,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                     t18.memberExpression(
                       t18.callExpression(
                         t18.memberExpression(
-                          t18.callExpression(
-                            t18.memberExpression(t18.identifier("Object"), t18.identifier("entries")),
-                            [t18.cloneNode(valueExpr, true)]
-                          ),
+                          t18.callExpression(t18.memberExpression(t18.identifier("Object"), t18.identifier("entries")), [
+                            t18.cloneNode(valueExpr, true)
+                          ]),
                           t18.identifier("filter")
                         ),
                         [
@@ -7358,12 +7819,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                       ),
                       t18.identifier("map")
                     ),
-                    [
-                      t18.arrowFunctionExpression(
-                        [t18.arrayPattern([t18.identifier("__k")])],
-                        t18.identifier("__k")
-                      )
-                    ]
+                    [t18.arrowFunctionExpression([t18.arrayPattern([t18.identifier("__k")])], t18.identifier("__k"))]
                   ),
                   t18.identifier("join")
                 ),
@@ -7374,9 +7830,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                 t18.stringLiteral("")
               );
               updateStmt = t18.blockStatement([
-                t18.variableDeclaration("const", [
-                  t18.variableDeclarator(t18.identifier("__newClass"), classValueExpr)
-                ]),
+                t18.variableDeclaration("const", [t18.variableDeclarator(t18.identifier("__newClass"), classValueExpr)]),
                 t18.ifStatement(
                   t18.binaryExpression(
                     "!==",
@@ -7493,22 +7947,35 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             } else {
               continue;
             }
-            const blockStatements = [
-              t18.variableDeclaration("const", [t18.variableDeclarator(t18.identifier("__el"), elExpr)])
-            ];
-            if (pb.expression && pb.setupStatements) {
+            const useDerivedPropExpr = Boolean(pb.expression && pb.setupStatements);
+            const elDecl = t18.variableDeclaration("const", [t18.variableDeclarator(t18.identifier("__el"), elExpr)]);
+            const corePatch = [elDecl];
+            let derivedRewrittenExpr;
+            let derivedPrunedSetup = [];
+            if (useDerivedPropExpr) {
               const rewrittenSetup = replacePropRefsInStatements(
                 pb.setupStatements,
                 templatePropNames,
                 templateWholeParam
               );
-              const rewrittenExpr = replacePropRefsInExpression(pb.expression, templatePropNames, templateWholeParam);
-              blockStatements.push(...pruneDeadParamDestructuring(rewrittenSetup, [rewrittenExpr]));
-              blockStatements.push(
+              let rewrittenExpr = replacePropRefsInExpression(pb.expression, templatePropNames, templateWholeParam);
+              rewrittenExpr = replaceThisPropsRootWithValueParam(rewrittenExpr, pb.propName);
+              derivedRewrittenExpr = rewrittenExpr;
+              derivedPrunedSetup = pruneDeadParamDestructuring(rewrittenSetup, [rewrittenExpr]);
+              corePatch.push(...derivedPrunedSetup);
+              corePatch.push(
                 t18.variableDeclaration("const", [t18.variableDeclarator(t18.identifier("__boundValue"), rewrittenExpr)])
               );
             }
-            blockStatements.push(t18.ifStatement(t18.identifier("__el"), updateStmt));
+            corePatch.push(t18.ifStatement(t18.identifier("__el"), updateStmt));
+            const nullishValue = t18.logicalExpression(
+              "||",
+              t18.binaryExpression("===", t18.identifier("value"), t18.nullLiteral()),
+              t18.binaryExpression("===", t18.identifier("value"), t18.identifier("undefined"))
+            );
+            const guardsNullishInExpr = Boolean(derivedRewrittenExpr) && derivedExprGuardsValueWhenNullish(derivedRewrittenExpr);
+            const needsValueNullishGuard = useDerivedPropExpr && !guardsNullishInExpr && expressionAccessesValueProperties(derivedRewrittenExpr, derivedPrunedSetup);
+            const blockStatements = needsValueNullishGuard ? [t18.ifStatement(t18.unaryExpression("!", nullishValue), t18.blockStatement(corePatch))] : corePatch;
             patchStatementsByBinding.set(pb, blockStatements);
             applied = true;
           }
@@ -7554,7 +8021,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               }
               bindings.add(pb);
             };
-            traverse10(scanProg, {
+            traverse11(scanProg, {
               noScope: true,
               Identifier(path) {
                 if (path.parentPath && t18.isMemberExpression(path.parentPath.node) && path.parentPath.node.object === path.node)
@@ -7588,9 +8055,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             if (!hasStateOnly) continue;
             for (const pb of bindings) {
               if (pb.stateOnly) continue;
-              const dup = [...bindings].some(
-                (b) => b.stateOnly && b.selector === pb.selector && b.type === pb.type
-              );
+              const dup = [...bindings].some((b) => b.stateOnly && b.selector === pb.selector && b.type === pb.type);
               if (dup) bindings.delete(pb);
             }
           }
@@ -7600,9 +8065,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
           if (analysis.earlyReturnGuard) {
             const guardExpr = analysis.earlyReturnGuard;
             const localToStoreExpr = /* @__PURE__ */ new Map();
-            const setupStmts = templateMethod?.body.body.filter(
-              (s) => t18.isVariableDeclaration(s)
-            ) || [];
+            const setupStmts = templateMethod?.body.body.filter((s) => t18.isVariableDeclaration(s)) || [];
             for (const decl of setupStmts) {
               for (const d of decl.declarations) {
                 if (t18.isIdentifier(d.id) && t18.isMemberExpression(d.init)) {
@@ -7619,19 +8082,14 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                 rerenderStoreKeys.push({ observeKey: key, pathParts: parts });
               }
             };
-            const guardScanProg = t18.program([
-              t18.expressionStatement(t18.cloneNode(guardExpr, true))
-            ]);
-            traverse10(guardScanProg, {
+            const guardScanProg = t18.program([t18.expressionStatement(t18.cloneNode(guardExpr, true))]);
+            traverse11(guardScanProg, {
               noScope: true,
               MemberExpression(path) {
                 const resolved = resolvePath(path.node, stateRefs);
                 if (!resolved?.parts?.length) return;
                 if (resolved.isImportedState || resolved.storeVar) {
-                  addRerenderDep(
-                    resolved.parts,
-                    resolved.isImportedState ? resolved.storeVar : void 0
-                  );
+                  addRerenderDep(resolved.parts, resolved.isImportedState ? resolved.storeVar : void 0);
                 }
               },
               Identifier(path) {
@@ -7661,7 +8119,8 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               const parsed = JSON.parse(entry.observeKey);
               const storeVarName = parsed.storeVar || void 0;
               const methodNameStr = getObserveMethodName(propPath, storeVarName);
-              const rerenderMethod = jsMethod8`${id11(methodNameStr)}(__v, __c) { this.__rerender(); }`;
+              const prevProp = `__geaPrev_guard_${methodNameStr}`;
+              const rerenderMethod = jsMethod8`${id11(methodNameStr)}(__v, __c) { if (!__v === !this.${id11(prevProp)}) return; this.${id11(prevProp)} = __v; this.__geaRequestRender(); }`;
               mergeObserveMethod(entry.observeKey, rerenderMethod);
               if (!stateProps.has(entry.observeKey)) {
                 stateProps.set(entry.observeKey, entry.pathParts);
@@ -7675,6 +8134,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
           const componentArrayMountMethods = [];
           const storeComponentArrayObservers = [];
           const observeListConfigs = [];
+          const staticArrayRefreshOnMount = [];
           const mapItemAttrInfos = [];
           const tmplBody = templateMethod?.body.body ?? [];
           let tmplReturnIdx = -1;
@@ -7747,10 +8207,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   const itemsName = getComponentArrayItemsName(arrayPropName);
                   const itemPropsMethodNameRef = `__itemProps_${arrayPropName}`;
                   const containerSuffix = arrayResult.containerBindingId;
-                  const containerExpr = containerSuffix ? t18.callExpression(
-                    t18.memberExpression(t18.thisExpression(), t18.identifier("__el")),
-                    [t18.stringLiteral(containerSuffix)]
-                  ) : jsExpr4`this.$(":scope")`;
+                  const containerExpr = containerSuffix ? t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__el")), [
+                    t18.stringLiteral(containerSuffix)
+                  ]) : jsExpr4`this.$(":scope")`;
                   const itemIdProp = arrayResult.itemIdProperty;
                   const keyFn = itemIdProp && itemIdProp !== ITEM_IS_KEY ? t18.arrowFunctionExpression(
                     [t18.identifier("opt")],
@@ -7768,29 +8227,30 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                       t18.variableDeclaration("const", [
                         t18.variableDeclarator(
                           t18.identifier("__arr"),
-                          t18.logicalExpression("??", t18.cloneNode(arrayResult.arrAccessExpr, true), t18.arrayExpression([]))
+                          t18.logicalExpression(
+                            "??",
+                            t18.cloneNode(arrayResult.arrAccessExpr, true),
+                            t18.arrayExpression([])
+                          )
                         )
                       ]),
                       t18.variableDeclaration("const", [
                         t18.variableDeclarator(
                           t18.identifier("__new"),
-                          t18.callExpression(
-                            t18.memberExpression(t18.thisExpression(), t18.identifier("__reconcileList")),
-                            [
-                              t18.memberExpression(t18.thisExpression(), t18.identifier(itemsName)),
-                              t18.identifier("__arr"),
-                              t18.cloneNode(containerExpr, true),
-                              t18.identifier(arrayResult.componentTag),
-                              t18.arrowFunctionExpression(
-                                [t18.identifier("opt")],
-                                t18.callExpression(
-                                  t18.memberExpression(t18.thisExpression(), t18.identifier(itemPropsMethodNameRef)),
-                                  [t18.identifier("opt")]
-                                )
-                              ),
-                              t18.cloneNode(keyFn, true)
-                            ]
-                          )
+                          t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__reconcileList")), [
+                            t18.memberExpression(t18.thisExpression(), t18.identifier(itemsName)),
+                            t18.identifier("__arr"),
+                            t18.cloneNode(containerExpr, true),
+                            t18.identifier(arrayResult.componentTag),
+                            t18.arrowFunctionExpression(
+                              [t18.identifier("opt")],
+                              t18.callExpression(
+                                t18.memberExpression(t18.thisExpression(), t18.identifier(itemPropsMethodNameRef)),
+                                [t18.identifier("opt")]
+                              )
+                            ),
+                            t18.cloneNode(keyFn, true)
+                          ])
                         )
                       ]),
                       t18.expressionStatement(
@@ -7826,10 +8286,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                           t18.blockStatement([
                             t18.expressionStatement(
                               t18.callExpression(
-                                t18.memberExpression(
-                                  t18.thisExpression(),
-                                  t18.identifier(refreshMethodName)
-                                ),
+                                t18.memberExpression(t18.thisExpression(), t18.identifier(refreshMethodName)),
                                 []
                               )
                             )
@@ -7880,11 +8337,14 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   });
                 }
                 componentArrayDisposeTargets.push(getComponentArrayItemsName(arrayPropName));
-                replaceMapWithComponentArrayItems(
+                const wasReplacedInTemplate = replaceMapWithComponentArrayItems(
                   templateMethod,
                   um.computationExpr,
                   getComponentArrayItemsName(arrayPropName)
                 );
+                if (!wasReplacedInTemplate && !storeArrayAccess) {
+                  staticArrayRefreshOnMount.push(getComponentArrayRefreshMethodName(arrayPropName));
+                }
                 applied = true;
               }
               return;
@@ -7981,10 +8441,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   [t18.identifier("value"), t18.identifier("change")],
                   t18.blockStatement([
                     t18.expressionStatement(
-                      t18.callExpression(
-                        t18.memberExpression(t18.thisExpression(), t18.identifier("__geaSyncMap")),
-                        [t18.numericLiteral(mapIdx)]
-                      )
+                      t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__geaSyncMap")), [
+                        t18.numericLiteral(mapIdx)
+                      ])
                     )
                   ])
                 )
@@ -8002,7 +8461,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             }
             if (scanNodes.length > 0) {
               const prog = t18.program(scanNodes);
-              traverse10(prog, {
+              traverse11(prog, {
                 noScope: true,
                 Identifier(path) {
                   if (templatePropNames.has(path.node.name)) usedPropNames.add(path.node.name);
@@ -8110,8 +8569,8 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             if (!t18.isClassMethod(member) || member.kind !== "get" || !t18.isIdentifier(member.key)) continue;
             const deps = [];
             const localRefs = /* @__PURE__ */ new Set();
-            const program9 = t18.program(member.body.body.map((s) => t18.cloneNode(s, true)));
-            traverse10(program9, {
+            const program10 = t18.program(member.body.body.map((s) => t18.cloneNode(s, true)));
+            traverse11(program10, {
               noScope: true,
               MemberExpression(mePath) {
                 if (t18.isThisExpression(mePath.node.object) && t18.isIdentifier(mePath.node.property)) {
@@ -8159,7 +8618,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                 if (!t18.isIfStatement(stmt) || !(t18.isReturnStatement(stmt.consequent) || t18.isBlockStatement(stmt.consequent) && stmt.consequent.body.some((b) => t18.isReturnStatement(b))))
                   continue;
                 const guardProg = t18.program([t18.expressionStatement(t18.cloneNode(stmt.test, true))]);
-                traverse10(guardProg, {
+                traverse11(guardProg, {
                   noScope: true,
                   Identifier(idPath) {
                     if (t18.isMemberExpression(idPath.parent) && idPath.parent.property === idPath.node && !idPath.parent.computed)
@@ -8290,7 +8749,10 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   if (allDepsCovered) continue;
                 }
               }
-              mergeObserveMethod(observeKey, generateRerenderObserver(propPath, storeVar, guardStateKeys.has(observeKey)));
+              mergeObserveMethod(
+                observeKey,
+                generateRerenderObserver(propPath, storeVar, guardStateKeys.has(observeKey))
+              );
             } else if (guardStateKeys.has(observeKey)) {
               mergeObserveMethod(observeKey, generateRerenderObserver(propPath, storeVar, true));
             }
@@ -8311,7 +8773,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               }
             };
             const wrapper = t18.expressionStatement(t18.cloneNode(childrenProp.value, true));
-            traverse10(t18.program([wrapper]), { noScope: true, ...check });
+            traverse11(t18.program([wrapper]), { noScope: true, ...check });
             if (hasMap) childrenWithResolvedMap.add(child.instanceVar);
           });
           if (childrenWithResolvedMap.size > 0 && analysis.arrayMaps.length > 0) {
@@ -8352,7 +8814,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               const methodName = member.key.name;
               const isRelevant = childrenWithResolvedMap.size > 0 && methodName.startsWith("__buildProps_");
               if (!isRelevant) continue;
-              traverse10(t18.program([t18.expressionStatement(t18.functionExpression(null, [], member.body))]), {
+              traverse11(t18.program([t18.expressionStatement(t18.functionExpression(null, [], member.body))]), {
                 noScope: true,
                 TemplateLiteral(tlPath) {
                   const tl = tlPath.node;
@@ -8395,8 +8857,8 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   return false;
                 }
                 return true;
-              }).map(
-                (child) => t18.expressionStatement(
+              }).map((child) => {
+                const updateExpr = t18.expressionStatement(
                   t18.callExpression(
                     t18.memberExpression(
                       t18.memberExpression(t18.thisExpression(), t18.identifier(child.instanceVar)),
@@ -8412,8 +8874,14 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                       )
                     ]
                   )
-                )
-              );
+                );
+                if (!child.lazy) return updateExpr;
+                const backingField = `__lazy${child.instanceVar}`;
+                return t18.ifStatement(
+                  t18.memberExpression(t18.thisExpression(), t18.identifier(backingField)),
+                  t18.blockStatement([updateExpr])
+                );
+              });
               if (existing && t18.isBlockStatement(existing.body)) {
                 existing.body.body.unshift(...calls);
               } else {
@@ -8512,7 +8980,11 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
           const htmlArrayMaps = [];
           for (const arrayMap of analysis.arrayMaps) {
             const compChild = isUnresolvedMapWithComponentChild(
-              { itemTemplate: arrayMap.itemTemplate, itemVariable: arrayMap.itemVariable, containerSelector: arrayMap.containerSelector },
+              {
+                itemTemplate: arrayMap.itemTemplate,
+                itemVariable: arrayMap.itemVariable,
+                containerSelector: arrayMap.containerSelector
+              },
               imports
             );
             if (compChild) {
@@ -8593,11 +9065,14 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               }
               componentArrayDisposeTargets.push(getComponentArrayItemsName(arrayPropName));
               const mapReplaceExpr = storeArrayAccess ? t18.memberExpression(t18.identifier(storeArrayAccess.storeVar), t18.identifier(storeArrayAccess.propName)) : computationExpr;
-              replaceMapWithComponentArrayItems(
+              const wasReplaced = replaceMapWithComponentArrayItems(
                 templateMethod,
                 mapReplaceExpr,
                 getComponentArrayItemsName(arrayPropName)
               );
+              if (!wasReplaced && !arrayMap.storeVar) {
+                staticArrayRefreshOnMount.push(getComponentArrayRefreshMethodName(arrayPropName));
+              }
               applied = true;
             }
           }
@@ -8610,21 +9085,30 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             for (const depPath of getterDepPaths) {
               const depObserveKey = buildObserveKey(depPath, arrayMap.storeVar);
               const depMethodName = getObserveMethodName(depPath, arrayMap.storeVar);
-              const delegateBody = t18.blockStatement([
-                t18.expressionStatement(
-                  t18.callExpression(
-                    t18.memberExpression(t18.thisExpression(), t18.identifier("__refreshList")),
-                    [t18.stringLiteral(pathKey)]
-                  )
-                )
-              ]);
-              const delegateMethod = t18.classMethod(
-                "method",
-                t18.identifier(depMethodName),
-                [t18.identifier("__v"), t18.identifier("__c")],
-                delegateBody
+              const refreshStmt = t18.expressionStatement(
+                t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__refreshList")), [
+                  t18.stringLiteral(pathKey)
+                ])
               );
-              mergeObserveMethod(depObserveKey, delegateMethod);
+              const existing = addedMethods.get(depObserveKey);
+              if (existing && t18.isBlockStatement(existing.body)) {
+                const renderedGuardIdx = existing.body.body.findIndex(
+                  (s) => t18.isIfStatement(s) && t18.isMemberExpression(s.test) && t18.isIdentifier(s.test.property) && s.test.property.name === "rendered_"
+                );
+                if (renderedGuardIdx >= 0) {
+                  existing.body.body.splice(renderedGuardIdx, 0, refreshStmt);
+                } else {
+                  existing.body.body.push(refreshStmt);
+                }
+              } else {
+                const delegateMethod = t18.classMethod(
+                  "method",
+                  t18.identifier(depMethodName),
+                  [t18.identifier("__v"), t18.identifier("__c")],
+                  t18.blockStatement([refreshStmt])
+                );
+                mergeObserveMethod(depObserveKey, delegateMethod);
+              }
             }
           }
           for (const arrayMap of componentArrayMaps) {
@@ -8634,12 +9118,10 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             const pathKey = arrayMap.arrayPathParts.join(".");
             const storeRef = stateRefs.get(arrayMap.storeVar);
             const getterDepPaths = storeRef?.getterDeps?.get(arrayMap.arrayPathParts[0]);
-            const getterDepKeys = new Set(
-              (getterDepPaths || []).map((dp) => buildObserveKey(dp, arrayMap.storeVar))
-            );
+            const getterDepKeys = new Set((getterDepPaths || []).map((dp) => buildObserveKey(dp, arrayMap.storeVar)));
             const externalDeps = /* @__PURE__ */ new Map();
             const clonedBody = t18.cloneNode(itemPropsMethod.body, true);
-            traverse10(t18.program([t18.expressionStatement(t18.arrowFunctionExpression([], clonedBody))]), {
+            traverse11(t18.program([t18.expressionStatement(t18.arrowFunctionExpression([], clonedBody))]), {
               noScope: true,
               Identifier(idPath) {
                 if (idPath.parentPath && t18.isMemberExpression(idPath.parentPath.node) && idPath.parentPath.node.property === idPath.node && !idPath.parentPath.node.computed)
@@ -8669,10 +9151,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               if (!stateProps.has(depKey)) stateProps.set(depKey, dep.parts);
               const delegateBody = t18.blockStatement([
                 t18.expressionStatement(
-                  t18.callExpression(
-                    t18.memberExpression(t18.thisExpression(), t18.identifier("__refreshList")),
-                    [t18.stringLiteral(pathKey)]
-                  )
+                  t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__refreshList")), [
+                    t18.stringLiteral(pathKey)
+                  ])
                 )
               ]);
               const delegateMethod = t18.classMethod(
@@ -8713,46 +9194,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             }
             const observeKey = buildObserveKey(arrayMap.arrayPathParts, arrayMap.storeVar);
             const arrayHandlerMethodName = getObserveMethodName(arrayMap.arrayPathParts, arrayMap.storeVar);
-            generateArrayHandlers(arrayMap, arrayHandlerMethodName).forEach(
-              (h) => {
-                mergeObserveMethod(observeKey, h);
-              }
-            );
-            if (arrayMap.storeVar) {
-              const storeRef = stateRefs.get(arrayMap.storeVar);
-              const getterDepPaths = storeRef?.getterDeps?.get(arrayMap.arrayPathParts[0]);
-              if (getterDepPaths && getterDepPaths.length > 0) {
-                for (const depPath of getterDepPaths) {
-                  const depObserveKey = buildObserveKey(depPath, arrayMap.storeVar);
-                  const depMethodName = getObserveMethodName(depPath, arrayMap.storeVar);
-                  let rereadExpr = t18.memberExpression(
-                    t18.identifier(arrayMap.storeVar),
-                    t18.identifier(arrayMap.arrayPathParts[0])
-                  );
-                  for (let i = 1; i < arrayMap.arrayPathParts.length; i++) {
-                    rereadExpr = t18.memberExpression(
-                      rereadExpr,
-                      t18.identifier(arrayMap.arrayPathParts[i])
-                    );
-                  }
-                  const delegateBody = t18.blockStatement([
-                    t18.expressionStatement(
-                      t18.callExpression(
-                        t18.memberExpression(t18.thisExpression(), t18.identifier(arrayHandlerMethodName)),
-                        [rereadExpr, t18.nullLiteral()]
-                      )
-                    )
-                  ]);
-                  const delegateMethod = t18.classMethod(
-                    "method",
-                    t18.identifier(depMethodName),
-                    [t18.identifier("__v"), t18.identifier("__c")],
-                    delegateBody
-                  );
-                  mergeObserveMethod(depObserveKey, delegateMethod);
-                }
-              }
-            }
+            generateArrayHandlers(arrayMap, arrayHandlerMethodName).forEach((h) => {
+              mergeObserveMethod(observeKey, h);
+            });
           });
           if ((analysis.conditionalSlots || []).length > 0) {
             const templatePropNames2 = getTemplatePropNames(classPath.node.body);
@@ -8760,7 +9204,8 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
               classPath.node.body,
               analysis.conditionalSlots,
               templatePropNames2,
-              getTemplateParamIdentifier(classPath.node.body)
+              getTemplateParamIdentifier(classPath.node.body),
+              analysis.earlyReturnGuard
             );
           }
           if (htmlArrayMaps.length > 0) {
@@ -8780,17 +9225,14 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   t18.identifier(arrayMap.arrayPathParts[0])
                 );
               } else {
-                valueExpr = t18.memberExpression(
-                  t18.thisExpression(),
-                  t18.identifier(arrayMap.arrayPathParts[0])
-                );
+                valueExpr = t18.memberExpression(t18.thisExpression(), t18.identifier(arrayMap.arrayPathParts[0]));
               }
               afterRenderCalls.push(
                 t18.expressionStatement(
-                  t18.callExpression(
-                    t18.memberExpression(t18.thisExpression(), t18.identifier(methodName)),
-                    [valueExpr, t18.nullLiteral()]
-                  )
+                  t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(methodName)), [
+                    valueExpr,
+                    t18.nullLiteral()
+                  ])
                 )
               );
             });
@@ -8801,10 +9243,7 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                 [],
                 t18.blockStatement([
                   t18.expressionStatement(
-                    t18.callExpression(
-                      t18.memberExpression(t18.super(), t18.identifier("onAfterRender")),
-                      []
-                    )
+                    t18.callExpression(t18.memberExpression(t18.super(), t18.identifier("onAfterRender")), [])
                   ),
                   ...afterRenderCalls
                 ])
@@ -8859,12 +9298,9 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                 const getterDepPaths = storeRef?.getterDeps?.get(parts[0]);
                 if (getterDepPaths && getterDepPaths.length > 0) {
                   const originalMethodName = getObserveMethodName(parts, storeVar);
-                  let rereadExpr = t18.memberExpression(
-                    t18.identifier(storeVar),
-                    t18.identifier(parts[0])
-                  );
+                  let rereadExpr = t18.memberExpression(t18.identifier(storeVar), t18.identifier(parts[0]));
                   for (let i = 1; i < parts.length; i++) {
-                    rereadExpr = t18.memberExpression(rereadExpr, t18.identifier(parts[i]));
+                    rereadExpr = t18.optionalMemberExpression(rereadExpr, t18.identifier(parts[i]), false, true);
                   }
                   for (const depPath of getterDepPaths) {
                     const depKey = buildObserveKey(depPath, storeVar) + `__getter_${parts.join("_")}`;
@@ -8941,46 +9377,141 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             if (guardStateKeys.size > 0) {
               addedMethods.forEach((method, observeKey) => {
                 const { parts, storeVar: sv } = parseObserveKey(observeKey);
-                if (!sv || parts.length < 2) return;
-                for (let prefixLen = 1; prefixLen < parts.length; prefixLen++) {
-                  const prefixKey = buildObserveKey(parts.slice(0, prefixLen), sv);
-                  if (guardStateKeys.has(prefixKey)) {
-                    const guardCheck = t18.ifStatement(
-                      t18.binaryExpression(
-                        "==",
-                        t18.memberExpression(t18.identifier(sv), t18.identifier(parts[prefixLen - 1])),
-                        t18.nullLiteral()
-                      ),
-                      t18.returnStatement()
-                    );
-                    if (t18.isBlockStatement(method.body)) {
-                      method.body.body.unshift(guardCheck);
+                if (!sv) return;
+                if (parts.length >= 2) {
+                  for (let prefixLen = 1; prefixLen < parts.length; prefixLen++) {
+                    const prefixKey = buildObserveKey(parts.slice(0, prefixLen), sv);
+                    if (guardStateKeys.has(prefixKey)) {
+                      const guardCheck = t18.ifStatement(
+                        t18.binaryExpression(
+                          "==",
+                          t18.memberExpression(t18.identifier(sv), t18.identifier(parts[prefixLen - 1])),
+                          t18.nullLiteral()
+                        ),
+                        t18.returnStatement()
+                      );
+                      if (t18.isBlockStatement(method.body)) {
+                        method.body.body.unshift(guardCheck);
+                      }
+                      break;
+                    }
+                  }
+                } else if (parts.length === 1) {
+                  const storeRef = stateRefs.get(sv);
+                  if (storeRef?.getterDeps) {
+                    for (const [getterName, depPaths] of storeRef.getterDeps) {
+                      const isDepOfGetter = depPaths.some((dp) => dp.length === 1 && dp[0] === parts[0]);
+                      if (!isDepOfGetter) continue;
+                      const guardKey = buildObserveKey([getterName], sv);
+                      if (!guardStateKeys.has(guardKey)) continue;
+                      const guardCheck = t18.ifStatement(
+                        t18.binaryExpression(
+                          "==",
+                          t18.memberExpression(t18.identifier(sv), t18.identifier(getterName)),
+                          t18.nullLiteral()
+                        ),
+                        t18.returnStatement()
+                      );
+                      if (t18.isBlockStatement(method.body)) {
+                        method.body.body.unshift(guardCheck);
+                      }
+                      break;
                     }
-                    break;
                   }
                 }
               });
             }
+            {
+              const seen = /* @__PURE__ */ new Set();
+              const methodEntries = [];
+              addedMethods.forEach((method, observeKey) => {
+                if (seen.has(method)) return;
+                seen.add(method);
+                const name = getMethodName(method);
+                if (name) methodEntries.push({ observeKey, method, name });
+              });
+              const bodyGroups = /* @__PURE__ */ new Map();
+              for (const entry of methodEntries) {
+                const { storeVar } = parseObserveKey(entry.observeKey);
+                const bodyCode = (storeVar || "") + ":" + generate2(t18.blockStatement(entry.method.body.body)).code;
+                if (!bodyGroups.has(bodyCode)) bodyGroups.set(bodyCode, []);
+                bodyGroups.get(bodyCode).push(entry);
+              }
+              const renameMap = /* @__PURE__ */ new Map();
+              for (const [, group] of bodyGroups) {
+                if (group.length < 2) continue;
+                const canonical = group[0];
+                for (let i = 1; i < group.length; i++) {
+                  const dup = group[i];
+                  renameMap.set(dup.name, canonical.name);
+                  const idx = classPath.node.body.body.indexOf(dup.method);
+                  if (idx !== -1) classPath.node.body.body.splice(idx, 1);
+                }
+              }
+              if (renameMap.size > 0) {
+                for (const [, config] of importedStores) {
+                  for (const [key, entry] of config.observeHandlers) {
+                    if (renameMap.has(entry.methodName)) {
+                      config.observeHandlers.set(key, { ...entry, methodName: renameMap.get(entry.methodName) });
+                    }
+                  }
+                }
+                for (const [key, entry] of localObserveHandlers) {
+                  if (renameMap.has(entry.methodName)) {
+                    localObserveHandlers.set(key, { ...entry, methodName: renameMap.get(entry.methodName) });
+                  }
+                }
+              }
+            }
             if (importedStores.size > 0 || localObserveHandlers.size > 0 || mapRegistrations.length > 0) {
               const storeConfigs = Array.from(importedStores.entries()).map(([storeVar, config]) => ({
                 storeVar,
                 captureExpression: config.captureExpression,
-                observeHandlers: Array.from(config.observeHandlers.values()).map(({ pathParts, methodName, isVia, rereadExpr }) => ({
-                  pathParts,
-                  methodName,
-                  isVia,
-                  rereadExpr
-                }))
+                observeHandlers: Array.from(config.observeHandlers.values()).map(
+                  ({ pathParts, methodName, isVia, rereadExpr }) => ({
+                    pathParts,
+                    methodName,
+                    isVia,
+                    rereadExpr
+                  })
+                )
               }));
               for (const olc of observeListConfigs) {
                 ensureStoreGroup(olc.storeVar);
               }
               if (storeConfigs.length > 0 || mapRegistrations.length > 0 || observeListConfigs.length > 0) {
-                const createdHooksMethod = generateCreatedHooks(storeConfigs, htmlArrayMaps.length > 0, observeListConfigs);
+                const createdHooksMethod = generateCreatedHooks(
+                  storeConfigs,
+                  htmlArrayMaps.length > 0,
+                  observeListConfigs
+                );
                 if (mapRegistrations.length > 0) {
                   createdHooksMethod.body.body.push(...mapRegistrations);
                 }
-                classPath.node.body.body.push(createdHooksMethod);
+                const generatedCreatedHooksBody = createdHooksMethod.body.body;
+                const existingCreatedHooks = classPath.node.body.body.find(
+                  (m) => t18.isClassMethod(m) && t18.isIdentifier(m.key) && m.key.name === "createdHooks"
+                );
+                if (existingCreatedHooks) {
+                  existingCreatedHooks.body.body.unshift(...generatedCreatedHooksBody);
+                } else {
+                  classPath.node.body.body.push(createdHooksMethod);
+                }
+              }
+              if (staticArrayRefreshOnMount.length > 0) {
+                const refreshStmts = [...new Set(staticArrayRefreshOnMount)].map(
+                  (name) => t18.expressionStatement(
+                    t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(name)), [])
+                  )
+                );
+                const existingHook = classPath.node.body.body.find(
+                  (m) => t18.isClassMethod(m) && t18.isIdentifier(m.key) && m.key.name === "onAfterRenderHooks"
+                );
+                if (existingHook) existingHook.body.body.push(...refreshStmts);
+                else
+                  classPath.node.body.body.push(
+                    t18.classMethod("method", t18.identifier("onAfterRenderHooks"), [], t18.blockStatement(refreshStmts))
+                  );
               }
               if (localObserveHandlers.size > 0) {
                 classPath.node.body.body.push(
@@ -9033,8 +9564,8 @@ function collectUnresolvedDependencies(unresolvedMaps, stateRefs, classBody2) {
     }
     const depExpr = resolveHelperCallExpressionForDeps(unresolvedMap.computationExpr, classBody2);
     const targetExpr = depExpr || unresolvedMap.computationExpr;
-    const program9 = t18.program([t18.expressionStatement(t18.cloneNode(targetExpr, true))]);
-    traverse10(program9, {
+    const program10 = t18.program([t18.expressionStatement(t18.cloneNode(targetExpr, true))]);
+    traverse11(program10, {
       noScope: true,
       MemberExpression(path) {
         const targetExpr2 = path.parentPath && t18.isCallExpression(path.parentPath.node) && path.parentPath.node.callee === path.node ? path.node.object : path.node;
@@ -9063,8 +9594,8 @@ function collectHelperMethodDependencies(expr, classBody2, stateRefs, deps) {
     (node) => t18.isClassMethod(node) && t18.isIdentifier(node.key) && node.key.name === helperMethodName
   );
   if (!helperMethod || !t18.isBlockStatement(helperMethod.body)) return false;
-  const program9 = t18.program(helperMethod.body.body.map((stmt) => t18.cloneNode(stmt, true)));
-  traverse10(program9, {
+  const program10 = t18.program(helperMethod.body.body.map((stmt) => t18.cloneNode(stmt, true)));
+  traverse11(program10, {
     noScope: true,
     MemberExpression(path) {
       const resolved = resolvePath(path.node, stateRefs);
@@ -9176,11 +9707,7 @@ function generateMapRegistration(arrayMap, unresolvedMap, templatePropNames, who
   if (needsReplace) {
     arrExpr = replacePropRefsInExpression(arrExpr, templatePropNames || /* @__PURE__ */ new Set(), wholeParamName);
     if (setupStatements.length) {
-      setupStatements = replacePropRefsInStatements(
-        setupStatements,
-        templatePropNames || /* @__PURE__ */ new Set(),
-        wholeParamName
-      );
+      setupStatements = replacePropRefsInStatements(setupStatements, templatePropNames || /* @__PURE__ */ new Set(), wholeParamName);
     }
   }
   const prunedSetup = pruneUnusedSetupStatements(setupStatements, arrExpr);
@@ -9208,7 +9735,7 @@ function generateMapRegistration(arrayMap, unresolvedMap, templatePropNames, who
 function collectFreeIdentifiers(nodes) {
   const names = /* @__PURE__ */ new Set();
   for (const node of nodes) {
-    traverse10(
+    traverse11(
       t18.isProgram(node) ? node : t18.program([t18.isStatement(node) ? node : t18.expressionStatement(node)]),
       {
         noScope: true,
@@ -9277,12 +9804,12 @@ function getArrayPropNameFromExpr(expr) {
   return null;
 }
 function replaceMapWithComponentArrayItems(templateMethod, arrayExpr, itemsName) {
-  if (!arrayExpr || !t18.isBlockStatement(templateMethod.body)) return;
+  if (!arrayExpr || !t18.isBlockStatement(templateMethod.body)) return false;
   const tempProg = t18.program([
     t18.expressionStatement(t18.arrowFunctionExpression(templateMethod.params, templateMethod.body))
   ]);
   let replaced = false;
-  traverse10(tempProg, {
+  traverse11(tempProg, {
     noScope: true,
     CallExpression(path) {
       if (replaced) return;
@@ -9303,6 +9830,7 @@ function replaceMapWithComponentArrayItems(templateMethod, arrayExpr, itemsName)
       replaced = true;
     }
   });
+  return replaced;
 }
 function inlineIntoConstructor(classBody2, statements) {
   let ctor = classBody2.body.find(
@@ -9411,10 +9939,7 @@ function ensureOnPropChangeMethod(classBody2, inlinePatchBodies, compiledChildre
         ),
         [
           t18.callExpression(
-            t18.memberExpression(
-              t18.thisExpression(),
-              t18.identifier(`__buildProps_${child.instanceVar.replace(/^_/, "")}`)
-            ),
+            t18.memberExpression(t18.thisExpression(), t18.identifier(`__buildProps_${child.instanceVar.replace(/^_/, "")}`)),
             []
           )
         ]
@@ -9580,7 +10105,10 @@ function mergeKeyGuards(stmts) {
   }
   return result;
 }
-function generateConditionalPatchMethods(classBody2, slots, templatePropNames, wholeParamName) {
+function generateConditionalPatchMethods(classBody2, slots, templatePropNames, wholeParamName, earlyReturnGuard) {
+  const guardedRoot = earlyReturnGuard ? earlyReturnFalsyBindingName(earlyReturnGuard) : null;
+  const maybeOptStmts = (stmts) => guardedRoot ? optionalizeBindingRootInStatements(stmts, guardedRoot) : stmts;
+  const maybeOptExpr = (e) => guardedRoot ? optionalizeMemberChainsFromBindingRoot(e, guardedRoot) : e;
   const collectDeduped = (stmts, seen, out) => {
     for (const stmt of stmts) {
       if (t18.isVariableDeclaration(stmt)) {
@@ -9617,9 +10145,12 @@ function generateConditionalPatchMethods(classBody2, slots, templatePropNames, w
   const rpExpr = (e) => replacePropRefsInExpression(e, templatePropNames, wholeParamName);
   const rpStmts = (s) => replacePropRefsInStatements(s, templatePropNames, wholeParamName);
   const rewrittenCondExprs = slots.map((s) => rpExpr(t18.cloneNode(s.conditionExpr, true)));
-  const initSetup = pruneDeadParamDestructuring(
-    rpStmts(allSetupStatements.map((s) => t18.cloneNode(s, true))),
-    rewrittenCondExprs
+  const rewrittenCondExprsSafe = rewrittenCondExprs.map((e) => maybeOptExpr(e));
+  const initSetup = maybeOptStmts(
+    pruneDeadParamDestructuring(
+      rpStmts(allSetupStatements.map((s) => t18.cloneNode(s, true))),
+      rewrittenCondExprs
+    )
   );
   const condAssignments = [];
   for (let i = 0; i < slots.length; i++) {
@@ -9628,7 +10159,7 @@ function generateConditionalPatchMethods(classBody2, slots, templatePropNames, w
         t18.assignmentExpression(
           "=",
           t18.memberExpression(t18.thisExpression(), t18.identifier(`__geaCond_${i}`)),
-          t18.unaryExpression("!", t18.unaryExpression("!", rewrittenCondExprs[i]))
+          t18.unaryExpression("!", t18.unaryExpression("!", rewrittenCondExprsSafe[i]))
         )
       )
     );
@@ -9637,22 +10168,25 @@ function generateConditionalPatchMethods(classBody2, slots, templatePropNames, w
   for (let i = 0; i < slots.length; i++) {
     const slot = slots[i];
     const rewrittenCondExpr = rpExpr(t18.cloneNode(slot.conditionExpr, true));
-    const condSetup = pruneDeadParamDestructuring(
-      rpStmts(allSetupStatements.map((s) => t18.cloneNode(s, true))),
-      [rewrittenCondExpr]
+    const condSetup = maybeOptStmts(
+      pruneDeadParamDestructuring(rpStmts(allSetupStatements.map((s) => t18.cloneNode(s, true))), [
+        rewrittenCondExpr
+      ])
     );
-    const getCondBody = [...condSetup, t18.returnStatement(rewrittenCondExpr)];
+    const getCondBody = [...condSetup, t18.returnStatement(maybeOptExpr(rewrittenCondExpr))];
     const buildHtmlFn = (htmlExpr) => {
       if (!htmlExpr) return t18.nullLiteral();
       const clonedHtmlExpr = rpExpr(t18.cloneNode(htmlExpr, true));
-      const htmlSetup = pruneDeadParamDestructuring(
-        rpStmts(allHtmlSetupStatements.map((s) => t18.cloneNode(s, true))),
-        [clonedHtmlExpr]
+      const htmlSetup = maybeOptStmts(
+        pruneDeadParamDestructuring(rpStmts(allHtmlSetupStatements.map((s) => t18.cloneNode(s, true))), [
+          clonedHtmlExpr
+        ])
       );
+      const htmlExprSafe = maybeOptExpr(clonedHtmlExpr);
       if (htmlSetup.length > 0) {
-        return t18.arrowFunctionExpression([], t18.blockStatement([...htmlSetup, t18.returnStatement(clonedHtmlExpr)]));
+        return t18.arrowFunctionExpression([], t18.blockStatement([...htmlSetup, t18.returnStatement(htmlExprSafe)]));
       }
-      return t18.arrowFunctionExpression([], clonedHtmlExpr);
+      return t18.arrowFunctionExpression([], htmlExprSafe);
     };
     registerCondCalls.push(
       t18.expressionStatement(
@@ -9667,10 +10201,7 @@ function generateConditionalPatchMethods(classBody2, slots, templatePropNames, w
     );
   }
   const evalStatements = [...initSetup, ...condAssignments];
-  const initBody = evalStatements.length > 0 ? [
-    t18.tryStatement(t18.blockStatement(evalStatements), loggingCatchClause()),
-    ...registerCondCalls
-  ] : registerCondCalls;
+  const initBody = evalStatements.length > 0 ? [...evalStatements, ...registerCondCalls] : registerCondCalls;
   inlineIntoConstructor(classBody2, initBody);
 }
 function getTemplatePropNames(classBody2) {
@@ -9698,7 +10229,7 @@ function getTemplateParamIdentifier(classBody2) {
 function collectPropNamesFromItemTemplate(itemTemplate, templatePropNames) {
   if (!itemTemplate) return [];
   const used = /* @__PURE__ */ new Set();
-  traverse10(itemTemplate, {
+  traverse11(itemTemplate, {
     noScope: true,
     Identifier(path) {
       if (templatePropNames.has(path.node.name)) used.add(path.node.name);
@@ -9740,7 +10271,7 @@ function injectMapItemAttrsIntoTemplate(templateMethod, mapInfos) {
   const tempProg = t18.program([
     t18.expressionStatement(t18.arrowFunctionExpression(templateMethod.params, templateMethod.body))
   ]);
-  traverse10(tempProg, {
+  traverse11(tempProg, {
     noScope: true,
     CallExpression(path) {
       if (!t18.isMemberExpression(path.node.callee)) return;
@@ -9815,7 +10346,7 @@ function addJoinToUnresolvedMapCalls(templateMethod, _unresolvedMaps) {
   const tempProg = t18.program([
     t18.expressionStatement(t18.arrowFunctionExpression(templateMethod.params, templateMethod.body))
   ]);
-  traverse10(tempProg, {
+  traverse11(tempProg, {
     noScope: true,
     CallExpression(path) {
       if (!t18.isMemberExpression(path.node.callee)) return;
@@ -9848,7 +10379,7 @@ function replaceInlineMapWithRenderCall(classPath, arrayMap, renderMethodName) {
   const tempProg = t18.program([
     t18.expressionStatement(t18.arrowFunctionExpression(templateMethod.params, templateMethod.body))
   ]);
-  traverse10(tempProg, {
+  traverse11(tempProg, {
     noScope: true,
     CallExpression(path) {
       if (!t18.isMemberExpression(path.node.callee)) return;
@@ -9897,7 +10428,7 @@ function replaceMapInConditionalSlots(slots, arrayMap, renderMethodName) {
     for (const expr of [slot.truthyHtmlExpr, slot.falsyHtmlExpr]) {
       if (!expr) continue;
       const tempProg = t18.program([t18.expressionStatement(expr)]);
-      traverse10(tempProg, {
+      traverse11(tempProg, {
         noScope: true,
         CallExpression(path) {
           if (!t18.isMemberExpression(path.node.callee)) return;
@@ -9962,15 +10493,7 @@ function generateRerenderObserver(pathParts, storeVar, truthinessOnly) {
   }
   method.body.body.push(
     t18.ifStatement(
-      t18.logicalExpression(
-        "&&",
-        t18.memberExpression(t18.thisExpression(), t18.identifier("rendered_")),
-        t18.binaryExpression(
-          "===",
-          t18.unaryExpression("typeof", t18.memberExpression(t18.thisExpression(), t18.identifier("__geaRequestRender"))),
-          t18.stringLiteral("function")
-        )
-      ),
+      t18.memberExpression(t18.thisExpression(), t18.identifier("rendered_")),
       t18.blockStatement([
         t18.expressionStatement(
           t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier("__geaRequestRender")), [])
@@ -10048,12 +10571,7 @@ function generateStateChildSwapMethod(classBody2, stateChildSlots) {
           t18.memberExpression(t18.thisExpression(), t18.identifier(slot.childInstanceVar)),
           t18.identifier("__geaUpdateProps")
         ),
-        [
-          t18.callExpression(
-            t18.memberExpression(t18.thisExpression(), t18.identifier(buildPropsName)),
-            []
-          )
-        ]
+        [t18.callExpression(t18.memberExpression(t18.thisExpression(), t18.identifier(buildPropsName)), [])]
       )
     );
   }).filter(Boolean);
@@ -10086,7 +10604,7 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 import { createRequire as createRequire12 } from "module";
 var require13 = createRequire12(import.meta.url);
-var traverse11 = require13("@babel/traverse").default;
+var traverse12 = require13("@babel/traverse").default;
 function resolveImportPath2(importer, source) {
   const base = resolve2(dirname2(importer), source);
   const candidates = [
@@ -10113,8 +10631,8 @@ function isPrivateName(name) {
 function extractGetterStatePaths(method) {
   if (!t19.isBlockStatement(method.body)) return null;
   const paths = /* @__PURE__ */ new Map();
-  const program9 = t19.program(method.body.body.map((stmt) => t19.cloneNode(stmt, true)));
-  traverse11(program9, {
+  const program10 = t19.program(method.body.body.map((stmt) => t19.cloneNode(stmt, true)));
+  traverse12(program10, {
     noScope: true,
     MemberExpression(path) {
       const node = path.node;
@@ -10154,7 +10672,7 @@ function analyzeStoreFile(filePath) {
   const parsed = parseSource(source);
   if (!parsed?.ast) return null;
   const result = /* @__PURE__ */ new Map();
-  traverse11(parsed.ast, {
+  traverse12(parsed.ast, {
     ClassDeclaration(classPath) {
       if (!classPath.node.superClass || !t19.isIdentifier(classPath.node.superClass) || classPath.node.superClass.name !== "Store") {
         return;
@@ -10211,7 +10729,7 @@ function getStoreFields(filePath) {
   const parsed = parseSource(source);
   if (!parsed?.ast) return null;
   const fields = /* @__PURE__ */ new Set();
-  traverse11(parsed.ast, {
+  traverse12(parsed.ast, {
     ClassDeclaration(classPath) {
       if (!classPath.node.superClass || !t19.isIdentifier(classPath.node.superClass) || classPath.node.superClass.name !== "Store") {
         return;
@@ -10254,7 +10772,7 @@ function analyzeStoreGetters(sourceFile, storeImports) {
 // src/transform-component.ts
 import { createRequire as createRequire13 } from "module";
 var require14 = createRequire13(import.meta.url);
-var traverse12 = require14("@babel/traverse").default;
+var traverse13 = require14("@babel/traverse").default;
 function transformComponentFile(ast, imports, storeImports, className, sourceFile, originalAST, compImportsUsedAsTags, knownComponentImports = /* @__PURE__ */ new Set()) {
   let transformed = false;
   const stateRefs = collectStateReferences(originalAST, storeImports);
@@ -10275,7 +10793,7 @@ function transformComponentFile(ast, imports, storeImports, className, sourceFil
   const compiledChildren = [];
   const eventIdCounter = { value: 0 };
   const preTransformAnalysis = /* @__PURE__ */ new Map();
-  traverse12(ast, {
+  traverse13(ast, {
     ClassMethod(path) {
       if (!t20.isIdentifier(path.node.key) || path.node.key.name !== "template") return;
       const ownerClass = path.findParent((p) => t20.isClassDeclaration(p.node));
@@ -10339,7 +10857,8 @@ function transformComponentFile(ast, imports, storeImports, className, sourceFil
         elementPathToBindingId: analysis.elementPathToBindingId,
         templateSetupContext: {
           params: path.node.params,
-          statements: returnIndex >= 0 ? body.slice(0, returnIndex) : []
+          statements: returnIndex >= 0 ? body.slice(0, returnIndex) : [],
+          earlyReturnBarrierIndex: analysis.earlyReturnBarrierIndex
         },
         sourceFile,
         isRoot: true,
@@ -10555,7 +11074,7 @@ function transformComponentFile(ast, imports, storeImports, className, sourceFil
 }
 function transformNonComponentJSX(ast, imports) {
   let transformed = false;
-  traverse12(ast, {
+  traverse13(ast, {
     ClassMethod(path) {
       if (!t20.isIdentifier(path.node.key) || path.node.key.name !== "template") return;
       const body = path.node.body.body;
@@ -10651,7 +11170,7 @@ function addJoinToMapCallsInTemplates(ast) {
 function ensureComponentImport(ast, imports) {
   if (imports.has("Component")) return;
   let geaImportPath = null;
-  traverse12(ast, {
+  traverse13(ast, {
     ImportDeclaration(path) {
       if (path.node.source.value === "@geajs/core") {
         geaImportPath = path;
@@ -10675,7 +11194,7 @@ function ensureComponentImport(ast, imports) {
   imports.set("Component", "@geajs/core");
 }
 function transformRemainingJSX(ast, imports) {
-  traverse12(ast, {
+  traverse13(ast, {
     noScope: true,
     JSXElement(path) {
       const classMethod8 = path.findParent((p) => t20.isClassMethod(p.node));
@@ -10704,13 +11223,13 @@ function transformRemainingJSX(ast, imports) {
 import * as t21 from "@babel/types";
 import { createRequire as createRequire14 } from "module";
 var require15 = createRequire14(import.meta.url);
-var traverse13 = require15("@babel/traverse").default;
+var traverse14 = require15("@babel/traverse").default;
 function convertFunctionalToClass(ast, info, imports) {
   let params = [t21.identifier("props")];
   let templateBody = [];
   let removeVarDeclPath = null;
   let exportPath = null;
-  traverse13(ast, {
+  traverse14(ast, {
     ExportDefaultDeclaration(path) {
       exportPath = path;
       const decl = path.node.declaration;
@@ -10766,16 +11285,16 @@ function convertFunctionalToClass(ast, info, imports) {
   if (removeVarDeclPath) {
     removeVarDeclPath.remove();
   }
-  const program9 = ast.program;
-  const idx = program9.body.indexOf(exportPath.node);
+  const program10 = ast.program;
+  const idx = program10.body.indexOf(exportPath.node);
   if (idx >= 0) {
-    program9.body[idx] = t21.exportDefaultDeclaration(classDecl);
+    program10.body[idx] = t21.exportDefaultDeclaration(classDecl);
   }
 }
 function ensureComponentImport2(ast, imports) {
   if (imports.get("Component")) return;
   let geaImportPath = null;
-  traverse13(ast, {
+  traverse14(ast, {
     ImportDeclaration(path) {
       if (path.node.source.value === "@geajs/core") {
         geaImportPath = path;
@@ -10802,8 +11321,8 @@ import { dirname as dirname3, relative, resolve as resolve3 } from "path";
 import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { fileURLToPath } from "url";
 var pluginDir = dirname3(fileURLToPath(import.meta.url));
-var traverse14 = typeof babelTraverse.default === "function" ? babelTraverse.default : babelTraverse;
-var generate2 = typeof babelGenerator.default === "function" ? babelGenerator.default : babelGenerator;
+var traverse15 = typeof babelTraverse2.default === "function" ? babelTraverse2.default : babelTraverse2;
+var generate3 = typeof babelGenerator2.default === "function" ? babelGenerator2.default : babelGenerator2;
 var RECONCILE_ID = "virtual:gea-reconcile";
 var RESOLVED_RECONCILE_ID = "\0" + RECONCILE_ID;
 var HMR_RUNTIME_ID = "virtual:gea-hmr";
@@ -11141,7 +11660,7 @@ function geaPlugin() {
           convertFunctionalToClass(ast, functionalComponentInfo, imports);
           componentClassName = functionalComponentInfo.name;
           componentClassNames = [functionalComponentInfo.name];
-          const freshCode = generate2(ast, { retainLines: true }).code;
+          const freshCode = generate3(ast, { retainLines: true }).code;
           const freshParsed = parseSource(freshCode);
           if (freshParsed) {
             ast = freshParsed.ast;
@@ -11163,7 +11682,7 @@ function geaPlugin() {
         const storeImports = /* @__PURE__ */ new Map();
         const knownComponentImports = /* @__PURE__ */ new Set();
         const namedImportSources = /* @__PURE__ */ new Map();
-        traverse14(ast, {
+        traverse15(ast, {
           ExportDefaultDeclaration() {
             isDefaultExport = true;
           },
@@ -11234,7 +11753,7 @@ function geaPlugin() {
           if (hmrAdded) transformed = true;
         }
         if (!transformed) return null;
-        const output = generate2(ast, { sourceMaps: true, sourceFileName: cleanId }, code);
+        const output = generate3(ast, { sourceMaps: true, sourceFileName: cleanId }, code);
         return { code: output.code, map: output.map };
       } catch (error) {
         if (error?.__geaCompileError) {