@fictjs/compiler 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -18343,7 +18343,8 @@ function lowerNodeWithRegionContext(node, t2, ctx, declaredVars, regionCtx) {
         t2.blockStatement(conseqStmts),
         altStmts ? t2.blockStatement(altStmts) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -18571,31 +18572,53 @@ function lowerStructuredNodeForRegion(node, region, t2, ctx, declaredVars, regio
       return stmt ? [stmt] : [];
     }
     case "if": {
-      const consequent = lowerStructuredNodeForRegion(
-        node.consequent,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      );
-      const alternate = node.alternate ? lowerStructuredNodeForRegion(
-        node.alternate,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      ) : [];
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const baseShouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx);
+      const lowerChild = (child, forceNonReactive) => {
+        if (!child) return [];
+        if (!forceNonReactive) {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        }
+        const prevDepth = ctx.nonReactiveScopeDepth ?? 0;
+        ctx.nonReactiveScopeDepth = prevDepth + 1;
+        try {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        } finally {
+          ctx.nonReactiveScopeDepth = prevDepth;
+        }
+      };
+      let consequent = lowerChild(node.consequent, baseShouldWrapEffect);
+      let alternate = node.alternate ? lowerChild(node.alternate, baseShouldWrapEffect) : [];
       if (consequent.length === 0 && alternate.length === 0) return [];
-      const ifStmt = t2.ifStatement(
+      const buildIfStmt = (cons, alt) => t2.ifStatement(
         lowerExpressionWithDeSSA(node.test, ctx),
-        t2.blockStatement(consequent),
-        alternate.length > 0 ? t2.blockStatement(alternate) : null
+        t2.blockStatement(cons),
+        alt.length > 0 ? t2.blockStatement(alt) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      let ifStmt = buildIfStmt(consequent, alternate);
+      const shouldWrapEffect = baseShouldWrapEffect && !statementHasEarlyExit(ifStmt, t2);
+      if (!shouldWrapEffect && baseShouldWrapEffect) {
+        consequent = lowerChild(node.consequent, false);
+        alternate = node.alternate ? lowerChild(node.alternate, false) : [];
+        if (consequent.length === 0 && alternate.length === 0) return [];
+        ifStmt = buildIfStmt(consequent, alternate);
+      }
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -19622,7 +19645,8 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       (dep) => ctx.trackedVars.has(deSSAVarName(dep))
     );
     const usesTracked = expressionUsesTracked(instr.value, ctx);
-    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && (usesTracked || hasTrackedControlDep);
+    const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && !inNonReactiveScope && (usesTracked || hasTrackedControlDep);
     if (shouldWrapExpr) {
       ctx.helpersUsed.add("useEffect");
       ctx.needsCtx = true;
@@ -21451,7 +21475,7 @@ function lowerExpression(expr, ctx, isAssigned = false) {
     ctx.expressionDepth = depth - 1;
   }
 }
-function lowerExpressionImpl(expr, ctx, isAssigned = false) {
+function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
   const { t: t2 } = ctx;
   const mapParams = (params) => params.map((p) => t2.identifier(deSSAVarName(p.name)));
   const withFunctionScope = (paramNames, fn) => {
@@ -21513,11 +21537,7 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
       };
       const declared = new Set(paramIds.map((p) => p.name));
       return lowerStructuredNodeWithoutRegions(structured, t2, ctx, declared);
-    } catch (e) {
-      console.log(
-        "[DEBUG] Structurization failed, falling back to lowerBlocksToStatements via lowerInstruction",
-        e
-      );
+    } catch {
       return lowerBlocksToStatements(blocks);
     }
   };
@@ -21696,12 +21716,10 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
     case "ArrowFunction": {
       const paramIds = mapParams(expr.params);
       const shadowed = new Set(expr.params.map((p) => deSSAVarName(p.name)));
-      return withFunctionScope(shadowed, () => {
-        if (isAssigned) {
-          ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) + 1;
-        }
-        let fn;
-        try {
+      return withNonReactiveScope(
+        ctx,
+        () => withFunctionScope(shadowed, () => {
+          let fn;
           if (expr.isExpression && !Array.isArray(expr.body)) {
             const { result: bodyExpr, cacheDeclarations } = withGetterCache(
               ctx,
@@ -21729,12 +21747,8 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
           }
           fn.async = expr.isAsync ?? false;
           return fn;
-        } finally {
-          if (isAssigned) {
-            ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) - 1;
-          }
-        }
-      });
+        })
+      );
     }
     case "FunctionExpression": {
       const paramIds = mapParams(expr.params);
@@ -22746,114 +22760,151 @@ function lowerIntrinsicElement(jsx, ctx) {
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx);
     if (binding.type === "event" && binding.expr && binding.name) {
-      const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
-      const prevWrapTracked = ctx.wrapTrackedExpressions;
-      ctx.wrapTrackedExpressions = false;
-      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
-        skipHookAccessors: true,
-        skipRegionRootOverride: true
-      });
-      ctx.wrapTrackedExpressions = prevWrapTracked;
-      const eventParam = t2.identifier("_e");
-      const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
-      const ensureHandlerParam = (fn) => {
-        if (t2.isArrowFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
-        }
-        if (t2.isFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
-        }
-        return t2.arrowFunctionExpression(
-          [eventParam],
-          t2.callExpression(fn, [eventParam])
-        );
-      };
-      const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
-      const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
-      if (isDelegated) {
+      const hirDataBinding = isDelegated && binding.expr ? extractDelegatedEventDataFromHIR(binding.expr, ctx) : null;
+      if (hirDataBinding) {
         ctx.delegatedEventsUsed?.add(eventName);
-        const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
-        const normalizeHandler = (expr) => {
-          if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
-            return expr.callee;
-          }
-          return expr;
-        };
-        const normalizedDataHandler = dataBinding !== null ? normalizeHandler(dataBinding?.handler ?? handlerExpr) : null;
-        const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
-        const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
-        const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
-        let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
-        if (dataForDelegate) {
-          let payloadExpr;
-          if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
-            payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
-          } else {
-            payloadExpr = t2.callExpression(dataForDelegate, []);
-          }
-          handlerToAssign = t2.arrowFunctionExpression(
-            [eventParam],
-            t2.callExpression(handlerForDelegate, [payloadExpr])
-          );
-        }
+        const handlerExpr = lowerExpression(hirDataBinding.handler, ctx);
+        const dataExpr = lowerDomExpression(hirDataBinding.data, ctx, containingRegion, {
+          skipHookAccessors: false,
+          skipRegionRootOverride: true
+        });
+        const dataParam = t2.identifier("__data");
+        const eventParam = t2.identifier("_e");
+        const wrappedHandler = t2.arrowFunctionExpression(
+          [dataParam, eventParam],
+          t2.callExpression(handlerExpr, [dataParam])
+        );
         statements.push(
           t2.expressionStatement(
             t2.assignmentExpression(
               "=",
               t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
-              handlerToAssign
+              wrappedHandler
             )
           )
         );
