@sarj/eslint-plugin 16.26.0 → 16.26.1

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.1",
   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) => {
@@ -20789,6 +20797,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 +20812,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 +20881,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 +20967,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 +20988,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 +26172,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 +26180,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 +26210,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 +26244,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 +26281,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 +26316,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 +26327,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 +26335,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 +26347,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 +26356,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;