@fictjs/compiler 0.8.0 → 0.10.0

package/dist/index.cjs

@@ -14241,6 +14241,9 @@ var RUNTIME_ALIASES = {
   hydrateComponent: "hydrateComponent",
   registerResume: "__fictRegisterResume"
 };
+var RUNTIME_HELPER_MODULES = {
+  keyedList: "@fictjs/runtime/internal/list"
+};
 var DelegatedEvents = /* @__PURE__ */ new Set([...DelegatedEventNames]);
 var SAFE_FUNCTIONS = /* @__PURE__ */ new Set([
   // Console methods
@@ -19939,15 +19942,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);
@@ -21208,7 +21234,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)])
@@ -21467,7 +21496,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)])
@@ -21580,7 +21612,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);
@@ -22942,7 +22979,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 };
@@ -22955,6 +22992,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];
@@ -23017,6 +23057,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;
   }
@@ -23027,7 +23071,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;
@@ -24066,17 +24113,19 @@ function collectDeclaredNames(body, t4) {
 function attachHelperImports(ctx, body, t4) {
   if (ctx.helpersUsed.size === 0) return body;
   const declared = collectDeclaredNames(body, t4);
-  const specifiers = [];
+  const specifiersByModule = /* @__PURE__ */ new Map();
   for (const name of ctx.helpersUsed) {
     const alias = RUNTIME_ALIASES[name];
     const helper = RUNTIME_HELPERS[name];
     if (alias && helper) {
       if (declared.has(alias)) continue;
-      specifiers.push(t4.importSpecifier(t4.identifier(alias), t4.identifier(helper)));
+      const modulePath = RUNTIME_HELPER_MODULES[name] ?? RUNTIME_MODULE;
+      const moduleSpecifiers = specifiersByModule.get(modulePath) ?? [];
+      moduleSpecifiers.push(t4.importSpecifier(t4.identifier(alias), t4.identifier(helper)));
+      specifiersByModule.set(modulePath, moduleSpecifiers);
     }
   }
-  if (specifiers.length === 0) return body;
-  const importDecl = t4.importDeclaration(specifiers, t4.stringLiteral(RUNTIME_MODULE));
+  if (specifiersByModule.size === 0) return body;
   const helpers = [];
   if (ctx.needsForOfHelper) {
     const itemId = t4.identifier("item");
@@ -24114,7 +24163,15 @@ function attachHelperImports(ctx, body, t4) {
       )
     );
   }
-  return [importDecl, ...helpers, ...body];
+  const modulePaths = Array.from(specifiersByModule.keys()).sort((a, b) => {
+    if (a === RUNTIME_MODULE) return -1;
+    if (b === RUNTIME_MODULE) return 1;
+    return a.localeCompare(b);
+  });
+  const importDecls = modulePaths.map(
+    (modulePath) => t4.importDeclaration(specifiersByModule.get(modulePath) ?? [], t4.stringLiteral(modulePath))
+  );
+  return [...importDecls, ...helpers, ...body];
 }
 
 // src/ir/codegen-jsx-keys.ts
@@ -24184,8 +24241,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;
   }
@@ -24257,9 +24314,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;
   }
@@ -24287,12 +24360,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
+      );
     }
   }
 }
@@ -24565,6 +24647,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") {
@@ -24583,7 +24783,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;
@@ -24634,7 +24835,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);
@@ -24664,7 +24865,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];
@@ -24678,6 +24904,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"),
@@ -25119,33 +25348,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;
@@ -25282,10 +25520,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;
@@ -25299,53 +25537,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)
         ]);
@@ -25357,7 +25630,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) {
@@ -25390,12 +25663,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(
@@ -25424,11 +25782,13 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
       ])
     )
   );