-        if (dataForDelegate) {
+        const dataGetter = t2.arrowFunctionExpression([], dataExpr);
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+              dataGetter
+            )
+          )
+        );
+      } else {
+        const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
+        const prevWrapTracked = ctx.wrapTrackedExpressions;
+        ctx.wrapTrackedExpressions = false;
+        const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
+          skipHookAccessors: true,
+          skipRegionRootOverride: true
+        });
+        ctx.wrapTrackedExpressions = prevWrapTracked;
+        const eventParam = t2.identifier("_e");
+        const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
+        const ensureHandlerParam = (fn) => {
+          if (t2.isArrowFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
+          }
+          if (t2.isFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+          }
+          return t2.arrowFunctionExpression(
+            [eventParam],
+            t2.callExpression(fn, [eventParam])
+          );
+        };
+        const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
+        const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
+        if (isDelegated) {
+          ctx.delegatedEventsUsed?.add(eventName);
+          const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
+          const normalizeHandler = (expr) => {
+            if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
+              return expr.callee;
+            }
+            return expr;
+          };
+          const normalizedDataHandler = dataBinding !== null ? normalizeHandler(
+            dataBinding?.handler ?? handlerExpr
+          ) : null;
+          const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
+          const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
+          const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
+          let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
+          if (dataForDelegate) {
+            let payloadExpr;
+            if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
+              payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
+            } else {
+              payloadExpr = t2.callExpression(dataForDelegate, []);
+            }
+            handlerToAssign = t2.arrowFunctionExpression(
+              [eventParam],
+              t2.callExpression(handlerForDelegate, [payloadExpr])
+            );
+          }
           statements.push(
             t2.expressionStatement(
               t2.assignmentExpression(
                 "=",
-                t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
-                dataForDelegate
+                t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
+                handlerToAssign
               )
             )
           );
