@sarj/eslint-plugin 16.26.0 → 16.26.2

package/dist/index.cjs

@@ -883,7 +883,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.26.0",
+  version: "16.26.2",
   packageManager: "npm@12.2.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -8845,6 +8845,14 @@ var import_utils53 = require("@typescript-eslint/utils");
 
 // src/rules/_stable-value-binding.ts
 var import_utils52 = require("@typescript-eslint/utils");
+function typeOnlyReference2(reference) {
+  if (reference.isTypeReference && !reference.isValueReference) return true;
+  let current = outerExpression(reference.identifier);
+  while (current.parent?.type === import_utils52.AST_NODE_TYPES.TSQualifiedName && current.parent.left === current) {
+    current = current.parent;
+  }
+  return current.parent?.type === import_utils52.AST_NODE_TYPES.TSTypeQuery && current.parent.exprName === current;
+}
 function stableValueBinding(variable, acceptRead) {
   let initializer;
   return variable.references.every((reference) => {
@@ -11076,6 +11084,7 @@ var no_bare_return_from_test_catch_default = createRule({
         const returnBlock = node.parent;
         if (parameter?.type === import_utils64.AST_NODE_TYPES.Identifier && returnBlock?.type === import_utils64.AST_NODE_TYPES.BlockStatement) {
           const errorBinding = import_utils64.ASTUtils.findVariable(context.sourceCode.getScope(parameter), parameter.name);
+          const errorReferences = errorBinding !== null && errorBinding.references.length > 32 ? new Set(errorBinding.references.map((reference) => reference.identifier)) : void 0;
           const assertedError = returnBlock.body.some((statement) => {
             if (statement.range[1] > node.range[0] || statement.type !== import_utils64.AST_NODE_TYPES.ExpressionStatement) return false;
             const expression = statement.expression;
@@ -11086,7 +11095,7 @@ var no_bare_return_from_test_catch_default = createRule({
             let operand = expression.callee.type === import_utils64.AST_NODE_TYPES.MemberExpression ? expression.callee.object : null;
             if (operand?.type === import_utils64.AST_NODE_TYPES.MemberExpression && staticMemberName3(operand) === "not") operand = operand.object;
             if (assertionName !== "assert" && (assertionName !== "expect" || operand?.type !== import_utils64.AST_NODE_TYPES.CallExpression || operand.callee !== root)) return false;
-            return walkOwnScope(expression, (current) => current.type === import_utils64.AST_NODE_TYPES.Identifier && errorBinding?.references.some((reference) => reference.identifier === current) === true);
+            return walkOwnScope(expression, (current) => current.type === import_utils64.AST_NODE_TYPES.Identifier && (errorReferences?.has(current) ?? errorBinding?.references.some((reference) => reference.identifier === current)) === true);
           });
           if (assertedError) return;
         }
@@ -17317,6 +17326,15 @@ var test_loops_over_literal_cases_default = createRule({
     if (!isTestFile(context)) {
       return {};
     }
+    const referenceIdentifiers = /* @__PURE__ */ new WeakMap();
+    const isReference = (variable, identifier) => {
+      let identifiers = referenceIdentifiers.get(variable);
+      if (identifiers === void 0) {
+        identifiers = new Set(variable.references.map((reference) => reference.identifier));
+        referenceIdentifiers.set(variable, identifiers);
+      }
+      return identifiers.has(identifier);
+    };
     const isFrameworkTest = (identifier) => TEST_CALLERS3.has(runtimeTestFrameworkName(context.sourceCode, identifier, "test") ?? "");
     const isFrameworkAssertion = (identifier) => ASSERTION_ROOTS.has(runtimeTestFrameworkName(context.sourceCode, identifier, "assertion") ?? "");
     return {
@@ -17340,7 +17358,7 @@ var test_loops_over_literal_cases_default = createRule({
         const capturesSetup = walkOwnScope2(node.body, (current) => {
           if (current.type !== import_utils99.AST_NODE_TYPES.Identifier) return false;
           const variable = import_utils99.ASTUtils.findVariable(context.sourceCode.getScope(current), current.name);
-          if (variable === null || !variable.references.some((reference) => reference.identifier === current)) return false;
+          if (variable === null || !isReference(variable, current)) return false;
           return variable.defs.some((definition) => {
             const declaration = definition.name;
             return declaration.range[0] >= enclosing.range[0] && declaration.range[1] <= enclosing.range[1] && (declaration.range[0] < node.range[0] || declaration.range[1] > node.range[1]);
@@ -20789,6 +20807,7 @@ var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
     "Only direct imports, const bindings, and inline calls with statically proven provenance from crypto or node:crypto are analyzed; arbitrary assignments and dynamic module specifiers are excluded.",
     "Only a literal algorithm with exactly one update call is reported; streaming and incremental hashes remain valid.",
     "Namespace bindings must remain read-only: visible writes, aliases, exports, inherited mutation or alias methods, unknown computed members, and other escaping uses are excluded; type-only references and direct member calls remain eligible.",
+    "CommonJS loads and default imports share one mutable native module object. A visible unsafe use of that object excludes its other loads; ESM named exports remain separate unless visible native export synchronization can update them.",
     "Runtime support and output encoding require manual review; no autofix or guaranteed speedup is promised."
   ],
   references: ["https://nodejs.org/api/crypto.html#cryptohashalgorithm-data-options"],
@@ -20803,39 +20822,57 @@ var UNSAFE_NAMESPACE_METHODS = /* @__PURE__ */ new Set(["__defineGetter__", "__d
 function stableNamespace(variable) {
   if (variable.defs.some((definition) => definition.type === "Variable" && definition.parent.parent.type === import_utils118.AST_NODE_TYPES.ExportNamedDeclaration)) return false;
   return stableValueBinding(variable, (reference) => {
-    if (reference.isTypeReference && !reference.isValueReference) return true;
+    if (typeOnlyReference2(reference)) return true;
+    const receiver = outerExpression(reference.identifier);
+    return readonlyNamespaceUse(receiver);
+  });
+}
+function readonlyNamespaceUse(receiver) {
+  const member = receiver.parent;
+  if (member?.type !== import_utils118.AST_NODE_TYPES.MemberExpression || member.object !== receiver) {
+    return member?.type === import_utils118.AST_NODE_TYPES.UnaryExpression && member.operator === "typeof";
+  }
+  const use = outerExpression(member);
+  const name = import_utils118.ASTUtils.getPropertyName(member);
+  return name !== null && !UNSAFE_NAMESPACE_METHODS.has(name) && use.parent?.type === import_utils118.AST_NODE_TYPES.CallExpression && use.parent.callee === use;
+}
+function readonlyLoaderUse(node, resolve2, stable) {
+  const receiver = outerExpression(node);
+  const parent = receiver.parent;
+  if (parent?.type === import_utils118.AST_NODE_TYPES.VariableDeclarator && parent.init === receiver) {
+    if (parent.id.type === import_utils118.AST_NODE_TYPES.ObjectPattern) return true;
+    if (parent.id.type !== import_utils118.AST_NODE_TYPES.Identifier) return false;
+    const variable = resolve2(parent.id);
+    return variable !== null && stable(variable);
+  }
+  return parent?.type === import_utils118.AST_NODE_TYPES.ExpressionStatement || readonlyNamespaceUse(receiver);
+}
+function namespaceDefaultMayEscape(variable) {
+  return variable.references.some((reference) => {
+    if (typeOnlyReference2(reference)) return false;
     const receiver = outerExpression(reference.identifier);
-    if (typeQueryReference(receiver)) return true;
     const member = receiver.parent;
     if (member?.type !== import_utils118.AST_NODE_TYPES.MemberExpression || member.object !== receiver) {
-      return member?.type === import_utils118.AST_NODE_TYPES.UnaryExpression && member.operator === "typeof";
+      return member?.type !== import_utils118.AST_NODE_TYPES.UnaryExpression || member.operator !== "typeof";
     }
-    const use = outerExpression(member);
     const name = import_utils118.ASTUtils.getPropertyName(member);
-    return name !== null && !UNSAFE_NAMESPACE_METHODS.has(name) && use.parent?.type === import_utils118.AST_NODE_TYPES.CallExpression && use.parent.callee === use;
+    return (name === null || name === "default") && !readonlyNamespaceUse(outerExpression(member));
   });
 }
-function typeQueryReference(node) {
-  let current = node;
-  while (current.parent?.type === import_utils118.AST_NODE_TYPES.TSQualifiedName && current.parent.left === current) {
-    current = current.parent;
-  }
-  return current.parent?.type === import_utils118.AST_NODE_TYPES.TSTypeQuery && current.parent.exprName === current;
-}
-function isCryptoLoader(node, resolve2) {
-  const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
+function isBuiltinLoader(node, resolve2, builtin = "crypto") {
   if (node.type !== import_utils118.AST_NODE_TYPES.CallExpression || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
-  if (argument === void 0 || argument.type === import_utils118.AST_NODE_TYPES.SpreadElement || !isCryptoSpecifier(argument)) {
+  if (argument === void 0 || argument.type === import_utils118.AST_NODE_TYPES.SpreadElement || !isBuiltinSpecifier(argument, builtin)) {
     return false;
   }
+  const unwrappedNodeCallee = unwrapExpression(node.callee);
   if (unwrappedNodeCallee?.type === import_utils118.AST_NODE_TYPES.Identifier) {
     return unwrappedNodeCallee.name === "require" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee, resolve2);
   }
   return unwrappedNodeCallee?.type === import_utils118.AST_NODE_TYPES.MemberExpression && unwrappedNodeCallee.object.type === import_utils118.AST_NODE_TYPES.Identifier && unwrappedNodeCallee.object.name === "process" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee.object, resolve2) && import_utils118.ASTUtils.getPropertyName(unwrappedNodeCallee) === "getBuiltinModule";
 }
-function isCryptoSpecifier(node) {
-  return node.type === import_utils118.AST_NODE_TYPES.Literal && (node.value === "crypto" || node.value === "node:crypto");
+function isBuiltinSpecifier(node, builtin) {
+  return node.type === import_utils118.AST_NODE_TYPES.Literal && (node.value === builtin || node.value === `node:${builtin}`);
 }
 function isUnshadowedBuiltinIdentifier(identifier, resolve2) {
   const variable = resolve2(identifier);
@@ -20854,46 +20891,84 @@ var prefer_node_crypto_hash_default = createRule({
   meta: { type: "problem", docs: { description: PREFER_NODE_CRYPTO_HASH_DOCUMENTATION.summary }, schema: [], messages: { preferNodeCryptoHash: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary." } },
   defaultOptions: [],
   create(context) {
+    if (!context.sourceCode.text.includes("crypto") && !context.sourceCode.text.includes("\\")) return {};
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
+    const sharedBindings = /* @__PURE__ */ new Set();
+    const syncBindings = /* @__PURE__ */ new Set();
+    const moduleBindings = /* @__PURE__ */ new Set();
+    const namespaceStability = /* @__PURE__ */ new WeakMap();
+    const candidates = [];
+    const possibleSynchronizations = [];
+    let sharedNamespaceUnsafe = false;
+    function namespaceStable(variable) {
+      const cached = namespaceStability.get(variable);
+      if (cached !== void 0) return cached;
+      const stable = stableNamespace(variable);
+      namespaceStability.set(variable, stable);
+      return stable;
+    }
     function resolve2(identifier) {
       return import_utils118.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
     }
-    function record(identifier, destination) {
+    function record(identifier, destination, shared = false) {
       const variable = resolve2(identifier);
-      if (variable !== null && (destination === namespaceBindings ? stableNamespace(variable) : stableValueBinding(variable))) destination.add(variable);
+      if (variable === null) return;
+      const stable = destination === namespaceBindings ? namespaceStable(variable) : stableValueBinding(variable);
+      if (shared && destination === namespaceBindings && !stable) sharedNamespaceUnsafe = true;
+      if (!stable) return;
+      destination.add(variable);
+      if (shared) sharedBindings.add(variable);
+    }
+    function recordModuleImports(specifiers) {
+      for (const specifier of specifiers) {
+        if (specifier.type === import_utils118.AST_NODE_TYPES.ImportSpecifier) {
+          if (importedName5(specifier.imported) === "syncBuiltinESMExports") record(specifier.local, syncBindings);
+          else if (importedName5(specifier.imported) === "default") record(specifier.local, moduleBindings);
+        } else record(specifier.local, moduleBindings);
+      }
     }
     return {
       ImportDeclaration(node) {
+        if (node.source.value === "module" || node.source.value === "node:module") {
+          recordModuleImports(node.specifiers);
+          return;
+        }
         if (node.source.value !== "crypto" && node.source.value !== "node:crypto") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils118.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils118.AST_NODE_TYPES.ImportDefaultSpecifier) {
-            record(specifier.local, namespaceBindings);
+          const shared = specifier.type === import_utils118.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils118.AST_NODE_TYPES.ImportSpecifier && importedName5(specifier.imported) === "default";
+          if (specifier.type === import_utils118.AST_NODE_TYPES.ImportNamespaceSpecifier || shared) {
+            record(specifier.local, namespaceBindings, shared);
+            const variable = resolve2(specifier.local);
+            if (!shared && variable !== null && namespaceDefaultMayEscape(variable)) sharedNamespaceUnsafe = true;
           } else if (specifier.type === import_utils118.AST_NODE_TYPES.ImportSpecifier && importedName5(specifier.imported) === "createHash") {
             record(specifier.local, directBindings);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve2)) {
+        if (node.parent.kind !== "const" || node.init === null || !isBuiltinLoader(node.init, resolve2) && !isBuiltinLoader(node.init, resolve2, "module")) {
           return;
         }
+        const crypto = isBuiltinLoader(node.init, resolve2);
         if (node.id.type === import_utils118.AST_NODE_TYPES.Identifier) {
-          record(node.id, namespaceBindings);
+          record(node.id, crypto ? namespaceBindings : moduleBindings, crypto);
           return;
         }
         if (node.id.type !== import_utils118.AST_NODE_TYPES.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === import_utils118.AST_NODE_TYPES.Property && propertyName3(property) === "createHash" && property.value.type === import_utils118.AST_NODE_TYPES.Identifier) {
-            record(property.value, directBindings);
+          if (property.type === import_utils118.AST_NODE_TYPES.Property && propertyName3(property) === (crypto ? "createHash" : "syncBuiltinESMExports") && property.value.type === import_utils118.AST_NODE_TYPES.Identifier) {
+            record(property.value, crypto ? directBindings : syncBindings, crypto);
           }
         }
       },
       CallExpression(node) {
+        if (isBuiltinLoader(node, resolve2) && !readonlyLoaderUse(node, resolve2, namespaceStable)) sharedNamespaceUnsafe = true;
         const unwrappedNodeCallee = unwrapExpression(node.callee);
+        if (unwrappedNodeCallee.type === import_utils118.AST_NODE_TYPES.Identifier || unwrappedNodeCallee.type === import_utils118.AST_NODE_TYPES.MemberExpression && import_utils118.ASTUtils.getPropertyName(unwrappedNodeCallee) === "syncBuiltinESMExports") possibleSynchronizations.push(node);
         if (unwrappedNodeCallee.type !== import_utils118.AST_NODE_TYPES.MemberExpression || !isMemberCall(node, "digest")) return;
         const update = unwrapExpression(unwrappedNodeCallee.object);
         if (update.type !== import_utils118.AST_NODE_TYPES.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
@@ -20902,14 +20977,16 @@ var prefer_node_crypto_hash_default = createRule({
         if (updateCallee.type !== import_utils118.AST_NODE_TYPES.MemberExpression) return;
         const create = unwrapExpression(updateCallee.object);
         const algorithm = create.type === import_utils118.AST_NODE_TYPES.CallExpression && create.arguments[0] !== void 0 ? unwrapExpression(create.arguments[0]) : null;
-        if (create.type !== import_utils118.AST_NODE_TYPES.CallExpression || create.arguments.length !== 1 || staticString(algorithm ?? void 0) === null || !isCreateHashCall(
-          create,
-          directBindings,
-          namespaceBindings,
-          resolve2
-        ))
+        if (create.type !== import_utils118.AST_NODE_TYPES.CallExpression || create.arguments.length !== 1 || staticString(algorithm ?? void 0) === null)
           return;
-        context.report({ node, messageId: "preferNodeCryptoHash" });
+        const provider = builtinCallProvider(create, directBindings, namespaceBindings, sharedBindings, resolve2);
+        if (provider !== null) candidates.push({ node, shared: provider === "shared" });
+      },
+      "Program:exit"() {
+        const exportsMaySynchronize = sharedNamespaceUnsafe && possibleSynchronizations.some((node) => builtinCallProvider(node, syncBindings, moduleBindings, sharedBindings, resolve2, "module") !== null);
+        for (const candidate2 of candidates) {
+          if (!sharedNamespaceUnsafe || !candidate2.shared && !exportsMaySynchronize) context.report({ node: candidate2.node, messageId: "preferNodeCryptoHash" });
+        }
       }
     };
   }
@@ -20921,19 +20998,21 @@ function isMemberCall(node, name) {
   const unwrappedNodeCallee = unwrapExpression(node.callee);
   return unwrappedNodeCallee.type === import_utils118.AST_NODE_TYPES.MemberExpression && import_utils118.ASTUtils.getPropertyName(unwrappedNodeCallee) === name;
 }
-function isCreateHashCall(node, directBindings, namespaceBindings, resolve2) {
+function builtinCallProvider(node, directBindings, namespaceBindings, sharedBindings, resolve2, builtin = "crypto") {
   const unwrappedNodeCallee = unwrapExpression(node.callee);
   if (unwrappedNodeCallee.type === import_utils118.AST_NODE_TYPES.Identifier) {
     const variable2 = resolve2(unwrappedNodeCallee);
-    return variable2 !== null && directBindings.has(variable2);
+    if (variable2 === null || !directBindings.has(variable2)) return null;
+    return sharedBindings.has(variable2) ? "shared" : "snapshot";
   }
-  if (unwrappedNodeCallee.type !== import_utils118.AST_NODE_TYPES.MemberExpression || import_utils118.ASTUtils.getPropertyName(unwrappedNodeCallee) !== "createHash") {
-    return false;
+  if (unwrappedNodeCallee.type !== import_utils118.AST_NODE_TYPES.MemberExpression || import_utils118.ASTUtils.getPropertyName(unwrappedNodeCallee) !== (builtin === "crypto" ? "createHash" : "syncBuiltinESMExports")) {
+    return null;
   }
-  if (isCryptoLoader(unwrappedNodeCallee.object, resolve2)) return true;
-  if (unwrappedNodeCallee.object.type !== import_utils118.AST_NODE_TYPES.Identifier) return false;
+  if (isBuiltinLoader(unwrappedNodeCallee.object, resolve2, builtin)) return "shared";
+  if (unwrappedNodeCallee.object.type !== import_utils118.AST_NODE_TYPES.Identifier) return null;
   const variable = resolve2(unwrappedNodeCallee.object);
-  return variable !== null && namespaceBindings.has(variable);
+  if (variable === null || !namespaceBindings.has(variable)) return null;
+  return sharedBindings.has(variable) ? "shared" : "snapshot";
 }
 
 // src/rules/prefer-node-fs-promises.ts
@@ -26103,6 +26182,7 @@ var require_static_next_matcher_default = createRule({
 
 // src/rules/require-use-form-default-values.ts
 var import_utils139 = require("@typescript-eslint/utils");
+var UNSAFE_FORM_MEMBERS = /* @__PURE__ */ new Set(["__defineGetter__", "__defineSetter__", "__proto__", "valueOf"]);
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "Require explicit form-level initialization or a field default for directly bound Controller fields.",
   rationale: "React Hook Form exposes form-level defaultValues/values and field-level defaultValue as its explicit initialization mechanisms. A directly bound controlled field should not omit both mechanisms.",
@@ -26110,7 +26190,8 @@ var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   category: "correctness",
   limitations: [
     "The rule proves only that an explicit form-level initialization option or field default is present; it does not prove that a particular field path occurs inside a defaultValues/values object.",
-    "The rule reports only scope-resolved Controller/useController fields explicitly bound to a directly created useForm control. FormProvider context, wrapper hooks, dynamic options, spreads, computed properties, and interprocedural flows are intentionally left unreported."
+    "The rule reports only scope-resolved Controller/useController fields explicitly bound to a directly created useForm control. FormProvider context, wrapper hooks, dynamic options, spreads, computed properties, and interprocedural flows are intentionally left unreported.",
+    "Form bindings must have one initializer and remain local and read-only; aliases, exports, property writes, and other escaping uses are left unreported."
   ],
   examples: [
     {
@@ -26139,6 +26220,29 @@ function staticPropertyName2(property) {
   if (property.key.type === import_utils139.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
   return null;
 }
+function readonlyFormReference(reference) {
+  if (typeOnlyReference2(reference)) return true;
+  const receiver = outerExpression(reference.identifier);
+  const parent = receiver.parent;
+  if (parent?.type === import_utils139.AST_NODE_TYPES.VariableDeclarator && parent.init === receiver) return parent.id.type === import_utils139.AST_NODE_TYPES.ObjectPattern;
+  if (parent?.type !== import_utils139.AST_NODE_TYPES.MemberExpression || parent.object !== receiver) {
+    return parent?.type === import_utils139.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof";
+  }
+  const name = import_utils139.ASTUtils.getPropertyName(parent);
+  return name !== null && !UNSAFE_FORM_MEMBERS.has(name) && !memberWrite(parent);
+}
+function memberWrite(node) {
+  let current = outerExpression(node);
+  let parent = current.parent;
+  while (parent?.type === import_utils139.AST_NODE_TYPES.Property && parent.value === current || parent?.type === import_utils139.AST_NODE_TYPES.ObjectPattern || parent?.type === import_utils139.AST_NODE_TYPES.ArrayPattern || parent?.type === import_utils139.AST_NODE_TYPES.RestElement || parent?.type === import_utils139.AST_NODE_TYPES.AssignmentPattern && parent.left === current) {
+    current = parent;
+    parent = current.parent;
+  }
+  return parent?.type === import_utils139.AST_NODE_TYPES.AssignmentExpression && parent.left === current || parent?.type === import_utils139.AST_NODE_TYPES.UpdateExpression && parent.argument === current || parent?.type === import_utils139.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete" || (parent?.type === import_utils139.AST_NODE_TYPES.ForOfStatement || parent?.type === import_utils139.AST_NODE_TYPES.ForInStatement) && parent.left === current;
+}
+function stableForm(variable) {
+  return !variable.defs.some((definition) => definition.type === "Variable" && definition.parent.parent.type === import_utils139.AST_NODE_TYPES.ExportNamedDeclaration) && stableValueBinding(variable, readonlyFormReference);
+}
 var require_use_form_default_values_default = createRule({
   name: "require-use-form-default-values",
   documentation: REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION,
@@ -26150,19 +26254,15 @@ var require_use_form_default_values_default = createRule({
   },
   defaultOptions: [],
   create(context) {
+    if (!context.sourceCode.ast.body.some((statement) => statement.type === import_utils139.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "react-hook-form")) return {};
     const imported = /* @__PURE__ */ new Map();
     const uninitializedForms = /* @__PURE__ */ new Set();
     const uninitializedControls = /* @__PURE__ */ new Set();
     const bindingNamed = (node, name) => import_utils139.ASTUtils.findVariable(context.sourceCode.getScope(node), name);
     const bindingOf = (node) => bindingNamed(node, node.name);
-    const stable = (variable) => !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
     const importedKind = (node) => {
-      const variable = bindingOf(node);
-      return variable !== null && stable(variable) ? imported.get(variable) ?? null : null;
-    };
-    const importedJsxKind = (node) => {
       const variable = bindingNamed(node, node.name);
-      return variable !== null && stable(variable) ? imported.get(variable) ?? null : null;
+      return variable === null ? null : imported.get(variable) ?? null;
     };
     const isDefinitelyUndefined = (node) => {
       const value = unwrapExpression(node);
@@ -26191,13 +26291,13 @@ var require_use_form_default_values_default = createRule({
       node = unwrapExpression(node);
       if (node.type !== import_utils139.AST_NODE_TYPES.Identifier) return false;
       const variable = bindingOf(node);
-      return variable !== null && stable(variable) && uninitializedForms.has(variable);
+      return variable !== null && uninitializedForms.has(variable);
     };
     const isUninitializedControl = (node) => {
       node = unwrapExpression(node);
       if (node.type === import_utils139.AST_NODE_TYPES.Identifier) {
         const variable = bindingOf(node);
-        return variable !== null && stable(variable) && uninitializedControls.has(variable);
+        return variable !== null && uninitializedControls.has(variable);
       }
       return node.type === import_utils139.AST_NODE_TYPES.MemberExpression && import_utils139.ASTUtils.getPropertyName(node) !== null && (import_utils139.ASTUtils.getPropertyName(node) ?? "") === "control" && isUninitializedForm(node.object);
     };
@@ -26226,7 +26326,7 @@ var require_use_form_default_values_default = createRule({
       for (const property of pattern.properties) {
         if (property.type !== import_utils139.AST_NODE_TYPES.Property || staticPropertyName2(property) !== "control" || property.value.type !== import_utils139.AST_NODE_TYPES.Identifier) continue;
         const variable = bindingOf(property.value);
-        if (variable !== null) uninitializedControls.add(variable);
+        if (variable !== null && stableValueBinding(variable)) uninitializedControls.add(variable);
       }
     };
     return {
@@ -26237,7 +26337,7 @@ var require_use_form_default_values_default = createRule({
           const name = specifier.imported.type === import_utils139.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
           if (name !== "Controller" && name !== "useController" && name !== "useForm") continue;
           const variable = bindingOf(specifier.local);
-          if (variable !== null) imported.set(variable, name);
+          if (variable !== null && stableValueBinding(variable)) imported.set(variable, name);
         }
       },
       VariableDeclarator(node) {
@@ -26245,7 +26345,7 @@ var require_use_form_default_values_default = createRule({
         if (uninitializedUseFormCall(node.init)) {
           if (node.id.type === import_utils139.AST_NODE_TYPES.Identifier) {
             const variable = bindingOf(node.id);
-            if (variable !== null) uninitializedForms.add(variable);
+            if (variable !== null && stableForm(variable)) uninitializedForms.add(variable);
           } else if (node.id.type === import_utils139.AST_NODE_TYPES.ObjectPattern) {
             trackDestructuredControl(node.id);
           }
@@ -26257,7 +26357,7 @@ var require_use_form_default_values_default = createRule({
         }
         if (node.id.type === import_utils139.AST_NODE_TYPES.Identifier && node.init.type === import_utils139.AST_NODE_TYPES.MemberExpression && import_utils139.ASTUtils.getPropertyName(node.init) !== null && (import_utils139.ASTUtils.getPropertyName(node.init) ?? "") === "control" && isUninitializedForm(node.init.object)) {
           const variable = bindingOf(node.id);
-          if (variable !== null) uninitializedControls.add(variable);
+          if (variable !== null && stableValueBinding(variable)) uninitializedControls.add(variable);
         }
       },
       CallExpression(node) {
@@ -26266,7 +26366,7 @@ var require_use_form_default_values_default = createRule({
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       },
       JSXOpeningElement(node) {
-        if (node.name.type !== import_utils139.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.name.type !== import_utils139.AST_NODE_TYPES.JSXIdentifier || importedKind(node.name) !== "Controller") return;
         if (node.attributes.some((attribute) => attribute.type === import_utils139.AST_NODE_TYPES.JSXSpreadAttribute)) return;
         const control = jsxAttribute(node, "control");
         if (control?.value?.type !== import_utils139.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils139.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
@@ -27442,6 +27542,14 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
     defaultOptions: [],
     create(context) {
       if (!isTestFile(context) || isGeneratedFile(context, context.sourceCode.text)) return {};
+      const referenceStability = /* @__PURE__ */ new WeakMap();
+      const referenceStable = (variable) => {
+        const cached = referenceStability.get(variable);
+        if (cached !== void 0) return cached;
+        const stable = !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
+        referenceStability.set(variable, stable);
+        return stable;
+      };
       const scopes = [newScope()];
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
@@ -27459,7 +27567,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const visible = (kind, node) => {
         const name2 = bindingOf(node);
-        if (name2 === null || name2.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
+        if (name2 === null || !referenceStable(name2)) return false;
         for (let index = scopes.length - 1; index >= 0; index--) {
           const scope = scopes[index];
           if (scope.declared.has(name2)) return scope[kind].has(name2);
@@ -27468,7 +27576,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const visibleRawOrigins = (node) => {
         const name2 = bindingOf(node);
-        if (name2 === null || name2.references.some((reference) => reference.isWrite() && reference.init !== true)) return /* @__PURE__ */ new Set();
+        if (name2 === null || !referenceStable(name2)) return /* @__PURE__ */ new Set();
         for (let index = scopes.length - 1; index >= 0; index--) {
           const scope = scopes[index];
           if (scope.declared.has(name2)) return scope.rawOrigins.get(name2) ?? /* @__PURE__ */ new Set();
@@ -27500,7 +27608,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const nativeImportedName = (node, modules) => {
         const binding = bindingOf(node);
-        if (binding === null || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return null;
+        if (binding === null || !referenceStable(binding)) return null;
         for (const definition of binding.defs) {
           const imported = definition.node;
           if (imported.type === import_utils144.AST_NODE_TYPES.ImportSpecifier && imported.imported.type === import_utils144.AST_NODE_TYPES.Identifier && imported.parent.type === import_utils144.AST_NODE_TYPES.ImportDeclaration && modules.has(String(imported.parent.source.value))) {
@@ -27511,7 +27619,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const stableInitializer = (node) => {
         const binding = bindingOf(node);
-        if (binding === null || binding.references.some((reference) => reference.isWrite() && reference.init !== true) || binding.defs.length !== 1) return null;
+        if (binding === null || !referenceStable(binding) || binding.defs.length !== 1) return null;
         const definition = binding.defs[0]?.node;
         return definition?.type === import_utils144.AST_NODE_TYPES.VariableDeclarator ? definition.init : null;
       };