+  return true;
 }
 
 // src/ir/codegen-runtime-imports.ts
 var RUNTIME_IMPORT_MODULES = /* @__PURE__ */ new Set([
   RUNTIME_MODULE,
+  ...Object.values(RUNTIME_HELPER_MODULES),
   "@fictjs/runtime",
   "@fictjs/runtime/advanced",
   "fict",
@@ -25807,7 +26167,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;
     }
@@ -26380,7 +26741,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),
@@ -26388,7 +26749,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);
@@ -26510,7 +26871,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;
@@ -26674,7 +27035,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) {
@@ -26685,12 +27046,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(
@@ -26731,6 +27092,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) {
@@ -26900,6 +27407,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);
@@ -27207,59 +27732,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(
@@ -27291,21 +27799,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(
@@ -27327,7 +27849,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,
@@ -27785,16 +28311,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) {
@@ -27836,34 +28363,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)) {
@@ -27875,8 +28392,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(
@@ -27892,9 +28407,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(
@@ -28568,10 +29080,13 @@ function transformControlFlowReturns(statements, ctx) {
     }
     return false;
   };
-  function hasNodeMatch(nodes, predicate) {
+  function hasNodeMatch(nodes, predicate, options) {
     let found = false;
-    const visit = (node) => {
+    const visit = (node, isRoot = false) => {
       if (!node || found) return;
+      if (!isRoot && options?.skipNestedFunctions && (t4.isFunctionExpression(node) || t4.isArrowFunctionExpression(node) || t4.isFunctionDeclaration(node) || t4.isObjectMethod(node) || t4.isClassMethod(node))) {
+        return;
+      }
       if (predicate(node)) {
         found = true;
         return;
@@ -28594,17 +29109,134 @@ function transformControlFlowReturns(statements, ctx) {
       }
     };
     for (const node of nodes) {
-      visit(node);
+      visit(node, true);
       if (found) return true;
     }
     return found;
   }
   const containsReturnStatement = (nodes) => hasNodeMatch(nodes, (node) => t4.isReturnStatement(node));
-  const containsReactiveAccessorRead = (nodes) => hasNodeMatch(nodes, (node) => {
-    if (!t4.isCallExpression(node) && !t4.isOptionalCallExpression(node)) return false;
-    const callee = node.callee;
-    return t4.isIdentifier(callee) && reactiveAccessorNames.has(callee.name);
-  });
+  const getMemberRootIdentifier = (expr) => {
+    let current = expr.object;
+    while (t4.isMemberExpression(current) || t4.isOptionalMemberExpression(current)) {
+      current = current.object;
+    }
+    return t4.isIdentifier(current) ? current : null;
+  };
+  const containsReactiveAccessorRead = (nodes, options) => hasNodeMatch(
+    nodes,
+    (node) => {
+      if (t4.isCallExpression(node) || t4.isOptionalCallExpression(node)) {
+        const callee = node.callee;
+        return t4.isIdentifier(callee) && reactiveAccessorNames.has(callee.name);
+      }
+      if (t4.isMemberExpression(node) || t4.isOptionalMemberExpression(node)) {
+        const root = getMemberRootIdentifier(node);
+        return !!(root && reactiveAccessorNames.has(root.name));
+      }
+      return false;
+    },
+    options
+  );
+  const containsReactiveControlFlowRead = (nodes) => hasNodeMatch(
+    nodes,
+    (node) => {
+      if (t4.isIfStatement(node)) {
+        return containsReactiveAccessorRead([node.test], { skipNestedFunctions: true });
+      }
+      if (t4.isSwitchStatement(node)) {
+        return containsReactiveAccessorRead([node.discriminant], { skipNestedFunctions: true });
+      }
+      if (t4.isConditionalExpression(node)) {
+        return containsReactiveAccessorRead([node.test], { skipNestedFunctions: true });
+      }
+      if (t4.isWhileStatement(node) || t4.isDoWhileStatement(node)) {
+        return containsReactiveAccessorRead([node.test], { skipNestedFunctions: true });
+      }
+      if (t4.isForStatement(node)) {
+        const parts = [];
+        if (node.init) parts.push(node.init);
+        if (node.test) parts.push(node.test);
+        if (node.update) parts.push(node.update);
+        return parts.length > 0 && containsReactiveAccessorRead(parts, { skipNestedFunctions: true });
+      }
+      if (t4.isForOfStatement(node) || t4.isForInStatement(node)) {
+        return containsReactiveAccessorRead([node.right], { skipNestedFunctions: true });
+      }
+      return false;
+    },
+    { skipNestedFunctions: true }
+  );
+  const hasRiskyBranchControlFlow = (stmts) => {
+    if (stmts.length === 0) return false;
+    return containsReactiveControlFlowRead(stmts);
+  };
+  const isJSXLikeNode = (node) => !!node && (t4.isJSXElement(node) || t4.isJSXFragment(node));
+  const isStoreSourceExpression = (expr) => {
+    if (t4.isIdentifier(expr)) {
+      return !!ctx.storeVars?.has(expr.name);
+    }
+    if (t4.isMemberExpression(expr) || t4.isOptionalMemberExpression(expr)) {
+      const root = getMemberRootIdentifier(expr);
+      return !!(root && ctx.storeVars?.has(root.name));
+    }
+    return false;
+  };
+  const hasRiskyStoreDestructureRead = (stmt) => {
+    if (t4.isVariableDeclaration(stmt)) {
+      for (const decl of stmt.declarations) {
+        if (!decl.init) continue;
+        const hasPattern = t4.isObjectPattern(decl.id) || t4.isArrayPattern(decl.id);
+        if (!hasPattern) continue;
+        if (isStoreSourceExpression(decl.init)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    if (t4.isExpressionStatement(stmt) && t4.isAssignmentExpression(stmt.expression)) {
+      const assignment = stmt.expression;
+      const isPatternLhs = t4.isObjectPattern(assignment.left) || t4.isArrayPattern(assignment.left);
+      if (!isPatternLhs) return false;
+      return isStoreSourceExpression(assignment.right);
+    }
+    return false;
+  };
+  const hasRiskyBranchPreludeReads = (stmts) => {
+    for (const stmt of stmts) {
+      if (hasRiskyStoreDestructureRead(stmt)) {
+        return true;
+      }
+      if (t4.isReturnStatement(stmt)) {
+        const arg = stmt.argument;
+        if (!arg || isJSXLikeNode(arg)) continue;
+        if (containsReactiveAccessorRead([arg], { skipNestedFunctions: true })) {
+          return true;
+        }
+        continue;
+      }
+      if (containsReactiveAccessorRead([stmt], { skipNestedFunctions: true })) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const hasRiskyImmediateInvocationReads = (stmts) => hasNodeMatch(
+    stmts,
+    (node) => {
+      if (!t4.isCallExpression(node) && !t4.isOptionalCallExpression(node)) return false;
+      const callee = node.callee;
+      if (!t4.isFunctionExpression(callee) && !t4.isArrowFunctionExpression(callee)) {
+        return false;
+      }
+      const bodyNodes = t4.isBlockStatement(callee.body) ? callee.body.body : [callee.body];
+      return containsReactiveAccessorRead(bodyNodes, { skipNestedFunctions: true });
+    },
+    { skipNestedFunctions: true }
+  );
+  const needsTrackedBranchReads = (stmts) => {
+    if (stmts.length === 0) return false;
+    return hasRiskyBranchControlFlow(stmts) || hasRiskyBranchPreludeReads(stmts) || hasRiskyImmediateInvocationReads(stmts);
+  };
   const emitControlFlowFallbackWarning = (node, kind) => {
     const onWarn = ctx.options?.onWarn;
     if (!onWarn) return;
@@ -28673,7 +29305,7 @@ function transformControlFlowReturns(statements, ctx) {
     }
     return found;
   }
-  function buildConditionalBindingExpr(testExpr, trueFn, falseFn) {
+  function buildConditionalBindingExpr(testExpr, trueFn, falseFn, options) {
     ctx.helpersUsed.add("conditional");
     ctx.helpersUsed.add("createElement");
     ctx.helpersUsed.add("onDestroy");
@@ -28684,6 +29316,16 @@ function transformControlFlowReturns(statements, ctx) {
       t4.identifier(RUNTIME_ALIASES.createElement),
       falseFn
     ];
+    if (options?.trackBranchReads) {
+      const undefinedExpr = t4.unaryExpression("void", t4.numericLiteral(0));
+      args.push(
+        undefinedExpr,
+        t4.cloneNode(undefinedExpr),
+        t4.objectExpression([
+          t4.objectProperty(t4.identifier("trackBranchReads"), t4.booleanLiteral(true))
+        ])
+      );
+    }
     const bindingCall = t4.callExpression(t4.identifier(RUNTIME_ALIASES.conditional), args);
     return t4.callExpression(
       t4.arrowFunctionExpression(
@@ -28717,7 +29359,13 @@ function transformControlFlowReturns(statements, ctx) {
     const trueFn = buildBranchFunction(consequentStmts);
     const falseFn = alternateStmts ? buildBranchFunction(alternateStmts) : null;
     if (!trueFn || !falseFn) return null;
-    return buildConditionalBindingExpr(ifStmt.test, trueFn, falseFn);
+    const shouldTrackBranchReads = needsTrackedBranchReads(consequentStmts) || (alternateStmts ? needsTrackedBranchReads(alternateStmts) : false);
+    return buildConditionalBindingExpr(
+      ifStmt.test,
+      trueFn,
+      falseFn,
+      shouldTrackBranchReads ? { trackBranchReads: true } : void 0
+    );
   }
   function isSupportedSwitchDiscriminant(_expr) {
     return true;
@@ -28810,10 +29458,13 @@ function transformControlFlowReturns(statements, ctx) {
       ),
       []
     );
+    let currentExprNeedsTrackedBranchReads = needsTrackedBranchReads(fallbackStatements);
     for (let i = branches.length - 1; i >= 0; i--) {
       const branch = branches[i];
       const trueFn = buildBranchFunction(branch.statements, { disallowRenderHooks: true });
       if (!trueFn) return null;
+      const trueBranchNeedsTrackedBranchReads = needsTrackedBranchReads(branch.statements);
+      const trackBranchReads = trueBranchNeedsTrackedBranchReads || currentExprNeedsTrackedBranchReads;
       const falseFn = t4.arrowFunctionExpression(
         [],
         t4.blockStatement([t4.returnStatement(currentExpr)])
@@ -28830,7 +29481,13 @@ function transformControlFlowReturns(statements, ctx) {
         (acc, expr) => t4.logicalExpression("||", acc, expr),
         comparisons[0]
       );
-      currentExpr = buildConditionalBindingExpr(testExpr, trueFn, falseFn);
+      currentExpr = buildConditionalBindingExpr(
+        testExpr,
+        trueFn,
+        falseFn,
+        trackBranchReads ? { trackBranchReads: true } : void 0
+      );
+      currentExprNeedsTrackedBranchReads = trackBranchReads;
     }
     return t4.callExpression(
       t4.arrowFunctionExpression(
@@ -30200,11 +30857,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));
@@ -30214,22 +30887,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);
@@ -30269,15 +30942,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);
@@ -30927,6 +31600,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);
         }
@@ -30943,8 +31618,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;
@@ -31250,6 +31927,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;
@@ -31258,6 +31945,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) {
@@ -33179,8 +33874,52 @@ function shouldSuppressWarning(suppressions, code, line) {
   });
 }
 var DEFAULT_ERROR_WARNING_CODES = /* @__PURE__ */ new Set(["FICT-R004"]);
+var STRICT_REACTIVITY_WARNING_CODES = /* @__PURE__ */ new Set(["FICT-R003", "FICT-R006"]);
+var STRICT_GUARANTEE_WARNING_CODES = /* @__PURE__ */ new Set([
+  "FICT-P001",
+  "FICT-P002",
+  "FICT-P003",
+  "FICT-P004",
+  "FICT-P005",
+  "FICT-J003",
+  "FICT-S002",
+  "FICT-R001",
+  "FICT-R002",
+  "FICT-R003",
+  "FICT-R006"
+]);
+function readBooleanEnv(name) {
+  const raw = process.env[name];
+  if (!raw) return void 0;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return void 0;
+}
+function validateStrictGuaranteeConfig(options, suppressions) {
+  if (!options.strictGuarantee) return;
+  if (suppressions.length > 0) {
+    throw new Error(
+      "strictGuarantee does not allow fict-ignore suppression comments. Remove suppressions to keep fail-closed guarantees."
+    );
+  }
+  if (!options.warningLevels) return;
+  for (const [code, level] of Object.entries(options.warningLevels)) {
+    if (!STRICT_GUARANTEE_WARNING_CODES.has(code)) continue;
+    if (level === "error") continue;
+    throw new Error(
+      `strictGuarantee does not allow downgrading ${code} to "${level}". Remove this warningLevels override.`
+    );
+  }
+}
 function hasErrorEscalation(options) {
   if (DEFAULT_ERROR_WARNING_CODES.size > 0) return true;
+  if (options.strictGuarantee) return true;
+  if (options.strictReactivity) return true;
   if (options.warningsAsErrors === true) return true;
   if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.length > 0) return true;
   if (options.warningLevels) {
@@ -33189,8 +33928,10 @@ function hasErrorEscalation(options) {
   return false;
 }
 function resolveWarningLevel(code, options) {
+  if (options.strictGuarantee && STRICT_GUARANTEE_WARNING_CODES.has(code)) return "error";
   const override = options.warningLevels?.[code];
   if (override) return override;
+  if (options.strictReactivity && STRICT_REACTIVITY_WARNING_CODES.has(code)) return "error";
   if (options.warningsAsErrors === true) return "error";
   if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.includes(code)) {
     return "error";
@@ -33204,6 +33945,7 @@ function formatWarningAsError(warning) {
   at ${location}`;
 }
 function createWarningDispatcher(onWarn, suppressions, options, dev) {
+  validateStrictGuaranteeConfig(options, suppressions);
   const hasEscalation = hasErrorEscalation(options);
   if (!dev && !hasEscalation) return () => {
   };
@@ -33309,7 +34051,7 @@ function isDynamicPropertyAccess(node, t4) {
   if (!node.computed) return false;
   return !(t4.isStringLiteral(node.property) || t4.isNumericLiteral(node.property));
 }
-function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, reactiveBindingIds, effectMacroNames, warn, fileName, t4) {
+function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, reactiveBindingIds, stateMacroNames, memoMacroNames, effectMacroNames, warn, fileName, t4) {
   const hasTrackedBinding = (path2, name, tracked) => {
     const binding = path2.scope.getBinding(name);
     return !!(binding && tracked.has(binding.identifier));
@@ -33324,6 +34066,107 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
     if (!root) return false;
     return hasTrackedBinding(path2, root.name, reactiveBindingIds);
   };
+  const NON_ESCAPING_CALLBACK_METHODS = /* @__PURE__ */ new Set([
+    "map",
+    "forEach",
+    "filter",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "flatMap",
+    "reduce",
+    "reduceRight",
+    "sort",
+    "toSorted",
+    "then",
+    "catch",
+    "finally"
+  ]);
+  const capturedClosureByBinding = /* @__PURE__ */ new Map();
+  const shouldIgnoreIdentifierReference = (idPath) => {
+    if (idPath.parentPath.isMemberExpression({ property: idPath.node }) && !idPath.parent.computed) {
+      return true;
+    }
+    if (idPath.parentPath.isObjectProperty({ key: idPath.node }) && !idPath.parent.computed && !idPath.parent.shorthand) {
+      return true;
+    }
+    return false;
+  };
+  const collectCapturedReactiveNames = (fnPath) => {
+    const captured = /* @__PURE__ */ new Set();
+    fnPath.traverse({
+      Function(inner) {
+        if (inner === fnPath) return;
+        inner.skip();
+      },
+      Identifier(idPath) {
+        if (shouldIgnoreIdentifierReference(idPath)) return;
+        const name = idPath.node.name;
+        const binding = idPath.scope.getBinding(name);
+        if (!binding) return;
+        if (!reactiveBindingIds.has(binding.identifier)) return;
+        if (binding.scope === idPath.scope || binding.scope === fnPath.scope) return;
+        captured.add(name);
+      }
+    });
+    return captured;
+  };
+  const registerClosureCaptureBinding = (fnPath, captured) => {
+    if (captured.size === 0) return;
+    if (fnPath.isFunctionDeclaration() && fnPath.node.id) {
+      const binding = fnPath.parentPath.scope.getBinding(fnPath.node.id.name);
+      if (binding) {
+        capturedClosureByBinding.set(binding.identifier, captured);
+      }
+      return;
+    }
+    if ((fnPath.isFunctionExpression() || fnPath.isArrowFunctionExpression()) && fnPath.parentPath.isVariableDeclarator()) {
+      const id = fnPath.parentPath.node.id;
+      if (!t4.isIdentifier(id)) return;
+      const binding = fnPath.parentPath.scope.getBinding(id.name);
+      if (binding) {
+        capturedClosureByBinding.set(binding.identifier, captured);
+      }
+      return;
+    }
+    if (fnPath.parentPath.isAssignmentExpression({ right: fnPath.node })) {
+      const left = fnPath.parentPath.node.left;
+      if (!t4.isIdentifier(left)) return;
+      const binding = fnPath.parentPath.scope.getBinding(left.name);
+      if (binding) {
+        capturedClosureByBinding.set(binding.identifier, captured);
+      }
+    }
+  };
+  const collectCapturedForArgument = (argPath) => {
+    if (argPath.isArrowFunctionExpression() || argPath.isFunctionExpression()) {
+      const captured2 = collectCapturedReactiveNames(argPath);
+      return captured2.size > 0 ? captured2 : null;
+    }
+    if (!argPath.isIdentifier()) return null;
+    const binding = argPath.scope.getBinding(argPath.node.name);
+    if (!binding) return null;
+    const captured = capturedClosureByBinding.get(binding.identifier);
+    return captured && captured.size > 0 ? captured : null;
+  };
+  const isNonEscapingCallbackHost = (callee) => {
+    const member = t4.isMemberExpression(callee) || t4.isOptionalMemberExpression(callee) ? callee : null;
+    if (!member || member.computed || !t4.isIdentifier(member.property)) return false;
+    return NON_ESCAPING_CALLBACK_METHODS.has(member.property.name);
+  };
+  const emitClosureCaptureWarning = (node, captured) => {
+    const names = Array.from(captured).sort().join(", ");
+    emitWarning(
+      node,
+      "FICT-R005",
+      `Function captures reactive variable(s): ${names}. Pass them as parameters or memoize explicitly to avoid hidden dependencies.`,
+      warn,
+      fileName
+    );
+  };
   const argumentHasReactive = (argPath) => {
     if (argPath.isSpreadElement()) {
       const inner = argPath.get("argument");
@@ -33346,12 +34189,7 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
         path2.skip();
       },
       Identifier(idPath) {
-        if (idPath.parentPath.isMemberExpression({ property: idPath.node }) && !idPath.parent.computed) {
-          return;
-        }
-        if (idPath.parentPath.isObjectProperty({ key: idPath.node }) && !idPath.parent.computed && !idPath.parent.shorthand) {
-          return;
-        }
+        if (shouldIgnoreIdentifierReference(idPath)) return;
         const binding = idPath.scope.getBinding(idPath.node.name);
         if (binding && reactiveBindingIds.has(binding.identifier)) {
           found = true;
@@ -33432,36 +34270,14 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
       }
     },
     Function(path2) {
-      const captured = /* @__PURE__ */ new Set();
-      path2.traverse(
-        {
-          Function(inner) {
-            if (inner === path2) return;
-            inner.skip();
-          },
-          Identifier(idPath) {
-            const name = idPath.node.name;
-            const binding = idPath.scope.getBinding(name);
-            if (!binding) return;
-            if (!reactiveBindingIds.has(binding.identifier)) return;
-            if (binding.scope === idPath.scope || binding.scope === path2.scope) return;
-            captured.add(name);
-          }
-        },
-        {}
-      );
-      if (captured.size > 0) {
-        emitWarning(
-          path2.node,
-          "FICT-R005",
-          `Function captures reactive variable(s): ${Array.from(captured).join(", ")}. Pass them as parameters or memoize explicitly to avoid hidden dependencies.`,
-          warn,
-          fileName
-        );
-      }
+      const captured = collectCapturedReactiveNames(path2);
+      registerClosureCaptureBinding(path2, captured);
     },
     CallExpression(path2) {
-      const isEffect = isEffectCall(path2.node, t4, effectMacroNames);
+      const callNode = path2.node;
+      if (isStateCall(callNode, t4, stateMacroNames)) return;
+      if (isMemoCall(callNode, t4, memoMacroNames)) return;
+      const isEffect = isEffectCall(callNode, t4, effectMacroNames);
       if (isEffect) {
         const argPath = path2.get("arguments.0");
         if (argPath?.isFunctionExpression() || argPath?.isArrowFunctionExpression()) {
@@ -33484,7 +34300,7 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
           });
           if (!hasReactiveDependency) {
             emitWarning(
-              path2.node,
+              callNode,
               "FICT-E001",
               "Effect has no reactive reads; it will run once. Consider removing $effect or adding dependencies.",
               warn,
@@ -33507,6 +34323,7 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
       const isSafe = calleeName && SAFE_FUNCTIONS.has(calleeName);
       if (isSafe) return;
       const argPaths = path2.get("arguments");
+      const nonEscapingCallbackHost = isNonEscapingCallbackHost(callee);
       for (const argPath of argPaths) {
         if (argPath.isIdentifier() && hasTrackedBinding(argPath, argPath.node.name, stateBindingIds)) {
           continue;
@@ -33522,6 +34339,13 @@ function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, react
           break;
         }
       }
+      if (nonEscapingCallbackHost) return;
+      for (const argPath of argPaths) {
+        const captured = collectCapturedForArgument(argPath);
+        if (!captured) continue;
+        emitClosureCaptureWarning(argPath.node, captured);
+        break;
+      }
     },
     OptionalMemberExpression(path2) {
       if (!path2.node.computed) return;
@@ -34386,6 +35210,8 @@ or extract the nested logic into a custom hook (useXxx).`
             stateBindingIds,
             stateRootBindingIds,
             reactiveBindingIds,
+            stateMacroNames,
+            memoMacroNames,
             effectMacroNames,
             warn,
             fileName,
@@ -34430,13 +35256,17 @@ var createFictPlugin = (0, import_helper_plugin_utils.declare)(
   (api, options = {}) => {
     api.assertVersion(7);
     const t4 = api.types;
+    const strictGuaranteeFromEnv = readBooleanEnv("FICT_STRICT_GUARANTEE") === true;
     const normalizedOptions = {
       ...options,
       fineGrainedDom: options.fineGrainedDom ?? true,
+      lazyConditional: options.lazyConditional ?? true,
+      getterCache: options.getterCache ?? true,
       optimize: options.optimize ?? true,
       optimizeLevel: options.optimizeLevel ?? "safe",
       inlineDerivedMemos: options.inlineDerivedMemos ?? true,
       emitModuleMetadata: options.emitModuleMetadata ?? "auto",
+      strictGuarantee: strictGuaranteeFromEnv || options.strictGuarantee !== false,
       dev: options.dev ?? (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test")
     };
     return {