-        }
-      } else {
-        ctx.helpersUsed.add("bindEvent");
-        ctx.helpersUsed.add("onDestroy");
-        const cleanupId = genTemp(ctx, "evt");
-        const args = [
-          targetId,
-          t2.stringLiteral(eventName),
-          handlerExpr
-        ];
-        if (hasEventOptions && binding.eventOptions) {
-          const optionProps = [];
-          if (binding.eventOptions.capture) {
-            optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
-          }
-          if (binding.eventOptions.passive) {
-            optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+          if (dataForDelegate) {
+            statements.push(
+              t2.expressionStatement(
+                t2.assignmentExpression(
+                  "=",
+                  t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+                  dataForDelegate
+                )
+              )
+            );
           }
-          if (binding.eventOptions.once) {
-            optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+        } else {
+          ctx.helpersUsed.add("bindEvent");
+          ctx.helpersUsed.add("onDestroy");
+          const cleanupId = genTemp(ctx, "evt");
+          const args = [
+            targetId,
+            t2.stringLiteral(eventName),
+            handlerExpr
+          ];
+          if (hasEventOptions && binding.eventOptions) {
+            const optionProps = [];
+            if (binding.eventOptions.capture) {
+              optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.passive) {
+              optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.once) {
+              optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+            }
+            args.push(t2.objectExpression(optionProps));
           }
-          args.push(t2.objectExpression(optionProps));
-        }
-        statements.push(
-          t2.variableDeclaration("const", [
-            t2.variableDeclarator(
-              cleanupId,
-              t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+          statements.push(
+            t2.variableDeclaration("const", [
+              t2.variableDeclarator(
+                cleanupId,
+                t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+              )
+            ]),
+            t2.expressionStatement(
+              t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
             )
-          ]),
-          t2.expressionStatement(
-            t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
-          )
-        );
+          );
+        }
       }
     } else if (binding.type === "attr" && binding.name) {
       const attrName = binding.name;
@@ -22915,16 +22966,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         t2.expressionStatement(lowerDomExpression(binding.expr, ctx, containingRegion))
       );
     } else if (binding.type === "text" && binding.expr) {
-      ctx.helpersUsed.add("bindText");
       const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
-      statements.push(
-        t2.expressionStatement(
-          t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
-            targetId,
-            t2.arrowFunctionExpression([], valueExpr)
-          ])
-        )
-      );
+      if (isExpressionReactive(binding.expr, ctx)) {
+        ctx.helpersUsed.add("bindText");
+        statements.push(
+          t2.expressionStatement(
+            t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
+              targetId,
+              t2.arrowFunctionExpression([], valueExpr)
+            ])
+          )
+        );
+      } else {
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier("data")),
+              t2.callExpression(t2.identifier("String"), [valueExpr])
+            )
+          )
+        );
+      }
     } else if (binding.type === "child" && binding.expr) {
       emitHIRChildBinding(targetId, binding.expr, statements, ctx, containingRegion);
     }
@@ -23228,6 +23291,82 @@ function extractDelegatedEventData(expr, t2) {
     data: dataArg && t2.isExpression(dataArg) ? dataArg : void 0
   };
 }
+function extractDelegatedEventDataFromHIR(expr, ctx) {
+  if (expr.kind !== "ArrowFunction" && expr.kind !== "FunctionExpression") {
+    return null;
+  }
+  let bodyExpr = null;
+  if (expr.kind === "ArrowFunction") {
+    if (expr.isExpression && !Array.isArray(expr.body)) {
+      bodyExpr = expr.body;
+    }
+  }
+  if (!bodyExpr || bodyExpr.kind !== "CallExpression") {
+    return null;
+  }
+  const callee = bodyExpr.callee;
+  if (callee.kind !== "Identifier") {
+    return null;
+  }
+  if (bodyExpr.arguments.length !== 1) {
+    return null;
+  }
+  if (callee.kind === "Identifier") {
+    const handlerName = deSSAVarName(callee.name);
+    const isTrackedAccessor = ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName);
+    if (isTrackedAccessor) {
+      return null;
+    }
+  }
+  const paramNames = new Set(expr.params.map((p) => p.name));
+  const dataExpr = bodyExpr.arguments[0];
+  if (!dataExpr) {
+    return null;
+  }
+  if (hirExpressionUsesIdentifiers(dataExpr, paramNames)) {
+    return null;
+  }
+  return {
+    handler: callee,
+    data: dataExpr
+  };
+}
+function hirExpressionUsesIdentifiers(expr, names) {
+  if (expr.kind === "Identifier") {
+    return names.has(deSSAVarName(expr.name));
+  }
+  switch (expr.kind) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return hirExpressionUsesIdentifiers(expr.left, names) || hirExpressionUsesIdentifiers(expr.right, names);
+    case "UnaryExpression":
+      return hirExpressionUsesIdentifiers(expr.argument, names);
+    case "ConditionalExpression":
+      return hirExpressionUsesIdentifiers(expr.test, names) || hirExpressionUsesIdentifiers(expr.consequent, names) || hirExpressionUsesIdentifiers(expr.alternate, names);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return hirExpressionUsesIdentifiers(expr.callee, names) || expr.arguments.some((arg) => hirExpressionUsesIdentifiers(arg, names));
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return hirExpressionUsesIdentifiers(expr.object, names) || expr.computed && hirExpressionUsesIdentifiers(expr.property, names);
+    case "ArrayExpression":
+      return expr.elements.some((el) => el && hirExpressionUsesIdentifiers(el, names));
+    case "ObjectExpression":
+      return expr.properties.some((prop) => {
+        if (prop.kind === "SpreadElement") {
+          return hirExpressionUsesIdentifiers(prop.argument, names);
+        }
+        return hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
+      });
+    case "TemplateLiteral":
+      return expr.expressions.some((e) => hirExpressionUsesIdentifiers(e, names));
+    case "ArrowFunction":
+    case "FunctionExpression":
+      return false;
+    default:
+      return false;
+  }
+}
 function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   if (ctx.t.isCallExpression(expr) && ctx.t.isIdentifier(expr.callee)) {
     if (expr.arguments.length !== 0) return null;
@@ -23238,8 +23377,13 @@ function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   }
   return null;
 }
