@fictjs/compiler 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -16719,10 +16719,12 @@ function convertJSXMemberExpr(node) {
   };
 }
 
-// src/fine-grained-dom.ts
+// src/ir/dependency-key.ts
 function normalizeDependencyKey(name) {
-  return name.split(".").map((part) => part.replace(/_\d+$/, "")).join(".");
+  return name.split(".").map((part) => getSSABaseName(part)).join(".");
 }
+
+// src/fine-grained-dom.ts
 function applyRegionMetadata(state, options) {
   if (!options.region) return;
   const region = options.region;
@@ -19942,15 +19944,38 @@ function buildEffectCall(ctx, t4, effectFn, options) {
   }
   return t4.callExpression(t4.identifier(RUNTIME_ALIASES.useEffect), args);
 }
-function buildMemoCall(ctx, t4, memoFn, slot) {
+function buildMemoCall(ctx, t4, memoFn, options) {
+  const slot = options?.slot;
+  const memoOptionsProperties = [];
+  if (options?.name) {
+    memoOptionsProperties.push(
+      t4.objectProperty(t4.identifier("name"), t4.stringLiteral(options.name))
+    );
+  }
+  if (options?.source) {
+    memoOptionsProperties.push(
+      t4.objectProperty(t4.identifier("devToolsSource"), t4.stringLiteral(options.source))
+    );
+  }
+  if (options?.internal) {
+    memoOptionsProperties.push(t4.objectProperty(t4.identifier("internal"), t4.booleanLiteral(true)));
+  }
+  const memoOptions = memoOptionsProperties.length > 0 ? t4.objectExpression(memoOptionsProperties) : null;
   if (ctx.inModule) {
     ctx.helpersUsed.add("memo");
-    return t4.callExpression(t4.identifier(RUNTIME_ALIASES.memo), [memoFn]);
+    const args2 = [memoFn];
+    if (memoOptions) args2.push(memoOptions);
+    return t4.callExpression(t4.identifier(RUNTIME_ALIASES.memo), args2);
   }
   ctx.helpersUsed.add("useMemo");
   ctx.needsCtx = true;
   const args = [t4.identifier("__fictCtx"), memoFn];
-  if (slot !== void 0 && slot >= 0) {
+  if (memoOptions) {
+    args.push(memoOptions);
+    if (slot !== void 0 && slot >= 0) {
+      args.push(t4.numericLiteral(slot));
+    }
+  } else if (slot !== void 0 && slot >= 0) {
     args.push(t4.numericLiteral(slot));
   }
   return t4.callExpression(t4.identifier(RUNTIME_ALIASES.useMemo), args);
@@ -21211,7 +21236,10 @@ function wrapInMemo(region, t4, declaredVars, ctx, bodyStatementsOverride, outpu
     const returnObj = t4.objectExpression(uniqueOutputNames.map((name) => buildOutputProperty(name)));
     const memoBody = t4.blockStatement([...bodyStatements, t4.returnStatement(returnObj)]);
     const slot = ctx.inModule ? void 0 : reserveHookSlot(ctx);
-    const memoCall = buildMemoCall(ctx, t4, t4.arrowFunctionExpression([], memoBody), slot);
+    const memoCall = buildMemoCall(ctx, t4, t4.arrowFunctionExpression([], memoBody), {
+      slot,
+      internal: true
+    });
     const regionVarName = `__region_${region.id}`;
     statements.push(
       t4.variableDeclaration("const", [t4.variableDeclarator(t4.identifier(regionVarName), memoCall)])
@@ -21470,7 +21498,10 @@ function generateLazyConditionalMemo(region, orderedOutputs, bodyStatements, con
     ctx,
     t4,
     t4.arrowFunctionExpression([], t4.blockStatement(memoBody)),
-    ctx.inModule ? void 0 : reserveHookSlot(ctx)
+    {
+      slot: ctx.inModule ? void 0 : reserveHookSlot(ctx),
+      internal: true
+    }
   );
   statements.push(
     t4.variableDeclaration("const", [t4.variableDeclarator(t4.identifier(regionVarName), memoCall)])
@@ -21583,7 +21614,12 @@ Context: ${location}`
     };
     const buildDerivedMemoCall = (expr) => {
       const slot = !ctx.inModule && inRegionMemo ? reserveHookSlot(ctx) : void 0;
-      return buildMemoCall(ctx, t4, t4.arrowFunctionExpression([], expr), slot);
+      const source = ctx.options?.dev !== false && instr.loc ? `${ctx.options?.filename ?? ""}:${instr.loc.start.line}:${instr.loc.start.column}` : void 0;
+      return buildMemoCall(ctx, t4, t4.arrowFunctionExpression([], expr), {
+        slot,
+        name: baseName2,
+        source
+      });
     };
     if (isShadowDeclaration && declKind) {
       ctx.trackedVars.delete(baseName2);
@@ -22945,7 +22981,7 @@ function expressionUsesIdentifier(expr, name, t4) {
   visit(expr);
   return found;
 }
-function extractDelegatedEventData(expr, t4) {
+function extractDelegatedEventData(expr, t4, options) {
   const isSimpleHandler = t4.isIdentifier(expr) || t4.isMemberExpression(expr);
   if (isSimpleHandler) {
     return { handler: expr };
@@ -22958,6 +22994,9 @@ function extractDelegatedEventData(expr, t4) {
   if (!bodyExpr || !t4.isCallExpression(bodyExpr)) return null;
   if (paramNames.some((name) => expressionUsesIdentifier(bodyExpr, name, t4))) return null;
   if (!t4.isIdentifier(bodyExpr.callee)) return null;
+  if (options?.isKnownHandlerIdentifier && !options.isKnownHandlerIdentifier(bodyExpr.callee.name)) {
+    return null;
+  }
   if (bodyExpr.arguments.length === 0) return null;
   if (bodyExpr.arguments.length > 1) return null;
   const dataArg = bodyExpr.arguments[0];
@@ -23020,6 +23059,10 @@ function extractDelegatedEventDataFromHIR(expr, ctx) {
     return null;
   }
   const handlerName = callee.name;
+  const normalizedHandlerName = deSSAVarName(handlerName);
+  if (!ctx.functionVars?.has(normalizedHandlerName)) {
+    return null;
+  }
   if (ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName) || ctx.storeVars?.has(handlerName) || ctx.trackedVars.has(handlerName)) {
     return null;
   }
@@ -23030,7 +23073,10 @@ function extractDelegatedEventDataFromHIR(expr, ctx) {
   if (isTrackedAccessor) {
     return null;
   }
-  const paramNames = new Set(expr.params.map((p) => p.name));
+  const paramNames = new Set(expr.params.map((p) => deSSAVarName(p.name)));
+  if (paramNames.has(deSSAVarName(callee.name))) {
+    return null;
+  }
   const dataExpr = bodyExpr.arguments[0];
   if (!dataExpr) {
     return null;
@@ -24171,7 +24217,7 @@ function extractKeyFromMapCallback(callback) {
 
 // src/ir/codegen-overrides.ts
 function normalizeDependencyKey2(name) {
-  return name.split(".").map((part) => deSSAVarName(part)).join(".");
+  return normalizeDependencyKey(name);
 }
 function getDependencyPathFromNode(node, t4) {
   if (t4.isIdentifier(node)) {
@@ -24197,8 +24243,8 @@ function getDependencyPathFromNode(node, t4) {
   }
   return null;
 }
-function replaceIdentifiersWithOverrides(node, overrides, t4, parentKind, parentKey, skipCurrentNode = false) {
-  const isCallTarget = parentKey === "callee" && (parentKind === "CallExpression" || parentKind === "OptionalCallExpression");
+function replaceIdentifiersWithOverrides(node, overrides, t4, parentKind, parentKey, skipCurrentNode = false, allowCallCalleeReplacement = false) {
+  const isCallTarget = !allowCallCalleeReplacement && parentKey === "callee" && (parentKind === "CallExpression" || parentKind === "OptionalCallExpression");
   if (parentKind === "VariableDeclarator" && parentKey === "id") {
     return;
   }
@@ -24270,9 +24316,25 @@ function replaceIdentifiersWithOverrides(node, overrides, t4, parentKind, parent
       }
     }
     if (t4.isBlockStatement(node.body)) {
-      replaceIdentifiersWithOverrides(node.body, scopedOverrides, t4, node.type, "body");
+      replaceIdentifiersWithOverrides(
+        node.body,
+        scopedOverrides,
+        t4,
+        node.type,
+        "body",
+        false,
+        allowCallCalleeReplacement
+      );
     } else {
-      replaceIdentifiersWithOverrides(node.body, scopedOverrides, t4, node.type, "body");
+      replaceIdentifiersWithOverrides(
+        node.body,
+        scopedOverrides,
+        t4,
+        node.type,
+        "body",
+        false,
+        allowCallCalleeReplacement
+      );
     }
     return;
   }
@@ -24300,12 +24362,21 @@ function replaceIdentifiersWithOverrides(node, overrides, t4, parentKind, parent
             t4,
             node.type,
             key,
-            false
+            false,
+            allowCallCalleeReplacement
           );
         }
       }
     } else if (value && typeof value === "object" && "type" in value) {
-      replaceIdentifiersWithOverrides(value, overrides, t4, node.type, key);
+      replaceIdentifiersWithOverrides(
+        value,
+        overrides,
+        t4,
+        node.type,
+        key,
+        false,
+        allowCallCalleeReplacement
+      );
     }
   }
 }
@@ -24578,6 +24649,124 @@ function applySelectorHoist(callbackExpr, itemParamName, keyParamName, statement
 }
 
 // src/ir/codegen-list-child.ts
+function getCallbackBlocks(callback) {
+  if (callback.kind === "FunctionExpression") {
+    return callback.body;
+  }
+  if (callback.kind === "ArrowFunction" && Array.isArray(callback.body)) {
+    return callback.body;
+  }
+  return [];
+}
+function collectMapCallbackAliasDeclarations(callback) {
+  const blocks = getCallbackBlocks(callback);
+  if (blocks.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const paramNames = callback.kind === "ArrowFunction" || callback.kind === "FunctionExpression" ? new Set(callback.params.map((param) => param.name)) : /* @__PURE__ */ new Set();
+  const declarationState = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    for (const instr of block.instructions) {
+      if (instr.kind !== "Assign" || instr.target.kind !== "Identifier") {
+        continue;
+      }
+      const name = instr.target.name;
+      if (paramNames.has(name)) continue;
+      const isDeclaration = !!instr.declarationKind;
+      const previous = declarationState.get(name);
+      if (previous) {
+        declarationState.set(name, {
+          declarationCount: previous.declarationCount + (isDeclaration ? 1 : 0),
+          hasNonDeclarationWrite: previous.hasNonDeclarationWrite || !isDeclaration,
+          declarationValue: previous.declarationValue,
+          lastAssignedValue: instr.value
+        });
+      } else {
+        declarationState.set(name, {
+          declarationCount: isDeclaration ? 1 : 0,
+          hasNonDeclarationWrite: !isDeclaration,
+          declarationValue: isDeclaration ? instr.value : null,
+          lastAssignedValue: instr.value
+        });
+      }
+    }
+  }
+  const aliasMap = /* @__PURE__ */ new Map();
+  const effectiveBlocks = blocks.filter(
+    (block) => block.instructions.length > 0 || block.terminator.kind !== "Unreachable"
+  );
+  const isSingleLinearBlock = effectiveBlocks.length === 1 && effectiveBlocks[0].terminator.kind === "Return";
+  for (const [name, state] of declarationState) {
+    if (isSingleLinearBlock) {
+      if (state.declarationCount <= 1) {
+        aliasMap.set(name, state.lastAssignedValue);
+      }
+      continue;
+    }
+    if (state.declarationCount === 1 && !state.hasNonDeclarationWrite && state.declarationValue) {
+      aliasMap.set(name, state.declarationValue);
+    }
+  }
+  return aliasMap;
+}
+function resolveMapCallbackKeyExpression(keyExpr, callback) {
+  if (keyExpr.kind !== "Identifier") {
+    return keyExpr;
+  }
+  const aliasMap = collectMapCallbackAliasDeclarations(callback);
+  if (aliasMap.size === 0) {
+    return keyExpr;
+  }
+  let resolved = keyExpr;
+  const seen = /* @__PURE__ */ new Set();
+  while (resolved.kind === "Identifier") {
+    const next = aliasMap.get(resolved.name);
+    if (!next || seen.has(resolved.name)) break;
+    seen.add(resolved.name);
+    resolved = next;
+  }
+  return resolved;
+}
+function collectMapCallbackLocalNames(callback) {
+  const blocks = getCallbackBlocks(callback);
+  if (blocks.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const paramNames = callback.kind === "ArrowFunction" || callback.kind === "FunctionExpression" ? new Set(callback.params.map((param) => deSSAVarName(param.name))) : /* @__PURE__ */ new Set();
+  const locals = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    for (const instr of block.instructions) {
+      if (instr.kind === "Assign" && instr.target.kind === "Identifier") {
+        const name = deSSAVarName(instr.target.name);
+        if (!paramNames.has(name)) locals.add(name);
+      }
+      if (instr.kind === "Phi" && instr.target.kind === "Identifier") {
+        const name = deSSAVarName(instr.target.name);
+        if (!paramNames.has(name)) locals.add(name);
+      }
+    }
+  }
+  return locals;
+}
+function hasUnresolvedCallbackLocalKeyDependencies(keyExpr, callback, keyAliasDeclarations) {
+  const callbackLocals = collectMapCallbackLocalNames(callback);
+  if (callbackLocals.size === 0) {
+    return false;
+  }
+  const resolvableAliases = new Set(
+    Array.from(keyAliasDeclarations.keys()).map((name) => deSSAVarName(name))
+  );
+  const deps = /* @__PURE__ */ new Set();
+  collectExpressionDependencies(keyExpr, deps);
+  for (const dep of deps) {
+    const base = dep.split(".")[0] ?? dep;
+    if (!base) continue;
+    if (callbackLocals.has(base) && !resolvableAliases.has(base)) {
+      return true;
+    }
+  }
+  return false;
+}
 function buildListCallExpression(expr, statements, ctx, ops) {
   const { t: t4 } = ctx;
   if (expr.kind !== "CallExpression" && expr.kind !== "OptionalCallExpression") {
@@ -24596,7 +24785,8 @@ function buildListCallExpression(expr, statements, ctx, ops) {
   if (!mapCallback) {
     throw new Error("map callback is required");
   }
-  const keyExpr = extractKeyFromMapCallback(mapCallback);
+  const extractedKeyExpr = extractKeyFromMapCallback(mapCallback);
+  const keyExpr = extractedKeyExpr ? resolveMapCallbackKeyExpression(extractedKeyExpr, mapCallback) : void 0;
   const isKeyed = !!keyExpr;
   const hasRestParam = (mapCallback.kind === "ArrowFunction" || mapCallback.kind === "FunctionExpression") && Array.isArray(mapCallback.rawParams) && mapCallback.rawParams.some((param) => t4.isRestElement(param));
   const canConstifyKey = isKeyed && keyExpr && !hasRestParam;
@@ -24647,7 +24837,7 @@ function buildListCallExpression(expr, statements, ctx, ops) {
     if (Object.keys(overrides).length > 0) {
       if (t4.isBlockStatement(callbackExpr.body)) {
         for (const stmt of callbackExpr.body.body) {
-          if (!t4.isVariableDeclaration(stmt)) continue;
+          if (!t4.isVariableDeclaration(stmt) || stmt.kind !== "const") continue;
           for (const decl of stmt.declarations) {
             if (!t4.isIdentifier(decl.id) || !decl.init) continue;
             const replacement = t4.cloneNode(decl.init, true);
@@ -24677,7 +24867,32 @@ function buildListCallExpression(expr, statements, ctx, ops) {
   }
   let listCall;
   if (isKeyed && keyExpr) {
+    const keyAliasDeclarations = collectMapCallbackAliasDeclarations(mapCallback);
+    const hasUnresolvedLocalKeyDeps = hasUnresolvedCallbackLocalKeyDependencies(
+      keyExpr,
+      mapCallback,
+      keyAliasDeclarations
+    );
     let keyExprAst = ops.lowerExpression(keyExpr, ctx);
+    if (keyAliasDeclarations.size > 0) {
+      const keyOverrides = {};
+      for (const [name, value] of keyAliasDeclarations) {
+        const replacement = ops.lowerExpression(value, ctx);
+        replaceIdentifiersWithOverrides(replacement, keyOverrides, t4);
+        keyOverrides[name] = () => t4.cloneNode(replacement, true);
+      }
+      if (Object.keys(keyOverrides).length > 0) {
+        replaceIdentifiersWithOverrides(
+          keyExprAst,
+          keyOverrides,
+          t4,
+          void 0,
+          void 0,
+          false,
+          true
+        );
+      }
+    }
     if (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr)) {
       const itemParam = callbackExpr.params[0];
       const indexParam = callbackExpr.params[1];
@@ -24691,6 +24906,9 @@ function buildListCallExpression(expr, statements, ctx, ops) {
     }
     const itemParamName = t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr) ? callbackExpr.params[0] : null;
     const indexParamName = t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr) ? callbackExpr.params[1] : null;
+    if (hasUnresolvedLocalKeyDeps) {
+      keyExprAst = t4.identifier(t4.isIdentifier(indexParamName) ? indexParamName.name : "__index");
+    }
     const keyFn = t4.arrowFunctionExpression(
       [
         t4.isIdentifier(itemParamName) ? itemParamName : t4.identifier("__item"),
@@ -25132,33 +25350,42 @@ function dependencyCoveredByDeclarations(dep, region) {
 
 // src/ir/codegen-resumable-utils.ts
 var import_node_url2 = require("url");
-function renameIdentifiersInExpr(expr, renames) {
-  const cloned = JSON.parse(JSON.stringify(expr));
-  function visit(node) {
-    if (!node || typeof node !== "object") return;
-    const n = node;
-    if (n.type === "Identifier" && typeof n.name === "string") {
-      const newName = renames.get(n.name);
-      if (newName) {
-        n.name = newName;
-      }
-    }
-    for (const key of Object.keys(n)) {
-      if (key === "loc" || key === "start" || key === "end" || key === "extra" || key === "comments" || key === "leadingComments" || key === "trailingComments") {
-        continue;
-      }
-      const value = n[key];
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          visit(item);
-        }
-      } else if (value && typeof value === "object") {
-        visit(value);
+var import_traverse2 = __toESM(require("@babel/traverse"), 1);
+function renameIdentifiersInExpr(expr, renames, t4) {
+  const traverse = import_traverse2.default.default ?? import_traverse2.default;
+  const cloned = t4.cloneNode(expr, true);
+  const file = t4.file(t4.program([t4.expressionStatement(cloned)]));
+  traverse(file, {
+    Identifier(path2) {
+      const oldName = path2.node.name;
+      const nextName = renames.get(oldName);
+      if (!nextName) return;
+      if (path2.parentPath.isObjectProperty() && path2.parentPath.node.shorthand && path2.parentPath.node.value === path2.node && t4.isIdentifier(path2.parentPath.node.key)) {
+        path2.parentPath.node.shorthand = false;
+        path2.parentPath.node.value = t4.identifier(nextName);
+        return;
       }
+      if (!path2.isReferencedIdentifier()) return;
+      const binding = path2.scope.getBinding(oldName);
+      if (binding && binding.scope !== path2.scope.getProgramParent()) return;
+      path2.node.name = nextName;
     }
-  }
-  visit(cloned);
-  return cloned;
+  });
+  const first = file.program.body[0];
+  return t4.isExpressionStatement(first) ? first.expression : cloned;
+}
+function collectFreeIdentifiersInExpr(expr, t4) {
+  const traverse = import_traverse2.default.default ?? import_traverse2.default;
+  const file = t4.file(t4.program([t4.expressionStatement(t4.cloneNode(expr, true))]));
+  const names = /* @__PURE__ */ new Set();
+  traverse(file, {
+    ReferencedIdentifier(path2) {
+      const name = path2.node.name;
+      if (path2.scope.getBinding(name)) return;
+      names.add(name);
+    }
+  });
+  return names;
 }
 function genModuleUrlExpr(ctx) {
   const { t: t4 } = ctx;
@@ -25295,10 +25522,10 @@ function registerResumableComponent(componentName, ctx) {
 }
 
 // src/ir/codegen-resumable-events.ts
-function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, containingRegion, ops) {
+function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, containingRegion, ops, options) {
   const { t: t4 } = ctx;
   if (!ctx.resumableEnabled) {
-    return;
+    return false;
   }
   const prevWrapTracked = ctx.wrapTrackedExpressions;
   ctx.wrapTrackedExpressions = false;
@@ -25312,53 +25539,88 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
   const scopeParam = t4.identifier("scopeId");
   const ensureHandlerParam = (fn) => {
     if (t4.isArrowFunctionExpression(fn)) {
-      if (fn.params.length > 0) return fn;
-      return t4.arrowFunctionExpression([eventParam], fn.body, fn.async);
+      return fn;
     }
     if (t4.isFunctionExpression(fn)) {
-      if (fn.params.length > 0) return fn;
-      return t4.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+      return fn;
     }
     if (t4.isIdentifier(fn) || t4.isMemberExpression(fn)) {
       return fn;
     }
-    if (t4.isCallExpression(fn) && fn.arguments.length === 0 && (t4.isIdentifier(fn.callee) || t4.isMemberExpression(fn.callee))) {
-      return fn.callee;
-    }
     return t4.functionExpression(
       null,
-      [eventParam],
-      t4.blockStatement([
-        t4.returnStatement(
-          t4.callExpression(
-            t4.memberExpression(fn, t4.identifier("call")),
-            [t4.thisExpression(), eventParam]
-          )
-        )
-      ])
+      [],
+      t4.blockStatement([t4.returnStatement(fn)])
     );
   };
   const handlerExpr = ensureHandlerParam(valueExpr);
   const handlerId = t4.identifier(`__fict_e${ctx.resumableHandlerCounter ?? 0}`);
   ctx.resumableHandlerCounter = (ctx.resumableHandlerCounter ?? 0) + 1;
-  const captured = /* @__PURE__ */ new Set();
-  collectExpressionIdentifiersDeep(expr, captured);
+  const captured = collectFreeIdentifiersInExpr(handlerExpr, t4);
   const lexicalNames = Array.from(captured).filter((name) => ctx.signalVars?.has(name));
   const propsName = ctx.propsParamName && captured.has(ctx.propsParamName) ? ctx.propsParamName : null;
+  const unsupportedLocals = Array.from(captured).filter((name) => {
+    if (ctx.inListRender && ctx.listKeyParamName && name === ctx.listKeyParamName) return true;
+    if (!ctx.localDeclaredNames?.has(name)) return false;
+    if (ctx.signalVars?.has(name)) return false;
+    if (ctx.functionVars?.has(name)) return false;
+    if (propsName && name === propsName) return false;
+    return true;
+  });
+  const loweredFunctionDeps = /* @__PURE__ */ new Map();
+  const unsafeFunctionCaptures = [];
+  for (const name of captured) {
+    if (!ctx.functionVars?.has(name) || ctx.signalVars?.has(name)) continue;
+    if (ctx.hoistedFunctionDepNames?.has(name)) continue;
+    const hirDef = ctx.componentFunctionDefs?.get(name);
+    if (!hirDef) {
+      if (ctx.localDeclaredNames?.has(name)) {
+        unsafeFunctionCaptures.push(`${name} -> <unhoistable>`);
+      }
+      continue;
+    }
+    const loweredFn = ops.lowerDomExpression(hirDef, ctx, null, {
+      skipHookAccessors: true,
+      skipRegionRootOverride: true
+    });
+    const fnCaptured = collectFreeIdentifiersInExpr(loweredFn, t4);
+    const localFnCaptures = Array.from(fnCaptured).filter((dep) => ctx.localDeclaredNames?.has(dep)).sort();
+    if (localFnCaptures.length > 0) {
+      unsafeFunctionCaptures.push(`${name} -> ${localFnCaptures.join(", ")}`);
+      continue;
+    }
+    loweredFunctionDeps.set(name, loweredFn);
+  }
+  if (unsupportedLocals.length > 0 || unsafeFunctionCaptures.length > 0) {
+    const detailParts = [];
+    if (unsupportedLocals.length > 0) {
+      detailParts.push(`direct: ${unsupportedLocals.sort().join(", ")}`);
+    }
+    if (unsafeFunctionCaptures.length > 0) {
+      detailParts.push(`function deps: ${unsafeFunctionCaptures.sort().join("; ")}`);
+    }
+    const detail = `Resumable handlers cannot capture non-serializable local variables (${detailParts.join(" | ")}).`;
+    if (options?.explicit) {
+      const loc = expr.loc?.start;
+      const fileName = ctx.options?.filename ?? "<unknown>";
+      const location = loc ? `${fileName}:${loc.line}:${loc.column + 1}` : fileName;
+      throw new Error(
+        `${detail} Use signals/props/function references or remove '$' suffix.
+  at ${location}`
+      );
+    }
+    return false;
+  }
   const functionDepRenames = /* @__PURE__ */ new Map();
   for (const name of captured) {
     if (ctx.functionVars?.has(name) && !ctx.signalVars?.has(name)) {
-      const hirDef = ctx.componentFunctionDefs?.get(name);
-      if (!hirDef) continue;
       let hoistedName = ctx.hoistedFunctionDepNames?.get(name);
       if (!hoistedName) {
+        const loweredFn = loweredFunctionDeps.get(name);
+        if (!loweredFn) continue;
         hoistedName = `__fict_fn_${name}_${ctx.hoistedFunctionDepCounter ?? 0}`;
         ctx.hoistedFunctionDepCounter = (ctx.hoistedFunctionDepCounter ?? 0) + 1;
         ctx.hoistedFunctionDepNames?.set(name, hoistedName);
-        const loweredFn = ops.lowerDomExpression(hirDef, ctx, null, {
-          skipHookAccessors: true,
-          skipRegionRootOverride: true
-        });
         const hoistedDecl = t4.variableDeclaration("const", [
           t4.variableDeclarator(t4.identifier(hoistedName), loweredFn)
         ]);
@@ -25370,7 +25632,7 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
   }
   let finalHandlerExpr = handlerExpr;
   if (functionDepRenames.size > 0) {
-    finalHandlerExpr = renameIdentifiersInExpr(handlerExpr, functionDepRenames);
+    finalHandlerExpr = renameIdentifiersInExpr(handlerExpr, functionDepRenames, t4);
   }
   const bodyStatements = [];
   if (lexicalNames.length > 0) {
@@ -25403,12 +25665,97 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
     );
   }
   const handlerVar = t4.identifier("__handler");
+  const resultVar = t4.identifier("__result");
   bodyStatements.push(
     t4.variableDeclaration("const", [t4.variableDeclarator(handlerVar, finalHandlerExpr)])
   );
   bodyStatements.push(
-    t4.returnStatement(
-      t4.callExpression(t4.memberExpression(handlerVar, t4.identifier("call")), [elParam, eventParam])
+    t4.ifStatement(
+      t4.binaryExpression(
+        "===",
+        t4.unaryExpression("typeof", handlerVar),
+        t4.stringLiteral("function")
+      ),
+      t4.blockStatement([
+        t4.variableDeclaration("const", [
+          t4.variableDeclarator(
+            resultVar,
+            t4.callExpression(t4.memberExpression(handlerVar, t4.identifier("call")), [
+              elParam,
+              eventParam
+            ])
+          )
+        ]),
+        t4.ifStatement(
+          t4.logicalExpression(
+            "&&",
+            t4.binaryExpression(
+              "===",
+              t4.unaryExpression("typeof", resultVar),
+              t4.stringLiteral("function")
+            ),
+            t4.binaryExpression("!==", resultVar, handlerVar)
+          ),
+          t4.blockStatement([
+            t4.returnStatement(
+              t4.callExpression(t4.memberExpression(resultVar, t4.identifier("call")), [
+                elParam,
+                eventParam
+              ])
+            )
+          ])
+        ),
+        t4.ifStatement(
+          t4.logicalExpression(
+            "&&",
+            resultVar,
+            t4.binaryExpression(
+              "===",
+              t4.unaryExpression(
+                "typeof",
+                t4.memberExpression(resultVar, t4.identifier("handleEvent"))
+              ),
+              t4.stringLiteral("function")
+            )
+          ),
+          t4.blockStatement([
+            t4.returnStatement(
+              t4.callExpression(
+                t4.memberExpression(
+                  t4.memberExpression(resultVar, t4.identifier("handleEvent")),
+                  t4.identifier("call")
+                ),
+                [resultVar, eventParam]
+              )
+            )
+          ])
+        ),
+        t4.returnStatement(resultVar)
+      ])
+    )
+  );
+  bodyStatements.push(
+    t4.ifStatement(
+      t4.logicalExpression(
+        "&&",
+        handlerVar,
+        t4.binaryExpression(
+          "===",
+          t4.unaryExpression("typeof", t4.memberExpression(handlerVar, t4.identifier("handleEvent"))),
+          t4.stringLiteral("function")
+        )
+      ),
+      t4.blockStatement([
+        t4.returnStatement(
+          t4.callExpression(
+            t4.memberExpression(
+              t4.memberExpression(handlerVar, t4.identifier("handleEvent")),
+              t4.identifier("call")
+            ),
+            [handlerVar, eventParam]
+          )
+        )
+      ])
     )
   );
   const exportedHandler = t4.exportNamedDeclaration(
@@ -25437,6 +25784,7 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
       ])
     )
   );
+  return true;
 }
 
 // src/ir/codegen-runtime-imports.ts
@@ -25821,7 +26169,8 @@ function extractHIRStaticHtml(jsx, ctx, ops, parentPath = [], namespace = null)
         name: eventName.toLowerCase(),
         expr: attr.value ?? void 0,
         eventOptions: { capture, passive, once },
-        resumable: shouldBeResumable
+        resumable: shouldBeResumable,
+        resumableExplicit: isResumableEvent
       });
       continue;
     }
@@ -26394,7 +26743,7 @@ function buildOutputParams(fn, t4) {
   }
   return fn.params.map((p) => t4.identifier(deSSAVarName(p.name)));
 }
-function lowerTrackedExpression(expr, ctx) {
+function lowerTrackedExpression(expr, ctx, valueUsed = true) {
   const regionOverride = ctx.inReturn && ctx.currentFnIsHook ? null : ctx.currentRegion ?? (ctx.trackedVars.size ? {
     id: -1,
     dependencies: new Set(ctx.trackedVars),
@@ -26402,7 +26751,7 @@ function lowerTrackedExpression(expr, ctx) {
     hasControlFlow: false,
     hasReactiveWrites: false
   } : null);
-  const lowered = lowerExpression2(expr, ctx);
+  const lowered = lowerExpression2(expr, ctx, valueUsed);
   if (ctx.t.isAssignmentExpression(lowered)) {
     const right = applyRegionMetadataToExpression2(lowered.right, ctx, regionOverride ?? void 0);
     return ctx.t.assignmentExpression(lowered.operator, lowered.left, right);
@@ -26524,7 +26873,7 @@ function lowerInstruction(instr, ctx) {
     );
   }
   if (instr.kind === "Expression") {
-    return applyLoc(t4.expressionStatement(lowerTrackedExpression(instr.value, ctx)));
+    return applyLoc(t4.expressionStatement(lowerTrackedExpression(instr.value, ctx, false)));
   }
   if (instr.kind === "Phi") {
     return null;
@@ -26688,7 +27037,7 @@ function collectLocalDeclaredNames(params, blocks, t4) {
   }
   return declared;
 }
-function lowerExpression2(expr, ctx, isAssigned = false) {
+function lowerExpression2(expr, ctx, valueUsed = true) {
   const depth = (ctx.expressionDepth ?? 0) + 1;
   const maxDepth = ctx.maxExpressionDepth ?? 500;
   if (depth > maxDepth) {
@@ -26699,12 +27048,12 @@ function lowerExpression2(expr, ctx, isAssigned = false) {
   }
   ctx.expressionDepth = depth;
   try {
-    return setNodeLoc(lowerExpressionImpl(expr, ctx, isAssigned), expr.loc);
+    return setNodeLoc(lowerExpressionImpl(expr, ctx, valueUsed), expr.loc);
   } finally {
     ctx.expressionDepth = depth - 1;
   }
 }
-function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
+function lowerExpressionImpl(expr, ctx, valueUsed = true) {
   const { t: t4 } = ctx;
   const mapParams = (params) => params.map((p) => t4.identifier(deSSAVarName(p.name)));
   const lowerArgsAsExpressions = (args) => args.map(
@@ -26745,6 +27094,152 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     ctx.localDeclaredNames = prevLocalDeclared;
     return result;
   };
+  const lowerTrackedWriteCall = (callee, nextValue) => {
+    if (!valueUsed) {
+      return t4.callExpression(t4.cloneNode(callee, true), [nextValue]);
+    }
+    const nextId = genTemp3(ctx, "next");
+    const nextRef = t4.identifier(nextId.name);
+    return t4.callExpression(
+      t4.arrowFunctionExpression(
+        [t4.cloneNode(nextId, true)],
+        t4.sequenceExpression([
+          t4.callExpression(t4.cloneNode(callee, true), [nextRef]),
+          t4.identifier(nextId.name)
+        ])
+      ),
+      [nextValue]
+    );
+  };
+  const buildTrackedAssignmentNext = (operator, current, right) => {
+    switch (operator) {
+      case "=":
+        return right;
+      case "+=":
+        return t4.binaryExpression("+", current, right);
+      case "-=":
+        return t4.binaryExpression("-", current, right);
+      case "*=":
+        return t4.binaryExpression("*", current, right);
+      case "/=":
+        return t4.binaryExpression("/", current, right);
+      case "%=":
+        return t4.binaryExpression("%", current, right);
+      case "**=":
+        return t4.binaryExpression("**", current, right);
+      case "<<=":
+        return t4.binaryExpression("<<", current, right);
+      case ">>=":
+        return t4.binaryExpression(">>", current, right);
+      case ">>>=":
+        return t4.binaryExpression(">>>", current, right);
+      case "|=":
+        return t4.binaryExpression("|", current, right);
+      case "^=":
+        return t4.binaryExpression("^", current, right);
+      case "&=":
+        return t4.binaryExpression("&", current, right);
+      case "&&=":
+        return t4.logicalExpression("&&", current, right);
+      case "||=":
+        return t4.logicalExpression("||", current, right);
+      case "??=":
+        return t4.logicalExpression("??", current, right);
+      default:
+        return right;
+    }
+  };
+  const buildStaticSignalKeyTest = (keyRef, keys) => {
+    if (keys.length === 0) return null;
+    let test = null;
+    for (const key of keys) {
+      const literal = typeof key === "number" ? t4.numericLiteral(key) : t4.stringLiteral(String(key));
+      const eq = t4.binaryExpression("===", t4.cloneNode(keyRef, true), literal);
+      test = test ? t4.logicalExpression("||", test, eq) : eq;
+    }
+    return test;
+  };
+  const lowerComputedHookSignalAssignment = (objectName, keyExpr, signalKeys, operator, rightExpr) => {
+    const keyTestKeys = signalKeys.filter(
+      (key) => typeof key === "number" && Number.isFinite(key) || typeof key === "string"
+    );
+    if (keyTestKeys.length === 0) return null;
+    const keyId = genTemp3(ctx, "key");
+    const keyRef = t4.identifier(keyId.name);
+    const memberForAccessor = t4.memberExpression(
+      t4.identifier(objectName),
+      t4.identifier(keyId.name),
+      true
+    );
+    const current = t4.callExpression(t4.cloneNode(memberForAccessor, true), []);
+    const right = lowerExpression2(rightExpr, ctx);
+    const signalWrite = lowerTrackedWriteCall(
+      memberForAccessor,
+      buildTrackedAssignmentNext(operator, current, t4.cloneNode(right, true))
+    );
+    const fallback = t4.assignmentExpression(
+      operator,
+      t4.memberExpression(t4.identifier(objectName), t4.identifier(keyId.name), true),
+      right
+    );
+    const keyTest = buildStaticSignalKeyTest(keyRef, keyTestKeys);
+    if (!keyTest) return null;
+    return t4.callExpression(
+      t4.arrowFunctionExpression(
+        [t4.cloneNode(keyId, true)],
+        t4.conditionalExpression(keyTest, signalWrite, fallback)
+      ),
+      [lowerExpression2(keyExpr, ctx)]
+    );
+  };
+  const lowerComputedHookSignalUpdate = (objectName, keyExpr, signalKeys, operator, prefix) => {
+    const keyTestKeys = signalKeys.filter(
+      (key) => typeof key === "number" && Number.isFinite(key) || typeof key === "string"
+    );
+    if (keyTestKeys.length === 0) return null;
+    const keyId = genTemp3(ctx, "key");
+    const keyRef = t4.identifier(keyId.name);
+    const signalUpdate = lowerTrackedUpdateCall(
+      t4.memberExpression(t4.identifier(objectName), t4.identifier(keyId.name), true),
+      operator,
+      prefix
+    );
+    const fallback = t4.updateExpression(
+      operator,
+      t4.memberExpression(t4.identifier(objectName), t4.identifier(keyId.name), true),
+      prefix
+    );
+    const keyTest = buildStaticSignalKeyTest(keyRef, keyTestKeys);
+    if (!keyTest) return null;
+    return t4.callExpression(
+      t4.arrowFunctionExpression(
+        [t4.cloneNode(keyId, true)],
+        t4.conditionalExpression(keyTest, signalUpdate, fallback)
+      ),
+      [lowerExpression2(keyExpr, ctx)]
+    );
+  };
+  const lowerTrackedUpdateCall = (callee, operator, prefix) => {
+    const op = operator === "++" ? "+" : "-";
+    const delta = t4.numericLiteral(1);
+    const current = t4.callExpression(t4.cloneNode(callee, true), []);
+    if (!valueUsed) {
+      return t4.callExpression(t4.cloneNode(callee, true), [t4.binaryExpression(op, current, delta)]);
+    }
+    const prevId = genTemp3(ctx, "prev");
+    const prevForSet = t4.identifier(prevId.name);
+    const prevForResult = t4.identifier(prevId.name);
+    return t4.callExpression(
+      t4.arrowFunctionExpression(
+        [t4.cloneNode(prevId, true)],
+        t4.sequenceExpression([
+          t4.callExpression(t4.cloneNode(callee, true), [t4.binaryExpression(op, prevForSet, delta)]),
+          prefix ? t4.binaryExpression(op, prevForResult, t4.numericLiteral(1)) : prevForResult
+        ])
+      ),
+      [current]
+    );
+  };
   const lowerBlocksToStatements = (blocks) => {
     const stmts = [];
     for (const block of blocks) {
@@ -26914,6 +27409,24 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
           expr.arguments,
           (arg) => arg.kind === "ArrowFunction" || arg.kind === "FunctionExpression" ? withNonReactiveScope(ctx, () => lowerExpression2(arg, ctx)) : lowerExpression2(arg, ctx)
         );
+        const includeDevtools = ctx.options?.dev !== false;
+        if (includeDevtools && expr.loc) {
+          const source = `${ctx.options?.filename ?? ""}:${expr.loc.start.line}:${expr.loc.start.column}`;
+          const sourceProp = t4.objectProperty(
+            t4.identifier("devToolsSource"),
+            t4.stringLiteral(source)
+          );
+          if (args.length === 1) {
+            args.push(t4.objectExpression([sourceProp]));
+          } else if (args.length > 1 && t4.isObjectExpression(args[1])) {
+            const hasSourceProp = args[1].properties.some(
+              (prop) => t4.isObjectProperty(prop) && t4.isIdentifier(prop.key) && prop.key.name === "devToolsSource"
+            );
+            if (!hasSourceProp) {
+              args[1].properties.push(sourceProp);
+            }
+          }
+        }
         if (ctx.inModule) {
           ctx.helpersUsed.add("effect");
           return t4.callExpression(t4.identifier(RUNTIME_ALIASES.effect), args);
@@ -27221,59 +27734,42 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
               expr.left.computed,
               expr.left.optional
             );
-            const current = t4.callExpression(member, []);
+            const current = t4.callExpression(t4.cloneNode(member, true), []);
             const right = lowerExpression2(expr.right, ctx);
-            let next;
-            switch (expr.operator) {
-              case "=":
-                next = right;
-                break;
-              case "+=":
-                next = t4.binaryExpression("+", current, right);
-                break;
-              case "-=":
-                next = t4.binaryExpression("-", current, right);
-                break;
-              case "*=":
-                next = t4.binaryExpression("*", current, right);
-                break;
-              case "/=":
-                next = t4.binaryExpression("/", current, right);
-                break;
-              default:
-                next = right;
+            const next = buildTrackedAssignmentNext(expr.operator, current, right);
+            return lowerTrackedWriteCall(member, next);
+          }
+          if (expr.left.computed) {
+            const signalKeys = [];
+            if (info?.objectProps) {
+              for (const [key, accessorKind] of info.objectProps.entries()) {
+                if (accessorKind === "signal") signalKeys.push(key);
+              }
             }
-            return t4.callExpression(member, [next]);
+            if (info?.arrayProps) {
+              for (const [key, accessorKind] of info.arrayProps.entries()) {
+                if (accessorKind === "signal") signalKeys.push(key);
+              }
+            }
+            const lowered = lowerComputedHookSignalAssignment(
+              deSSAVarName(expr.left.object.name),
+              expr.left.property,
+              signalKeys,
+              expr.operator,
+              expr.right
+            );
+            if (lowered) return lowered;
           }
         }
       }
       if (expr.left.kind === "Identifier") {
         const baseName2 = deSSAVarName(expr.left.name);
         if (ctx.trackedVars.has(baseName2)) {
-          const id = t4.identifier(baseName2);
+          const callee = t4.identifier(baseName2);
           const current = t4.callExpression(t4.identifier(baseName2), []);
           const right = lowerExpression2(expr.right, ctx);
-          let next;
-          switch (expr.operator) {
-            case "=":
-              next = right;
-              break;
-            case "+=":
-              next = t4.binaryExpression("+", current, right);
-              break;
-            case "-=":
-              next = t4.binaryExpression("-", current, right);
-              break;
-            case "*=":
-              next = t4.binaryExpression("*", current, right);
-              break;
-            case "/=":
-              next = t4.binaryExpression("/", current, right);
-              break;
-            default:
-              next = right;
-          }
-          return t4.callExpression(id, [next]);
+          const next = buildTrackedAssignmentNext(expr.operator, current, right);
+          return lowerTrackedWriteCall(callee, next);
         }
       }
       return t4.assignmentExpression(
@@ -27305,21 +27801,35 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
               expr.argument.computed,
               expr.argument.optional
             );
-            const current = t4.callExpression(member, []);
-            const delta = t4.numericLiteral(1);
-            const next = expr.operator === "++" ? t4.binaryExpression("+", current, delta) : t4.binaryExpression("-", current, delta);
-            return t4.callExpression(member, [next]);
+            return lowerTrackedUpdateCall(member, expr.operator, expr.prefix);
+          }
+          if (expr.argument.computed) {
+            const signalKeys = [];
+            if (info?.objectProps) {
+              for (const [key, accessorKind] of info.objectProps.entries()) {
+                if (accessorKind === "signal") signalKeys.push(key);
+              }
+            }
+            if (info?.arrayProps) {
+              for (const [key, accessorKind] of info.arrayProps.entries()) {
+                if (accessorKind === "signal") signalKeys.push(key);
+              }
+            }
+            const lowered = lowerComputedHookSignalUpdate(
+              deSSAVarName(expr.argument.object.name),
+              expr.argument.property,
+              signalKeys,
+              expr.operator,
+              expr.prefix
+            );
+            if (lowered) return lowered;
           }
         }
       }
       if (expr.argument.kind === "Identifier") {
         const baseName2 = deSSAVarName(expr.argument.name);
         if (ctx.trackedVars.has(baseName2)) {
-          const id = t4.identifier(baseName2);
-          const current = t4.callExpression(t4.identifier(baseName2), []);
-          const delta = t4.numericLiteral(1);
-          const next = expr.operator === "++" ? t4.binaryExpression("+", current, delta) : t4.binaryExpression("-", current, delta);
-          return t4.callExpression(id, [next]);
+          return lowerTrackedUpdateCall(t4.identifier(baseName2), expr.operator, expr.prefix);
         }
       }
       return t4.updateExpression(
@@ -27341,7 +27851,11 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     case "NewExpression":
       return t4.newExpression(lowerExpression2(expr.callee, ctx), lowerCallArguments(expr.arguments));
     case "SequenceExpression":
-      return t4.sequenceExpression(expr.expressions.map((e) => lowerExpression2(e, ctx)));
+      return t4.sequenceExpression(
+        expr.expressions.map(
+          (e, index) => lowerExpression2(e, ctx, index === expr.expressions.length - 1 ? valueUsed : false)
+        )
+      );
     case "YieldExpression":
       return t4.yieldExpression(
         expr.argument ? lowerExpression2(expr.argument, ctx) : null,
@@ -27799,16 +28313,17 @@ function lowerIntrinsicElement(jsx, ctx) {
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
       if (binding.resumable && !hasEventOptions) {
-        emitResumableEventBinding(
+        const emitted = emitResumableEventBinding(
           targetId,
           eventName,
           binding.expr,
           statements,
           ctx,
           containingRegion,
-          createResumableEventBindingOps()
+          createResumableEventBindingOps(),
+          { explicit: binding.resumableExplicit === true }
         );
-        continue;
+        if (emitted) continue;
       }
       const hirDataBinding = isDelegated && binding.expr ? extractDelegatedEventDataFromHIR(binding.expr, ctx) : null;
       if (hirDataBinding) {
@@ -27850,34 +28365,24 @@ function lowerIntrinsicElement(jsx, ctx) {
         const isFn = t4.isArrowFunctionExpression(valueExpr) || t4.isFunctionExpression(valueExpr);
         const ensureHandlerParam = (fn) => {
           if (t4.isArrowFunctionExpression(fn)) {
-            if (fn.params.length > 0) return fn;
-            return t4.arrowFunctionExpression([eventParam], fn.body, fn.async);
+            return fn;
           }
           if (t4.isFunctionExpression(fn)) {
-            if (fn.params.length > 0) return fn;
-            return t4.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+            return fn;
           }
           if (t4.isIdentifier(fn) || t4.isMemberExpression(fn)) {
             return fn;
           }
-          if (t4.isCallExpression(fn) && fn.arguments.length === 0 && (t4.isIdentifier(fn.callee) || t4.isMemberExpression(fn.callee))) {
-            return fn.callee;
-          }
           return t4.functionExpression(
             null,
-            [eventParam],
-            t4.blockStatement([
-              t4.returnStatement(
-                t4.callExpression(
-                  t4.memberExpression(fn, t4.identifier("call")),
-                  [t4.thisExpression(), eventParam]
-                )
-              )
-            ])
+            [],
+            t4.blockStatement([t4.returnStatement(fn)])
           );
         };
         const handlerExpr = !isFn && shouldWrapHandler ? t4.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
-        let dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t4) : null;
+        let dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t4, {
+          isKnownHandlerIdentifier: (name) => ctx.functionVars?.has(deSSAVarName(name)) ?? false
+        }) : null;
         if (dataBinding && t4.isIdentifier(dataBinding.handler)) {
           const handlerName = dataBinding.handler.name;
           if (ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName) || ctx.storeVars?.has(handlerName) || ctx.trackedVars.has(handlerName)) {
@@ -27889,8 +28394,6 @@ function lowerIntrinsicElement(jsx, ctx) {
           let handlerName = null;
           if (t4.isIdentifier(valueExpr)) {
             handlerName = valueExpr.name;
-          } else if (t4.isCallExpression(valueExpr) && valueExpr.arguments.length === 0 && t4.isIdentifier(valueExpr.callee)) {
-            handlerName = valueExpr.callee.name;
           }
           const handlerForCall = handlerName ? t4.identifier(handlerName) : t4.cloneNode(valueExpr, true);
           const finalHandler = !isFn && shouldWrapHandler ? t4.functionExpression(
@@ -27906,9 +28409,6 @@ function lowerIntrinsicElement(jsx, ctx) {
             ])
           ) : handlerExpr;
           const normalizeHandler = (expr) => {
-            if (t4.isCallExpression(expr) && (t4.isIdentifier(expr.callee) || t4.isMemberExpression(expr.callee))) {
-              return expr.callee;
-            }
             return expr;
           };
           const normalizedDataHandler = dataBinding !== null ? normalizeHandler(
@@ -30359,11 +30859,27 @@ function optimizeReactiveBlock(block, reactive, purity, options) {
   const constArrays = /* @__PURE__ */ new Map();
   const cseMap = /* @__PURE__ */ new Map();
   const instructions = [];
+  const deleteByBase = (map, name) => {
+    const base = getSSABaseName(name);
+    for (const key of Array.from(map.keys())) {
+      if (getSSABaseName(key) === base) {
+        map.delete(key);
+      }
+    }
+  };
   const invalidateCSE = (name) => {
+    const base = getSSABaseName(name);
     const toDelete = [];
     for (const [hash, entry] of cseMap.entries()) {
-      if (entry.name === name || entry.deps.has(name)) {
+      if (getSSABaseName(entry.name) === base) {
         toDelete.push(hash);
+        continue;
+      }
+      for (const dep of entry.deps) {
+        if (getSSABaseName(dep) === base) {
+          toDelete.push(hash);
+          break;
+        }
       }
     }
     toDelete.forEach((hash) => cseMap.delete(hash));
@@ -30373,22 +30889,22 @@ function optimizeReactiveBlock(block, reactive, purity, options) {
       const target = instr.target.name;
       const declKind = instr.declarationKind;
       invalidateCSE(target);
-      constants.delete(target);
-      constObjects.delete(target);
-      constArrays.delete(target);
+      deleteByBase(constants, target);
+      deleteByBase(constObjects, target);
+      deleteByBase(constArrays, target);
       const sideWrites = collectWriteTargets(instr.value);
       for (const name of sideWrites) {
         if (name !== target) {
-          constants.delete(name);
+          deleteByBase(constants, name);
           invalidateCSE(name);
         }
-        constObjects.delete(name);
-        constArrays.delete(name);
+        deleteByBase(constObjects, name);
+        deleteByBase(constArrays, name);
       }
       const memberCalls = collectMemberCallTargets(instr.value);
       for (const name of memberCalls) {
-        constObjects.delete(name);
-        constArrays.delete(name);
+        deleteByBase(constObjects, name);
+        deleteByBase(constArrays, name);
       }
       const dependsOnReactiveValue = expressionDependsOnReactive(instr.value, reactive);
       let value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, options, constObjects, constArrays);
@@ -30428,15 +30944,15 @@ function optimizeReactiveBlock(block, reactive, purity, options) {
     if (instr.kind === "Expression") {
       const writes = collectWriteTargets(instr.value);
       for (const name of writes) {
-        constants.delete(name);
+        deleteByBase(constants, name);
         invalidateCSE(name);
-        constObjects.delete(name);
-        constArrays.delete(name);
+        deleteByBase(constObjects, name);
+        deleteByBase(constArrays, name);
       }
       const memberCalls = collectMemberCallTargets(instr.value);
       for (const name of memberCalls) {
-        constObjects.delete(name);
-        constArrays.delete(name);
+        deleteByBase(constObjects, name);
+        deleteByBase(constArrays, name);
       }
       const dependsOnReactiveValue = expressionDependsOnReactive(instr.value, reactive);
       const value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, options, constObjects, constArrays);
@@ -31086,6 +31602,8 @@ function collectWriteTargets(expr) {
         } else if (left.kind === "MemberExpression" || left.kind === "OptionalMemberExpression") {
           const base = getMemberBaseIdentifier(left);
           if (base) writes.add(base.name);
+          visit(left.object);
+          if (left.computed) visit(left.property);
         } else {
           visit(left);
         }
@@ -31102,8 +31620,10 @@ function collectWriteTargets(expr) {
           const base = getMemberBaseIdentifier(arg);
           if (base) {
             writes.add(base.name);
-            return;
           }
+          visit(arg.object);
+          if (arg.computed) visit(arg.property);
+          return;
         }
         visit(arg);
         return;
@@ -31409,6 +31929,16 @@ function propagateConstants(fn, options) {
 }
 function computeConstantMap(fn) {
   const constants = /* @__PURE__ */ new Map();
+  const invalidateWrittenName = (writtenName) => {
+    const writtenBase = getSSABaseName(writtenName);
+    let removed = false;
+    for (const constantName of Array.from(constants.keys())) {
+      if (constantName === writtenName || getSSABaseName(constantName) === writtenBase) {
+        removed = constants.delete(constantName) || removed;
+      }
+    }
+    return removed;
+  };
   let changed = true;
   let iterations = 0;
   const maxIterations = 10;
@@ -31417,6 +31947,14 @@ function computeConstantMap(fn) {
     changed = false;
     for (const block of fn.blocks) {
       for (const instr of block.instructions) {
+        if (instr.kind === "Assign" || instr.kind === "Expression") {
+          const writes = collectWriteTargets(instr.value);
+          for (const writtenName of writes) {
+            if (invalidateWrittenName(writtenName)) {
+              changed = true;
+            }
+          }
+        }
         if (instr.kind === "Assign") {
           const value = evaluateConstant(instr.value, constants);
           if (value !== UNKNOWN_CONST) {
@@ -33303,9 +33841,18 @@ function isInsideLoop(path2) {
   );
 }
 function isInsideConditional(path2) {
-  return !!path2.findParent(
-    (p) => p.isIfStatement?.() || p.isConditionalExpression?.() || p.isSwitchCase?.()
-  );
+  let current = path2;
+  while (current?.parentPath) {
+    const parent = current.parentPath;
+    if (parent.isIfStatement?.() || parent.isConditionalExpression?.() || parent.isSwitchCase?.()) {
+      return true;
+    }
+    if (parent.isLogicalExpression?.() && current.key === "right") {
+      return true;
+    }
+    current = parent;
+  }
+  return false;
 }
 function isInsideJSX(path2) {
   return !!path2.findParent((p) => p.isJSXElement?.() || p.isJSXFragment?.());