@fictjs/compiler 0.8.0 → 0.9.0

package/README.md

@@ -39,7 +39,17 @@ createFictPlugin({
 
 - `dev` (default: `NODE_ENV !== 'production' && NODE_ENV !== 'test'`): enables compiler warnings/diagnostics. Set to `false` to silence warnings.
 - `onWarn`: custom warning handler (only called when `dev` is enabled).
+- `fineGrainedDom` (default: `true`): emits template-first fine-grained DOM operations for supported JSX.
+- `lazyConditional` (default: `true`): enables control-flow lazy lowering for reactive branch returns where supported.
+- `getterCache` (default: `true`): caches repeated getter reads within the same synchronous block.
+- `optimize` (default: `true`): enables optimizer passes.
+- `optimizeLevel` (default: `'safe'`): conservative algebraic optimization level.
 - `inlineDerivedMemos` (default: `true`): allow the compiler to inline single-use derived values. Set to `false` for a “strict memo” mode where user-named derived values keep explicit memo accessors (unless `"use no memo"` disables memoization).
+- `strictReactivity` (default: `false`): treat control-flow fallback diagnostics (`FICT-R003`, `FICT-R006`) as build errors. Useful for CI gates that require deterministic fine-grained reactivity without fallback paths.
+- `strictGuarantee` (default: `true`): fail-closed mode for reactivity guarantees. Non-guaranteed reactivity diagnostics (including control-flow fallback and props fallback classes) are treated as hard errors and cannot be suppressed/downgraded.
+  - Opt-out: set `strictGuarantee: false` to compile in non-strict mode.
+  - CI override: set `FICT_STRICT_GUARANTEE=1` to force-enable `strictGuarantee` even when options request opt-out.
+  - Contract fixtures: see `packages/compiler/test/reactivity-guarantee-contract.test.ts` for the maintained guarantee/fallback/unsupported matrix checks.
 - `emitModuleMetadata`:
   - `true`: always write adjacent `.fict.meta.json` sidecar files next to source files.
   - `false`: never write metadata files.
@@ -49,3 +59,12 @@ createFictPlugin({
 - `reactiveScopes`: function names whose **first callback argument** is treated as a component-like reactive scope.
   - Only **direct calls** are recognized (e.g., `renderHook(() => ...)` or `utils.renderHook(() => ...)`).
   - **Aliases/indirect calls** are not recognized (e.g., `const rh = renderHook; rh(() => ...)`).
+
+## Recommended Profiles
+
+Use `docs/config-profiles.md` for copy-paste presets:
+
+- strict default app profile (`strictGuarantee: true`)
+- CI hard-gate profile
+- migration/benchmark profile (`strictGuarantee: false`)
+- one-shot build profile (`emitModuleMetadata: false`)

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
@@ -24066,17 +24069,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 +24119,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
@@ -25429,6 +25442,7 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
 // 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",
@@ -28568,10 +28582,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 +28611,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 +28807,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 +28818,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 +28861,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 +28960,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 +28983,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(
@@ -33179,8 +33338,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 +33392,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 +33409,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 +33515,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 +33530,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 +33653,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 +33734,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 +33764,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 +33787,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 +33803,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 +34674,8 @@ or extract the nested logic into a custom hook (useXxx).`
             stateBindingIds,
             stateRootBindingIds,
             reactiveBindingIds,
+            stateMacroNames,
+            memoMacroNames,
             effectMacroNames,
             warn,
             fileName,
@@ -34430,13 +34720,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 {

package/dist/index.d.cts

@@ -23,9 +23,9 @@ interface FictCompilerOptions {
     onWarn?: (warning: CompilerWarning) => void;
     /** Internal: filename of the module being compiled. */
     filename?: string;
-    /** Enable lazy evaluation of conditional derived values (Rule J optimization) */
+    /** Enable lazy evaluation of conditional derived values (Rule J optimization). Default: true. */
     lazyConditional?: boolean;
-    /** Enable getter caching within the same sync block (Rule L optimization) */
+    /** Enable getter caching within the same sync block (Rule L optimization). Default: true. */
     getterCache?: boolean;
     /** Emit fine-grained DOM creation/binding code for supported JSX templates */
     fineGrainedDom?: boolean;
@@ -63,6 +63,19 @@ interface FictCompilerOptions {
      * Per-warning override. "off" suppresses, "error" throws, "warn" emits.
      */
     warningLevels?: Record<string, 'off' | 'warn' | 'error'>;
+    /**
+     * Strict control-flow reactivity mode.
+     * When enabled, control-flow fallback diagnostics (`FICT-R003`, `FICT-R006`)
+     * are treated as errors unless explicitly overridden via `warningLevels`.
+     */
+    strictReactivity?: boolean;
+    /**
+     * Fail-closed reactivity guarantee mode.
+     * When enabled, diagnostics that indicate non-guaranteed reactive behavior are
+     * treated as hard errors and cannot be suppressed/downgraded.
+     * Default: true.
+     */
+    strictGuarantee?: boolean;
     /**
      * Optional shared module metadata map for cross-module reactive imports.
      * If omitted, the compiler uses a process-wide cache.

package/dist/index.d.ts

@@ -23,9 +23,9 @@ interface FictCompilerOptions {
     onWarn?: (warning: CompilerWarning) => void;
     /** Internal: filename of the module being compiled. */
     filename?: string;
-    /** Enable lazy evaluation of conditional derived values (Rule J optimization) */
+    /** Enable lazy evaluation of conditional derived values (Rule J optimization). Default: true. */
     lazyConditional?: boolean;
-    /** Enable getter caching within the same sync block (Rule L optimization) */
+    /** Enable getter caching within the same sync block (Rule L optimization). Default: true. */
     getterCache?: boolean;
     /** Emit fine-grained DOM creation/binding code for supported JSX templates */
     fineGrainedDom?: boolean;
@@ -63,6 +63,19 @@ interface FictCompilerOptions {
      * Per-warning override. "off" suppresses, "error" throws, "warn" emits.
      */
     warningLevels?: Record<string, 'off' | 'warn' | 'error'>;
+    /**
+     * Strict control-flow reactivity mode.
+     * When enabled, control-flow fallback diagnostics (`FICT-R003`, `FICT-R006`)
+     * are treated as errors unless explicitly overridden via `warningLevels`.
+     */
+    strictReactivity?: boolean;
+    /**
+     * Fail-closed reactivity guarantee mode.
+     * When enabled, diagnostics that indicate non-guaranteed reactive behavior are
+     * treated as hard errors and cannot be suppressed/downgraded.
+     * Default: true.
+     */
+    strictGuarantee?: boolean;
     /**
      * Optional shared module metadata map for cross-module reactive imports.
      * If omitted, the compiler uses a process-wide cache.

package/dist/index.js

@@ -14226,6 +14226,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
@@ -24051,17 +24054,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");
@@ -24099,7 +24104,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
@@ -25414,6 +25427,7 @@ function emitResumableEventBinding(targetId, eventName, expr, statements, ctx, c
 // 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",
@@ -28553,10 +28567,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;
@@ -28579,17 +28596,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;
@@ -28658,7 +28792,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");
@@ -28669,6 +28803,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(
@@ -28702,7 +28846,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;
@@ -28795,10 +28945,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)])
@@ -28815,7 +28968,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(
@@ -33164,8 +33323,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) {
@@ -33174,8 +33377,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";
@@ -33189,6 +33394,7 @@ function formatWarningAsError(warning) {
   at ${location}`;
 }
 function createWarningDispatcher(onWarn, suppressions, options, dev) {
+  validateStrictGuaranteeConfig(options, suppressions);
   const hasEscalation = hasErrorEscalation(options);
   if (!dev && !hasEscalation) return () => {
   };
@@ -33294,7 +33500,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));
@@ -33309,6 +33515,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");
@@ -33331,12 +33638,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;
@@ -33417,36 +33719,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()) {
@@ -33469,7 +33749,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,
@@ -33492,6 +33772,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;
@@ -33507,6 +33788,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;
@@ -34371,6 +34659,8 @@ or extract the nested logic into a custom hook (useXxx).`
             stateBindingIds,
             stateRootBindingIds,
             reactiveBindingIds,
+            stateMacroNames,
+            memoMacroNames,
             effectMacroNames,
             warn,
             fileName,
@@ -34415,13 +34705,17 @@ var createFictPlugin = 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 {

package/package.json

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