-function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
+function rewriteSelectorExpression(expr, itemParamName, keyParamName, getSelectorId, ctx) {
   const { t: t2 } = ctx;
+  const usesParamIdentifier = (e) => {
+    if (expressionUsesIdentifier(e, itemParamName, t2)) return true;
+    if (keyParamName && expressionUsesIdentifier(e, keyParamName, t2)) return true;
+    return false;
+  };
   if (t2.isBinaryExpression(expr) && (expr.operator === "===" || expr.operator === "==")) {
     const leftTracked = getTrackedCallIdentifier(
       expr.left,
@@ -23251,7 +23395,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
       ctx,
       itemParamName
     );
-    if (leftTracked && expressionUsesIdentifier(expr.right, itemParamName, t2)) {
+    if (leftTracked && usesParamIdentifier(expr.right)) {
       return {
         expr: t2.callExpression(getSelectorId(leftTracked), [
           expr.right
@@ -23259,7 +23403,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
         changed: true
       };
     }
-    if (rightTracked && expressionUsesIdentifier(expr.left, itemParamName, t2)) {
+    if (rightTracked && usesParamIdentifier(expr.left)) {
       return {
         expr: t2.callExpression(getSelectorId(rightTracked), [
           expr.left
@@ -23270,7 +23414,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   let changed = false;
   const rewrite = (node) => {
-    const result = rewriteSelectorExpression(node, itemParamName, getSelectorId, ctx);
+    const result = rewriteSelectorExpression(node, itemParamName, keyParamName, getSelectorId, ctx);
     if (result.changed) changed = true;
     return result.expr;
   };
@@ -23331,7 +23475,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   return { expr, changed };
 }
-function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
+function applySelectorHoist(callbackExpr, itemParamName, keyParamName, statements, ctx) {
   const { t: t2 } = ctx;
   if (!itemParamName) return;
   if (!t2.isArrowFunctionExpression(callbackExpr) && !t2.isFunctionExpression(callbackExpr)) return;
@@ -23347,7 +23491,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
     if (t2.isBlockStatement(fn.body)) {
       for (const stmt of fn.body.body) {
         if (t2.isReturnStatement(stmt) && stmt.argument && t2.isExpression(stmt.argument)) {
-          const result = rewriteSelectorExpression(stmt.argument, itemParamName, getSelectorId, ctx);
+          const result = rewriteSelectorExpression(
+            stmt.argument,
+            itemParamName,
+            keyParamName,
+            getSelectorId,
+            ctx
+          );
           if (result.changed) {
             stmt.argument = result.expr;
           }
@@ -23356,7 +23506,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
       return;
     }
     if (t2.isExpression(fn.body)) {
-      const result = rewriteSelectorExpression(fn.body, itemParamName, getSelectorId, ctx);
+      const result = rewriteSelectorExpression(
+        fn.body,
+        itemParamName,
+        keyParamName,
+        getSelectorId,
+        ctx
+      );
       if (result.changed) {
         fn.body = result.expr;
       }
@@ -23520,7 +23676,14 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
   const listId = genTemp(ctx, "list");
   if (isKeyed) {
     const itemParamName = t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr) ? t2.isIdentifier(callbackExpr.params[0]) ? callbackExpr.params[0].name : null : null;
-    applySelectorHoist(callbackExpr, itemParamName, statements, ctx);
+    const keyParamName = ctx.listKeyParamName ?? null;
+    applySelectorHoist(
+      callbackExpr,
+      itemParamName,
+      keyParamName,
+      statements,
+      ctx
+    );
   }
   if (isKeyed && keyExpr) {
     let keyExprAst = lowerExpression(keyExpr, ctx);

package/dist/index.js

@@ -18331,7 +18331,8 @@ function lowerNodeWithRegionContext(node, t2, ctx, declaredVars, regionCtx) {
         t2.blockStatement(conseqStmts),
         altStmts ? t2.blockStatement(altStmts) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -18559,31 +18560,53 @@ function lowerStructuredNodeForRegion(node, region, t2, ctx, declaredVars, regio
       return stmt ? [stmt] : [];
     }
     case "if": {
-      const consequent = lowerStructuredNodeForRegion(
-        node.consequent,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      );
-      const alternate = node.alternate ? lowerStructuredNodeForRegion(
-        node.alternate,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      ) : [];
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const baseShouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx);
+      const lowerChild = (child, forceNonReactive) => {
+        if (!child) return [];
+        if (!forceNonReactive) {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        }
+        const prevDepth = ctx.nonReactiveScopeDepth ?? 0;
+        ctx.nonReactiveScopeDepth = prevDepth + 1;
+        try {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        } finally {
+          ctx.nonReactiveScopeDepth = prevDepth;
+        }
+      };
+      let consequent = lowerChild(node.consequent, baseShouldWrapEffect);
+      let alternate = node.alternate ? lowerChild(node.alternate, baseShouldWrapEffect) : [];
       if (consequent.length === 0 && alternate.length === 0) return [];
-      const ifStmt = t2.ifStatement(
+      const buildIfStmt = (cons, alt) => t2.ifStatement(
         lowerExpressionWithDeSSA(node.test, ctx),
-        t2.blockStatement(consequent),
-        alternate.length > 0 ? t2.blockStatement(alternate) : null
+        t2.blockStatement(cons),
+        alt.length > 0 ? t2.blockStatement(alt) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      let ifStmt = buildIfStmt(consequent, alternate);
+      const shouldWrapEffect = baseShouldWrapEffect && !statementHasEarlyExit(ifStmt, t2);
+      if (!shouldWrapEffect && baseShouldWrapEffect) {
+        consequent = lowerChild(node.consequent, false);
+        alternate = node.alternate ? lowerChild(node.alternate, false) : [];
+        if (consequent.length === 0 && alternate.length === 0) return [];
+        ifStmt = buildIfStmt(consequent, alternate);
+      }
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -19610,7 +19633,8 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       (dep) => ctx.trackedVars.has(deSSAVarName(dep))
     );
     const usesTracked = expressionUsesTracked(instr.value, ctx);
-    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && (usesTracked || hasTrackedControlDep);
+    const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && !inNonReactiveScope && (usesTracked || hasTrackedControlDep);
     if (shouldWrapExpr) {
       ctx.helpersUsed.add("useEffect");
       ctx.needsCtx = true;
@@ -21439,7 +21463,7 @@ function lowerExpression(expr, ctx, isAssigned = false) {
     ctx.expressionDepth = depth - 1;
   }
 }
-function lowerExpressionImpl(expr, ctx, isAssigned = false) {
+function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
   const { t: t2 } = ctx;
   const mapParams = (params) => params.map((p) => t2.identifier(deSSAVarName(p.name)));
   const withFunctionScope = (paramNames, fn) => {
@@ -21501,11 +21525,7 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
       };
       const declared = new Set(paramIds.map((p) => p.name));
       return lowerStructuredNodeWithoutRegions(structured, t2, ctx, declared);
-    } catch (e) {
-      console.log(
-        "[DEBUG] Structurization failed, falling back to lowerBlocksToStatements via lowerInstruction",
-        e
-      );
+    } catch {
       return lowerBlocksToStatements(blocks);
     }
   };
@@ -21684,12 +21704,10 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
     case "ArrowFunction": {
       const paramIds = mapParams(expr.params);
       const shadowed = new Set(expr.params.map((p) => deSSAVarName(p.name)));
-      return withFunctionScope(shadowed, () => {
-        if (isAssigned) {
-          ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) + 1;
-        }
-        let fn;
-        try {
+      return withNonReactiveScope(
+        ctx,
+        () => withFunctionScope(shadowed, () => {
+          let fn;
           if (expr.isExpression && !Array.isArray(expr.body)) {
             const { result: bodyExpr, cacheDeclarations } = withGetterCache(
               ctx,
@@ -21717,12 +21735,8 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
           }
           fn.async = expr.isAsync ?? false;
           return fn;
-        } finally {
-          if (isAssigned) {
-            ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) - 1;
-          }
-        }
-      });
+        })
+      );
     }
     case "FunctionExpression": {
       const paramIds = mapParams(expr.params);
@@ -22734,114 +22748,151 @@ function lowerIntrinsicElement(jsx, ctx) {
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx);
     if (binding.type === "event" && binding.expr && binding.name) {
-      const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
-      const prevWrapTracked = ctx.wrapTrackedExpressions;
-      ctx.wrapTrackedExpressions = false;
-      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
-        skipHookAccessors: true,
-        skipRegionRootOverride: true
-      });
-      ctx.wrapTrackedExpressions = prevWrapTracked;
-      const eventParam = t2.identifier("_e");
-      const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
-      const ensureHandlerParam = (fn) => {
-        if (t2.isArrowFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
-        }
-        if (t2.isFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
-        }
-        return t2.arrowFunctionExpression(
-          [eventParam],
-          t2.callExpression(fn, [eventParam])
-        );
-      };
-      const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
-      const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
-      if (isDelegated) {
+      const hirDataBinding = isDelegated && binding.expr ? extractDelegatedEventDataFromHIR(binding.expr, ctx) : null;
+      if (hirDataBinding) {
         ctx.delegatedEventsUsed?.add(eventName);
-        const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
-        const normalizeHandler = (expr) => {
-          if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
-            return expr.callee;
-          }
-          return expr;
-        };
-        const normalizedDataHandler = dataBinding !== null ? normalizeHandler(dataBinding?.handler ?? handlerExpr) : null;
-        const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
-        const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
-        const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
-        let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
-        if (dataForDelegate) {
-          let payloadExpr;
-          if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
-            payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
-          } else {
-            payloadExpr = t2.callExpression(dataForDelegate, []);
-          }
-          handlerToAssign = t2.arrowFunctionExpression(
-            [eventParam],
-            t2.callExpression(handlerForDelegate, [payloadExpr])
-          );
-        }
+        const handlerExpr = lowerExpression(hirDataBinding.handler, ctx);
+        const dataExpr = lowerDomExpression(hirDataBinding.data, ctx, containingRegion, {
+          skipHookAccessors: false,
+          skipRegionRootOverride: true
+        });
+        const dataParam = t2.identifier("__data");
+        const eventParam = t2.identifier("_e");
+        const wrappedHandler = t2.arrowFunctionExpression(
+          [dataParam, eventParam],
+          t2.callExpression(handlerExpr, [dataParam])
+        );
         statements.push(
           t2.expressionStatement(
             t2.assignmentExpression(
               "=",
               t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
-              handlerToAssign
+              wrappedHandler
             )
           )
         );
-        if (dataForDelegate) {
+        const dataGetter = t2.arrowFunctionExpression([], dataExpr);
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+              dataGetter
+            )
+          )
+        );
+      } else {
+        const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
+        const prevWrapTracked = ctx.wrapTrackedExpressions;
+        ctx.wrapTrackedExpressions = false;
+        const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
+          skipHookAccessors: true,
+          skipRegionRootOverride: true
+        });
+        ctx.wrapTrackedExpressions = prevWrapTracked;
+        const eventParam = t2.identifier("_e");
+        const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
+        const ensureHandlerParam = (fn) => {
+          if (t2.isArrowFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
+          }
+          if (t2.isFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+          }
+          return t2.arrowFunctionExpression(
+            [eventParam],
+            t2.callExpression(fn, [eventParam])
+          );
+        };
+        const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
+        const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
+        if (isDelegated) {
+          ctx.delegatedEventsUsed?.add(eventName);
+          const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
+          const normalizeHandler = (expr) => {
+            if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
+              return expr.callee;
+            }
+            return expr;
+          };
+          const normalizedDataHandler = dataBinding !== null ? normalizeHandler(
+            dataBinding?.handler ?? handlerExpr
+          ) : null;
+          const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
+          const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
+          const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
+          let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
+          if (dataForDelegate) {
+            let payloadExpr;
+            if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
+              payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
+            } else {
+              payloadExpr = t2.callExpression(dataForDelegate, []);
+            }
+            handlerToAssign = t2.arrowFunctionExpression(
+              [eventParam],
+              t2.callExpression(handlerForDelegate, [payloadExpr])
+            );
+          }
           statements.push(
             t2.expressionStatement(
               t2.assignmentExpression(
                 "=",
-                t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
-                dataForDelegate
+                t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
+                handlerToAssign
               )
             )
           );
-        }
-      } else {
-        ctx.helpersUsed.add("bindEvent");
-        ctx.helpersUsed.add("onDestroy");
-        const cleanupId = genTemp(ctx, "evt");
-        const args = [
-          targetId,
-          t2.stringLiteral(eventName),
-          handlerExpr
-        ];
-        if (hasEventOptions && binding.eventOptions) {
-          const optionProps = [];
-          if (binding.eventOptions.capture) {
-            optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
-          }
-          if (binding.eventOptions.passive) {
-            optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+          if (dataForDelegate) {
+            statements.push(
+              t2.expressionStatement(
+                t2.assignmentExpression(
+                  "=",
+                  t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+                  dataForDelegate
+                )
+              )
+            );
           }
-          if (binding.eventOptions.once) {
-            optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+        } else {
+          ctx.helpersUsed.add("bindEvent");
+          ctx.helpersUsed.add("onDestroy");
+          const cleanupId = genTemp(ctx, "evt");
+          const args = [
+            targetId,
+            t2.stringLiteral(eventName),
+            handlerExpr
+          ];
+          if (hasEventOptions && binding.eventOptions) {
+            const optionProps = [];
+            if (binding.eventOptions.capture) {
+              optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.passive) {
+              optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.once) {
+              optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+            }
+            args.push(t2.objectExpression(optionProps));
           }
-          args.push(t2.objectExpression(optionProps));
-        }
-        statements.push(
-          t2.variableDeclaration("const", [
-            t2.variableDeclarator(
-              cleanupId,
-              t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+          statements.push(
+            t2.variableDeclaration("const", [
+              t2.variableDeclarator(
+                cleanupId,
+                t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+              )
+            ]),
+            t2.expressionStatement(
+              t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
             )
-          ]),
-          t2.expressionStatement(
-            t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
-          )
-        );
+          );
+        }
       }
     } else if (binding.type === "attr" && binding.name) {
       const attrName = binding.name;
@@ -22903,16 +22954,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         t2.expressionStatement(lowerDomExpression(binding.expr, ctx, containingRegion))
       );
     } else if (binding.type === "text" && binding.expr) {
-      ctx.helpersUsed.add("bindText");
       const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
-      statements.push(
-        t2.expressionStatement(
-          t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
-            targetId,
-            t2.arrowFunctionExpression([], valueExpr)
-          ])
-        )
-      );
+      if (isExpressionReactive(binding.expr, ctx)) {
+        ctx.helpersUsed.add("bindText");
+        statements.push(
+          t2.expressionStatement(
+            t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
+              targetId,
+              t2.arrowFunctionExpression([], valueExpr)
+            ])
+          )
+        );
+      } else {
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier("data")),
+              t2.callExpression(t2.identifier("String"), [valueExpr])
+            )
+          )
+        );
+      }
     } else if (binding.type === "child" && binding.expr) {
       emitHIRChildBinding(targetId, binding.expr, statements, ctx, containingRegion);
     }
@@ -23216,6 +23279,82 @@ function extractDelegatedEventData(expr, t2) {
     data: dataArg && t2.isExpression(dataArg) ? dataArg : void 0
   };
 }
+function extractDelegatedEventDataFromHIR(expr, ctx) {
+  if (expr.kind !== "ArrowFunction" && expr.kind !== "FunctionExpression") {
+    return null;
+  }
+  let bodyExpr = null;
+  if (expr.kind === "ArrowFunction") {
+    if (expr.isExpression && !Array.isArray(expr.body)) {
+      bodyExpr = expr.body;
+    }
+  }
+  if (!bodyExpr || bodyExpr.kind !== "CallExpression") {
+    return null;
+  }
+  const callee = bodyExpr.callee;
+  if (callee.kind !== "Identifier") {
+    return null;
+  }
+  if (bodyExpr.arguments.length !== 1) {
+    return null;
+  }
+  if (callee.kind === "Identifier") {
+    const handlerName = deSSAVarName(callee.name);
+    const isTrackedAccessor = ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName);
+    if (isTrackedAccessor) {
+      return null;
+    }
+  }
+  const paramNames = new Set(expr.params.map((p) => p.name));
+  const dataExpr = bodyExpr.arguments[0];
+  if (!dataExpr) {
+    return null;
+  }
+  if (hirExpressionUsesIdentifiers(dataExpr, paramNames)) {
+    return null;
+  }
+  return {
+    handler: callee,
+    data: dataExpr
+  };
+}
+function hirExpressionUsesIdentifiers(expr, names) {
+  if (expr.kind === "Identifier") {
+    return names.has(deSSAVarName(expr.name));
+  }
+  switch (expr.kind) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return hirExpressionUsesIdentifiers(expr.left, names) || hirExpressionUsesIdentifiers(expr.right, names);
+    case "UnaryExpression":
+      return hirExpressionUsesIdentifiers(expr.argument, names);
+    case "ConditionalExpression":
+      return hirExpressionUsesIdentifiers(expr.test, names) || hirExpressionUsesIdentifiers(expr.consequent, names) || hirExpressionUsesIdentifiers(expr.alternate, names);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return hirExpressionUsesIdentifiers(expr.callee, names) || expr.arguments.some((arg) => hirExpressionUsesIdentifiers(arg, names));
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return hirExpressionUsesIdentifiers(expr.object, names) || expr.computed && hirExpressionUsesIdentifiers(expr.property, names);
+    case "ArrayExpression":
+      return expr.elements.some((el) => el && hirExpressionUsesIdentifiers(el, names));
+    case "ObjectExpression":
+      return expr.properties.some((prop) => {
+        if (prop.kind === "SpreadElement") {
+          return hirExpressionUsesIdentifiers(prop.argument, names);
+        }
+        return hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
+      });
+    case "TemplateLiteral":
+      return expr.expressions.some((e) => hirExpressionUsesIdentifiers(e, names));
+    case "ArrowFunction":
+    case "FunctionExpression":
+      return false;
+    default:
+      return false;
+  }
+}
 function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   if (ctx.t.isCallExpression(expr) && ctx.t.isIdentifier(expr.callee)) {
     if (expr.arguments.length !== 0) return null;
@@ -23226,8 +23365,13 @@ function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   }
   return null;
 }
-function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
+function rewriteSelectorExpression(expr, itemParamName, keyParamName, getSelectorId, ctx) {
   const { t: t2 } = ctx;
+  const usesParamIdentifier = (e) => {
+    if (expressionUsesIdentifier(e, itemParamName, t2)) return true;
+    if (keyParamName && expressionUsesIdentifier(e, keyParamName, t2)) return true;
+    return false;
+  };
   if (t2.isBinaryExpression(expr) && (expr.operator === "===" || expr.operator === "==")) {
     const leftTracked = getTrackedCallIdentifier(
       expr.left,
@@ -23239,7 +23383,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
       ctx,
       itemParamName
     );
-    if (leftTracked && expressionUsesIdentifier(expr.right, itemParamName, t2)) {
+    if (leftTracked && usesParamIdentifier(expr.right)) {
       return {
         expr: t2.callExpression(getSelectorId(leftTracked), [
           expr.right
@@ -23247,7 +23391,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
         changed: true
       };
     }
-    if (rightTracked && expressionUsesIdentifier(expr.left, itemParamName, t2)) {
+    if (rightTracked && usesParamIdentifier(expr.left)) {
       return {
         expr: t2.callExpression(getSelectorId(rightTracked), [
           expr.left
@@ -23258,7 +23402,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   let changed = false;
   const rewrite = (node) => {
-    const result = rewriteSelectorExpression(node, itemParamName, getSelectorId, ctx);
+    const result = rewriteSelectorExpression(node, itemParamName, keyParamName, getSelectorId, ctx);
     if (result.changed) changed = true;
     return result.expr;
   };
@@ -23319,7 +23463,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   return { expr, changed };
 }
-function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
+function applySelectorHoist(callbackExpr, itemParamName, keyParamName, statements, ctx) {
   const { t: t2 } = ctx;
   if (!itemParamName) return;
   if (!t2.isArrowFunctionExpression(callbackExpr) && !t2.isFunctionExpression(callbackExpr)) return;
@@ -23335,7 +23479,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
     if (t2.isBlockStatement(fn.body)) {
       for (const stmt of fn.body.body) {
         if (t2.isReturnStatement(stmt) && stmt.argument && t2.isExpression(stmt.argument)) {
-          const result = rewriteSelectorExpression(stmt.argument, itemParamName, getSelectorId, ctx);
+          const result = rewriteSelectorExpression(
+            stmt.argument,
+            itemParamName,
+            keyParamName,
+            getSelectorId,
+            ctx
+          );
           if (result.changed) {
             stmt.argument = result.expr;
           }
@@ -23344,7 +23494,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
       return;
     }
     if (t2.isExpression(fn.body)) {
-      const result = rewriteSelectorExpression(fn.body, itemParamName, getSelectorId, ctx);
+      const result = rewriteSelectorExpression(
+        fn.body,
+        itemParamName,
+        keyParamName,
+        getSelectorId,
+        ctx
+      );
       if (result.changed) {
         fn.body = result.expr;
       }
@@ -23508,7 +23664,14 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
   const listId = genTemp(ctx, "list");
   if (isKeyed) {
     const itemParamName = t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr) ? t2.isIdentifier(callbackExpr.params[0]) ? callbackExpr.params[0].name : null : null;
-    applySelectorHoist(callbackExpr, itemParamName, statements, ctx);
+    const keyParamName = ctx.listKeyParamName ?? null;
+    applySelectorHoist(
+      callbackExpr,
+      itemParamName,
+      keyParamName,
+      statements,
+      ctx
+    );
   }
   if (isKeyed && keyExpr) {
     let keyExprAst = lowerExpression(keyExpr, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/compiler",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Babel plugin for Fict Compiler",
   "publishConfig": {
     "access": "public",
@@ -45,7 +45,7 @@
     "@types/babel__helper-plugin-utils": "^7.10.3",
     "@types/babel__traverse": "^7.28.0",
     "tsup": "^8.5.1",
-    "@fictjs/runtime": "0.0.9"
+    "@fictjs/runtime": "0.0.11"
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",