@sarj/eslint-plugin 16.4.8 → 16.5.1

package/dist/index.cjs

@@ -52,7 +52,7 @@ module.exports = __toCommonJS(src_exports);
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.4.8",
+  version: "16.5.1",
   packageManager: "npm@12.1.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -2017,13 +2017,21 @@ function attributeText(node, name) {
   }
   return attribute.value === null ? "" : staticText(attribute.value);
 }
-function isHidden(node) {
+function isHidden(node, source) {
   if (attributeText(node, "aria-hidden") === "true") return true;
   const hidden = node.attributes.findLast(
     (attribute) => attribute.type === import_utils11.AST_NODE_TYPES.JSXSpreadAttribute || attribute.name.type === import_utils11.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "hidden"
   );
   if (hidden?.type !== import_utils11.AST_NODE_TYPES.JSXAttribute) return false;
   if (hidden.value === null) return true;
+  if (hidden.value.type === import_utils11.AST_NODE_TYPES.JSXExpressionContainer) {
+    const value = hidden.value.expression;
+    if (value.type === import_utils11.AST_NODE_TYPES.Identifier && value.name === "undefined") {
+      const binding = import_utils11.ASTUtils.findVariable(source.getScope(value), value.name);
+      if (binding === null || binding.defs.length === 0) return false;
+    }
+    if (value.type === import_utils11.AST_NODE_TYPES.UnaryExpression && value.operator === "void" && value.argument.type === import_utils11.AST_NODE_TYPES.Literal && value.argument.value === 0) return false;
+  }
   if (hidden.value.type === import_utils11.AST_NODE_TYPES.JSXExpressionContainer && hidden.value.expression.type === import_utils11.AST_NODE_TYPES.Literal)
     return hidden.value.expression.value !== false && hidden.value.expression.value !== null;
   return true;
@@ -2054,7 +2062,7 @@ function childrenNameStatus(children, source, iconModules) {
       return childrenNameStatus(child.children, source, iconModules);
     if (child.type !== import_utils11.AST_NODE_TYPES.JSXElement) return "unknown";
     const opening = child.openingElement;
-    if (isHidden(opening)) return "empty";
+    if (isHidden(opening, source)) return "empty";
     const imported = importedComponent(opening.name, source);
     const intrinsic = opening.name.type === import_utils11.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(opening.name.name);
     if (!intrinsic && (imported === null || !iconModules.includes(imported.module)))
@@ -2080,7 +2088,7 @@ function isPassedAsProp(node, source) {
 }
 function hasHiddenAncestor(node, source) {
   return source.getAncestors(node).some(
-    (ancestor) => ancestor.type === import_utils11.AST_NODE_TYPES.JSXElement && isHidden(ancestor.openingElement)
+    (ancestor) => ancestor.type === import_utils11.AST_NODE_TYPES.JSXElement && isHidden(ancestor.openingElement, source)
   );
 }
 function textNameStatus(text) {
@@ -2096,7 +2104,8 @@ var REQUIRE_BUTTON_ACCESSIBLE_NAME_DOCUMENTATION = {
   category: "correctness",
   limitations: [
     "Native button and conventional Button elements are checked by default. Other custom buttons require exact module/export configuration; aliases and namespace imports are resolved by scope. Lucide icons are recognized by default; other icon modules are configurable.",
-    "Composed JSX passed as props, render/asChild adapters, dynamic labels, children, unknown components, and prop spreads are left to runtime accessibility testing. Referenced IDs, CSS visibility, and meaningful wording are not verified. Generated files, tests, fixtures, and stories are excluded. No automatic labels are invented."
+    "Composed JSX passed as props, render/asChild adapters, dynamic labels, children, unknown components, and prop spreads are left to runtime accessibility testing. Referenced IDs, CSS visibility, and meaningful wording are not verified. Generated files, tests, fixtures, and stories are excluded. No automatic labels are invented.",
+    "A hidden prop with unshadowed undefined or exact void 0 does not hide the element or its children. Shadowed undefined and dynamic hidden values remain unproven."
   ],
   examples: [
     {
@@ -2174,7 +2183,7 @@ var require_button_accessible_name_default = createRule({
           return;
         if (isPassedAsProp(node, context.sourceCode) || hasHiddenAncestor(node, context.sourceCode))
           return;
-        if (isHidden(opening) || attributeNameStatus(opening) !== "empty")
+        if (isHidden(opening, context.sourceCode) || attributeNameStatus(opening) !== "empty")
           return;
         if (childrenNameStatus(node.children, context.sourceCode, iconModules) !== "empty")
           return;
@@ -2270,7 +2279,8 @@ var REQUIRE_SVG_ACCESSIBLE_NAME_DOCUMENTATION = {
   remediation: "Add aria-label, aria-labelledby, or a direct title child; mark decorative graphics aria-hidden or presentational.",
   category: "correctness",
   limitations: [
-    "Only intrinsic svg elements are checked. Dynamic labels, forwarded props, and dynamic title content remain runtime concerns. IDs, CSS visibility and graphic meaning are not inferred. Tests, stories, fixtures and generated files are excluded. No automatic title or decorative marker is invented."
+    "Only intrinsic svg elements are checked. Dynamic labels, forwarded props, and dynamic title content remain runtime concerns. IDs, CSS visibility and graphic meaning are not inferred. Tests, stories, fixtures and generated files are excluded. No automatic title or decorative marker is invented.",
+    "A hidden prop with unshadowed undefined or exact void 0 does not hide the element. Shadowed undefined and dynamic hidden values remain unproven."
   ],
   examples: [
     {
@@ -2320,7 +2330,7 @@ var require_svg_accessible_name_default = createRule({
           return;
         if (isPassedAsProp(node, context.sourceCode) || hasHiddenAncestor(node, context.sourceCode))
           return;
-        if (isHidden(opening) || ["none", "presentation"].includes(
+        if (isHidden(opening, context.sourceCode) || ["none", "presentation"].includes(
           attributeText(opening, "role") ?? ""
         ))
           return;
@@ -6987,7 +6997,7 @@ var NO_JSON_STRINGIFY_ERROR_DOCUMENTATION = {
   rationale: "Native Error details are non-enumerable, so generic JSON serialization discards diagnostic information.",
   remediation: "Serialize explicit error fields or use an error-aware serializer.",
   category: "correctness",
-  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Custom replacers and explicit toJSON hooks are left to their serializer contract; a catch value is not guaranteed to be an Error. Member values, including cause, do not inherit the base Error's provenance; even an Error-valued member requires explicit value/dataflow proof outside this rule. Known literal __proto__ initializer chains preserve native hook inheritance and own toJSON precedence; computed __proto__ keys remain data. Unknown prototype expressions, hook values/spreads and deferred hook writes conservatively lose default serializer proof. Explicit writes invalidate constructor provenance except a later, separate top-level statement; deferred functions, loops, and unknown property keys conservatively lose constructor proof. Statically owned global/property writes and native Reflect.set/Reflect.defineProperty/Object.defineProperty/Object.defineProperties calls are tracked. Mutator aliases, replaced Reflect/Object methods, external calls, and runtime-only property names are not resolved; uncertain ordering conservatively loses proof."],
+  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Native DOMException constructor coverage is validated in Node; browser serialization is not evaluated. Custom replacers and explicit toJSON hooks are left to their serializer contract; a catch value is not guaranteed to be an Error. Member values, including cause, do not inherit the base Error's provenance; even an Error-valued member requires explicit value/dataflow proof outside this rule. Known literal __proto__ initializer chains preserve native hook inheritance and own toJSON precedence; computed __proto__ keys remain data. Unknown prototype expressions, hook values/spreads and deferred hook writes conservatively lose default serializer proof. Explicit writes invalidate constructor provenance except a later, separate top-level statement; deferred functions, loops, and unknown property keys conservatively lose constructor proof. Statically owned global/property writes and native Reflect.set/Reflect.defineProperty/Object.defineProperty/Object.defineProperties calls are tracked. Mutator aliases, replaced Reflect/Object methods, external calls, and runtime-only property names are not resolved; uncertain ordering conservatively loses proof."],
   examples: [
     { id: "explicit-error-message", title: "Narrow an unknown catch value before selecting fields", outcome: "no-match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err instanceof Error ? err.message : String(err) }); }" }], focusPath: "src/report.ts", expectedCount: 0, public: true },
     { id: "stringified-error", title: "Do not stringify an Error object", outcome: "match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err }); }" }], focusPath: "src/report.ts", expectedCount: 1, public: true },
@@ -7009,6 +7019,7 @@ var NO_JSON_STRINGIFY_ERROR_DOCUMENTATION = {
 };
 var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "AggregateError",
+  "DOMException",
   "Error",
   "EvalError",
   "RangeError",
@@ -11852,7 +11863,7 @@ var NO_SILENT_PROMISE_CATCH_DOCUMENTATION = {
   rationale: "A swallowed rejection hides failures and gives callers an indistinguishable fallback value.",
   remediation: "Log, rethrow, or explicitly recover from the rejection; explain intentional teardown suppression.",
   category: "correctness",
-  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded. Other untyped catch-like APIs are not proven to be Promises.", "Computed methods resolve literal syntax and stable local string aliases in lexical scope. Function-derived, object-derived and mutated computed keys remain unproven."],
+  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded, including URL schemas and primitive bigint, boolean, number and string coercion. Other untyped catch-like APIs are not proven to be Promises.", "Computed methods resolve literal syntax and stable local string aliases in lexical scope. Function-derived, object-derived and mutated computed keys remain unproven."],
   examples: [
     { id: "reported-rejection", title: "Report the rejection", outcome: "no-match", files: [{ path: "src/load.ts", source: "load().catch((error) => logger.error({ error }, 'load failed'));" }], focusPath: "src/load.ts", expectedCount: 0, public: true },
     { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true },
@@ -11888,7 +11899,8 @@ var ZOD_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "tuple",
   "undefined",
   "union",
-  "unknown"
+  "unknown",
+  "url"
 ]);
 var ZOD_CHAIN_METHODS = /* @__PURE__ */ new Set([
   "array",
@@ -11996,8 +12008,9 @@ var no_silent_promise_catch_default = createRule({
         return binding.defs.length === 1 && definition?.node.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && definition.node.init !== null && isZodSchema(definition.node.init, seen);
       }
       if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
-      const { object } = unwrappedNodeCallee;
+      let { object } = unwrappedNodeCallee;
       const method = staticPropertyName(unwrappedNodeCallee, context.sourceCode);
+      if (object.type === import_utils68.AST_NODE_TYPES.MemberExpression && staticPropertyName(object, context.sourceCode) === "coerce" && method !== null && ["bigint", "boolean", "number", "string"].includes(method)) object = object.object;
       if (object.type === import_utils68.AST_NODE_TYPES.Identifier && method !== null && ZOD_CONSTRUCTORS.has(method)) {
         const binding = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
         if (binding?.defs.some((definition) => {
@@ -21360,8 +21373,112 @@ function staticFieldName(key) {
   return key.type === import_utils115.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils115.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
 }
 
-// src/rules/prefer-zod-parse-output-type.ts
+// src/rules/named-child-schema-type.ts
 var import_utils116 = require("@typescript-eslint/utils");
+var UNRESOLVED_TYPE_NODES = /* @__PURE__ */ new Set([
+  import_utils116.AST_NODE_TYPES.TSTypeQuery,
+  import_utils116.AST_NODE_TYPES.TSImportType,
+  import_utils116.AST_NODE_TYPES.TSTypeParameter,
+  import_utils116.AST_NODE_TYPES.TSAnyKeyword,
+  import_utils116.AST_NODE_TYPES.TSUnknownKeyword
+]);
+var NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION = {
+  defaultLevel: "warning",
+  summary: "Reference a named Zod record child's complete schema type instead of repeating its explicit annotation.",
+  rationale: "Repeating a child schema's generic contract creates a second maintained declaration even though the record already uses that child at runtime.",
+  remediation: "Replace only the matching record type argument with `typeof ChildSchema`; retain the outer annotation required by isolatedDeclarations and every runtime schema operation.",
+  category: "maintainability",
+  autofix: "none",
+  limitations: [
+    "Only direct module-level const z.record calls with two arguments, a ZodRecord annotation, and an earlier local const child with a complete explicit Zod type are inspected.",
+    "The entire generic child annotation must match token for token; input/output, defaults, transforms, readonly modifiers and brands are never compared by output shape alone.",
+    "Bare leaf types, broad ZodType constraints, type queries, imported or unqualified type references, annotation cycles, comments on the repeated argument, mutable bindings and generated files are excluded.",
+    "Import aliases and namespace imports resolve through scope bindings. Independent public contract pins require review; this warning does not remove annotations or change runtime validation."
+  ],
+  examples: [
+    { id: "named-child", title: "Reference the named child contract", outcome: "no-match", files: [{ path: "src/record.ts", source: 'import { z } from "zod"; const KeySchema: z.ZodEnum<{ a: "a"; b: "b" }> = z.enum(["a", "b"]); export const RecordSchema: z.ZodRecord<typeof KeySchema, z.ZodString> = z.record(KeySchema, z.string());' }], focusPath: "src/record.ts", expectedCount: 0, public: true },
+    { id: "copied-child", title: "Do not repeat the complete child annotation", outcome: "match", files: [{ path: "src/record.ts", source: 'import { z } from "zod"; const KeySchema: z.ZodEnum<{ a: "a"; b: "b" }> = z.enum(["a", "b"]); export const RecordSchema: z.ZodRecord<z.ZodEnum<{ a: "a"; b: "b" }>, z.ZodString> = z.record(KeySchema, z.string());' }], focusPath: "src/record.ts", expectedCount: 1, public: true }
+  ]
+};
+function isModuleConst(node) {
+  if (node.parent.kind !== "const" || node.id.type !== import_utils116.AST_NODE_TYPES.Identifier) return false;
+  const parent = node.parent.parent;
+  return parent.type === import_utils116.AST_NODE_TYPES.Program || parent.type === import_utils116.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent.type === import_utils116.AST_NODE_TYPES.Program;
+}
+var named_child_schema_type_default = createRule({
+  name: "named-child-schema-type",
+  documentation: NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION.summary },
+    schema: [],
+    messages: { namedChildType: "Use `typeof {{name}}` for this exact child contract; keep the outer schema annotation and runtime operations." }
+  },
+  defaultOptions: [],
+  create(context) {
+    const source = context.sourceCode;
+    if (isGeneratedFile(context.filename, source.text)) return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    const bindingOf = (node) => import_utils116.ASTUtils.findVariable(source.getScope(node), node.name);
+    function namespaceOf(type) {
+      if (type.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || type.typeName.left.type !== import_utils116.AST_NODE_TYPES.Identifier) return null;
+      const binding = bindingOf(type.typeName.left);
+      return binding !== null && namespaces.has(binding) ? binding : null;
+    }
+    function closedType(node, namespace) {
+      if (UNRESOLVED_TYPE_NODES.has(node.type)) return false;
+      if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && namespaceOf(node) !== namespace) return false;
+      return !forEachOwnAstChild(node, (child) => !closedType(child, namespace));
+    }
+    function inspectChild(argument, repeated, namespace, parent) {
+      if (argument.type !== import_utils116.AST_NODE_TYPES.Identifier || repeated.type !== import_utils116.AST_NODE_TYPES.TSTypeReference || repeated.typeArguments === void 0) return;
+      if (repeated.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || /^(?:ZodType|ZodSchema|ZodTypeAny)$/u.test(repeated.typeName.right.name)) return;
+      const variable = bindingOf(argument);
+      const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
+      if (definition?.type !== "Variable" || !isModuleConst(definition.node)) return;
+      const child = definition.node;
+      if (child.id.type !== import_utils116.AST_NODE_TYPES.Identifier || child.init === null || child.range[0] >= parent.range[0]) return;
+      const annotation = child.id.typeAnnotation?.typeAnnotation;
+      if (annotation === void 0 || factoryNamespace(child.init) !== namespace || !closedType(annotation, namespace)) return;
+      if (source.getCommentsInside(repeated).length > 0 || source.getCommentsBefore(repeated).length > 0) return;
+      const expected = source.getTokens(annotation);
+      const actual = source.getTokens(repeated);
+      if (expected.length !== actual.length || expected.some((token, index) => token.type !== actual[index]?.type || token.value !== actual[index]?.value)) return;
+      context.report({ node: repeated, messageId: "namedChildType", data: { name: argument.name } });
+    }
+    function factoryNamespace(expression) {
+      if (expression.type !== import_utils116.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression) return null;
+      const object = expression.callee.object;
+      return object.type === import_utils116.AST_NODE_TYPES.Identifier ? bindingOf(object) : factoryNamespace(object);
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type" || !isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== import_utils116.AST_NODE_TYPES.ImportNamespaceSpecifier && (specifier.type !== import_utils116.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || importSpecifierName(specifier) !== "z")) continue;
+          const binding = bindingOf(specifier.local);
+          if (binding !== null) namespaces.add(binding);
+        }
+      },
+      VariableDeclarator(node) {
+        if (!isModuleConst(node) || node.id.type !== import_utils116.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils116.AST_NODE_TYPES.CallExpression) return;
+        const call = node.init;
+        if (call.arguments.length !== 2 || call.callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || call.callee.object.type !== import_utils116.AST_NODE_TYPES.Identifier || import_utils116.ASTUtils.getPropertyName(call.callee) !== "record") return;
+        const annotation = node.id.typeAnnotation?.typeAnnotation;
+        if (annotation?.type !== import_utils116.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || annotation.typeName.right.name !== "ZodRecord") return;
+        const namespace = namespaceOf(annotation);
+        if (namespace === null || bindingOf(call.callee.object) !== namespace || annotation.typeArguments?.params.length !== 2) return;
+        for (const [index, argument] of call.arguments.entries()) {
+          const repeated = annotation.typeArguments.params[index];
+          if (repeated !== void 0) inspectChild(argument, repeated, namespace, node);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-zod-parse-output-type.ts
+var import_utils117 = require("@typescript-eslint/utils");
 var import_typescript7 = __toESM(require("typescript"), 1);
 var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
   summary: "Derive a function's return contract from the local Zod schema whose parsed output it returns.",
@@ -21417,22 +21534,22 @@ var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
 };
 function isModuleLevelConst2(node) {
   const declaration = node.parent;
-  if (declaration.type !== import_utils116.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== import_utils117.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === import_utils116.AST_NODE_TYPES.Program || container.type === import_utils116.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils116.AST_NODE_TYPES.Program;
+  return container.type === import_utils117.AST_NODE_TYPES.Program || container.type === import_utils117.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils117.AST_NODE_TYPES.Program;
 }
 function isLocalZodObjectSchema(node, namespaces) {
   let current = node;
-  while (current.type === import_utils116.AST_NODE_TYPES.CallExpression) {
+  while (current.type === import_utils117.AST_NODE_TYPES.CallExpression) {
     const callee = unwrapExpression(current.callee);
-    const calleeReceiver = callee.type === import_utils116.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-    if (callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || import_utils116.ASTUtils.getPropertyName(callee) === null) {
+    const calleeReceiver = callee.type === import_utils117.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+    if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || import_utils117.ASTUtils.getPropertyName(callee) === null) {
       return false;
     }
-    if (calleeReceiver.type === import_utils116.AST_NODE_TYPES.Identifier) {
-      return namespaces.has(calleeReceiver.name) && ((import_utils116.ASTUtils.getPropertyName(callee) ?? "") === "object" || (import_utils116.ASTUtils.getPropertyName(callee) ?? "") === "strictObject");
+    if (calleeReceiver.type === import_utils117.AST_NODE_TYPES.Identifier) {
+      return namespaces.has(calleeReceiver.name) && ((import_utils117.ASTUtils.getPropertyName(callee) ?? "") === "object" || (import_utils117.ASTUtils.getPropertyName(callee) ?? "") === "strictObject");
     }
     current = calleeReceiver;
   }
@@ -21440,11 +21557,11 @@ function isLocalZodObjectSchema(node, namespaces) {
 }
 function zodParseCall(node) {
   const callee = unwrapExpression(node.callee);
-  const calleeReceiver = callee.type === import_utils116.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-  if (callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || calleeReceiver.type !== import_utils116.AST_NODE_TYPES.Identifier || import_utils116.ASTUtils.getPropertyName(callee) === null) {
+  const calleeReceiver = callee.type === import_utils117.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+  if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || calleeReceiver.type !== import_utils117.AST_NODE_TYPES.Identifier || import_utils117.ASTUtils.getPropertyName(callee) === null) {
     return null;
   }
-  const method = import_utils116.ASTUtils.getPropertyName(callee);
+  const method = import_utils117.ASTUtils.getPropertyName(callee);
   if (method !== "parse" && method !== "safeParse") return null;
   return {
     call: node,
@@ -21458,7 +21575,7 @@ function returnedOutputCandidate(parsed, output) {
   const annotation = owner?.returnType?.typeAnnotation;
   if (annotation === void 0) return null;
   const typeReference = returnContractReference(annotation);
-  if (typeReference === null || typeReference.typeName.type !== import_utils116.AST_NODE_TYPES.Identifier) {
+  if (typeReference === null || typeReference.typeName.type !== import_utils117.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return {
@@ -21475,7 +21592,7 @@ function directParseReturnCandidate(node) {
   return parsed?.method === "parse" ? returnedOutputCandidate(parsed, node) : null;
 }
 function localParseReturnCandidates(node, sourceCode) {
-  if (node.id.type !== import_utils116.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils116.AST_NODE_TYPES.CallExpression || node.parent.type !== import_utils116.AST_NODE_TYPES.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
+  if (node.id.type !== import_utils117.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils117.AST_NODE_TYPES.CallExpression || node.parent.type !== import_utils117.AST_NODE_TYPES.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
     return [];
   }
   const parsed = zodParseCall(node.init);
@@ -21486,7 +21603,7 @@ function localParseReturnCandidates(node, sourceCode) {
   for (const reference of variable.references) {
     const identifier = reference.identifier;
     const parent = identifier.parent;
-    const output = parsed.method === "parse" ? identifier : parent.type === import_utils116.AST_NODE_TYPES.MemberExpression && parent.object === identifier && import_utils116.ASTUtils.getPropertyName(parent) !== null && (import_utils116.ASTUtils.getPropertyName(parent) ?? "") === "data" ? parent : null;
+    const output = parsed.method === "parse" ? identifier : parent.type === import_utils117.AST_NODE_TYPES.MemberExpression && parent.object === identifier && import_utils117.ASTUtils.getPropertyName(parent) !== null && (import_utils117.ASTUtils.getPropertyName(parent) ?? "") === "data" ? parent : null;
     if (output === null) continue;
     const candidate2 = returnedOutputCandidate(parsed, output);
     if (candidate2 !== null) candidates.push(candidate2);
@@ -21497,17 +21614,17 @@ function directReturnOwner(node) {
   let current = node;
   while (current.parent !== void 0) {
     const parent = current.parent;
-    if (parent.type === import_utils116.AST_NODE_TYPES.ReturnStatement) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ReturnStatement) {
       return parent.argument === current ? enclosingFunction4(parent) : null;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.ArrowFunctionExpression && parent.expression && parent.body === current) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression && parent.expression && parent.body === current) {
       return parent;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.AwaitExpression && parent.argument === current) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.AwaitExpression && parent.argument === current) {
       current = parent;
       continue;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.ConditionalExpression) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
       const parsedWhenTrue = parent.consequent === current && isNullishExpression(parent.alternate);
       const parsedWhenFalse = parent.alternate === current && isNullishExpression(parent.consequent);
       if (parsedWhenTrue || parsedWhenFalse) {
@@ -21520,12 +21637,12 @@ function directReturnOwner(node) {
   return null;
 }
 function isNullishExpression(node) {
-  return node.type === import_utils116.AST_NODE_TYPES.Literal && node.value === null || node.type === import_utils116.AST_NODE_TYPES.Identifier && node.name === "undefined";
+  return node.type === import_utils117.AST_NODE_TYPES.Literal && node.value === null || node.type === import_utils117.AST_NODE_TYPES.Identifier && node.name === "undefined";
 }
 function enclosingFunction4(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils116.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils116.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils116.AST_NODE_TYPES.FunctionExpression) {
+    if (current.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils117.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils117.AST_NODE_TYPES.FunctionExpression) {
       return current;
     }
     current = current.parent;
@@ -21533,45 +21650,45 @@ function enclosingFunction4(node) {
   return null;
 }
 function returnContractReference(node) {
-  if (node.type === import_utils116.AST_NODE_TYPES.TSUnionType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSUnionType) {
     const substantive = node.types.filter(
-      (member) => member.type !== import_utils116.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils116.AST_NODE_TYPES.TSUndefinedKeyword
+      (member) => member.type !== import_utils117.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils117.AST_NODE_TYPES.TSUndefinedKeyword
     );
     const [only] = substantive;
     return substantive.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier && node.typeName.name === "Promise") {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier && node.typeName.name === "Promise") {
     const parameters = node.typeArguments?.params ?? [];
     const [only] = parameters;
     return parameters.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  return node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
+  return node.type === import_utils117.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
 }
 function recordZodNamespaces(node, namespaces) {
   for (const statement of node.body) {
-    if (statement.type !== import_utils116.AST_NODE_TYPES.ImportDeclaration || !isZodModule(statement.source.value)) {
+    if (statement.type !== import_utils117.AST_NODE_TYPES.ImportDeclaration || !isZodModule(statement.source.value)) {
       continue;
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.type === import_utils116.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils116.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils116.AST_NODE_TYPES.ImportSpecifier && importSpecifierName(specifier) === "z") {
+      if (specifier.type === import_utils117.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils117.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils117.AST_NODE_TYPES.ImportSpecifier && importSpecifierName(specifier) === "z") {
         namespaces.add(specifier.local.name);
       }
     }
   }
 }
 function collectConstrainedNames(node, names) {
-  if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference) {
-    if (node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier) names.add(node.typeName.name);
+  if (node.type === import_utils117.AST_NODE_TYPES.TSTypeReference) {
+    if (node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier) names.add(node.typeName.name);
     for (const argument of node.typeArguments?.params ?? []) {
       collectConstrainedNames(argument, names);
     }
     return;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSArrayType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSArrayType) {
     collectConstrainedNames(node.elementType, names);
     return;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSUnionType || node.type === import_utils116.AST_NODE_TYPES.TSIntersectionType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSUnionType || node.type === import_utils117.AST_NODE_TYPES.TSIntersectionType) {
     for (const member of node.types) collectConstrainedNames(member, names);
   }
 }
@@ -21605,7 +21722,7 @@ function reportCandidates(context, services, schemas, candidates, zodNamespaces,
     if (constrained) return;
     if (declaration.getSourceFile() === tsSchema.getSourceFile()) {
       const estreeDeclaration = services.tsNodeToESTreeNodeMap.get(declaration);
-      if ((estreeDeclaration.type === import_utils116.AST_NODE_TYPES.TSInterfaceDeclaration || estreeDeclaration.type === import_utils116.AST_NODE_TYPES.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
+      if ((estreeDeclaration.type === import_utils117.AST_NODE_TYPES.TSInterfaceDeclaration || estreeDeclaration.type === import_utils117.AST_NODE_TYPES.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
         constrained,
         declaration: estreeDeclaration,
         initializer: schema.initializer,
@@ -21695,7 +21812,7 @@ var prefer_zod_parse_output_type_default = createRule({
     }
     let services;
     try {
-      services = import_utils116.ESLintUtils.getParserServices(context);
+      services = import_utils117.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -21710,7 +21827,7 @@ var prefer_zod_parse_output_type_default = createRule({
         recordZodNamespaces(node, namespaces);
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils116.AST_NODE_TYPES.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
+        if (node.id.type === import_utils117.AST_NODE_TYPES.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
           schemas.push({ identifier: node.id, initializer: node.init, name: node.id.name });
         }
         candidates.push(...localParseReturnCandidates(node, context.sourceCode));
@@ -21720,13 +21837,13 @@ var prefer_zod_parse_output_type_default = createRule({
         if (candidate2 !== null) candidates.push(candidate2);
       },
       "MemberExpression"(node) {
-        if (node.object.type === import_utils116.AST_NODE_TYPES.Identifier && node.property.type === import_utils116.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+        if (node.object.type === import_utils117.AST_NODE_TYPES.Identifier && node.property.type === import_utils117.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemas.add(node.object.name);
         }
       },
       TSTypeReference(node) {
         const { typeName } = node;
-        const name = typeName.type === import_utils116.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils116.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils116.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const name = typeName.type === import_utils117.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils117.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils117.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (name === null || !isPreferZodInferTypeConstraintName(name)) return;
         for (const argument of node.typeArguments?.params ?? []) {
           collectConstrainedNames(argument, constrainedTypeNames);
@@ -21748,7 +21865,7 @@ var prefer_zod_parse_output_type_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils117 = require("@typescript-eslint/utils");
+var import_utils118 = require("@typescript-eslint/utils");
 var import_typescript8 = __toESM(require("typescript"), 1);
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
@@ -21762,14 +21879,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils117.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils117.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils118.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils117.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils117.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils118.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils117.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -21785,7 +21902,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils117.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils118.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -21839,7 +21956,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils117.ESLintUtils.getParserServices(context);
+      services = import_utils118.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -21866,7 +21983,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils118 = require("@typescript-eslint/utils");
+var import_utils119 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an explicit abort signal on locally analyzable global fetch calls.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -21893,18 +22010,18 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init, resolvesToGlobal) {
-  if (init.type !== import_utils118.AST_NODE_TYPES.ObjectExpression) return false;
+  if (init.type !== import_utils119.AST_NODE_TYPES.ObjectExpression) return false;
   let lacksSignal = true;
   for (const prop of init.properties) {
-    if (prop.type === import_utils118.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils119.AST_NODE_TYPES.SpreadElement) {
       lacksSignal = false;
       continue;
     }
-    const isSignal = !prop.computed && prop.key.type === import_utils118.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils118.AST_NODE_TYPES.Literal && prop.key.value === "signal";
+    const isSignal = !prop.computed && prop.key.type === import_utils119.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils119.AST_NODE_TYPES.Literal && prop.key.value === "signal";
     if (isSignal) {
       const value = prop.value;
-      lacksSignal = prop.kind === "init" && !prop.method && (value.type === import_utils118.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils118.AST_NODE_TYPES.Identifier && value.name === "undefined" && resolvesToGlobal(value) || value.type === import_utils118.AST_NODE_TYPES.UnaryExpression && value.operator === "void" && value.argument.type === import_utils118.AST_NODE_TYPES.Literal && value.argument.value === 0);
-    } else if (prop.computed && prop.key.type !== import_utils118.AST_NODE_TYPES.Literal) {
+      lacksSignal = prop.kind === "init" && !prop.method && (value.type === import_utils119.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils119.AST_NODE_TYPES.Identifier && value.name === "undefined" && resolvesToGlobal(value) || value.type === import_utils119.AST_NODE_TYPES.UnaryExpression && value.operator === "void" && value.argument.type === import_utils119.AST_NODE_TYPES.Literal && value.argument.value === 0);
+    } else if (prop.computed && prop.key.type !== import_utils119.AST_NODE_TYPES.Literal) {
       lacksSignal = false;
     }
   }
@@ -21912,7 +22029,7 @@ function initProvablyLacksSignal(init, resolvesToGlobal) {
 }
 function isInlineUrl(node, resolvesToGlobal) {
   node = unwrapExpression(node);
-  return node.type === import_utils118.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils118.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils118.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils118.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils119.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils119.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils119.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -21950,30 +22067,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils118.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils119.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils118.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils119.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils118.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils118.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils118.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils119.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils119.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils119.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils118.ASTUtils.findVariable(
+      const variable = import_utils119.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils118.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init, resolvesToGlobal)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils119.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init, resolvesToGlobal)) {
         return false;
       }
       for (const reference of variable.references) {
         const ref = reference.identifier;
         if (ref === identifier || ref === definition.name) continue;
         const member = ref.parent;
-        if (member.type !== import_utils118.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils118.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils118.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils119.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils119.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils119.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -21981,13 +22098,13 @@ var require_fetch_timeout_default = createRule({
     }
     function isForwardedRequest(argument) {
       let value = argument;
-      if (value.type === import_utils118.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils118.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
+      if (value.type === import_utils119.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
         const definition = binding?.defs.length === 1 ? binding.defs[0] : void 0;
         if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || binding?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         value = definition.node.init;
       }
-      return value.type === import_utils118.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils118.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
+      return value.type === import_utils119.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils119.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
     }
     return {
       CallExpression(node) {
@@ -21999,7 +22116,7 @@ var require_fetch_timeout_default = createRule({
         if (first !== void 0 && (node.arguments.length === 1 && !isInlineUrl(first, resolvesToGlobal) || isForwardedRequest(first))) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init, resolvesToGlobal) || init.type === import_utils118.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init, resolvesToGlobal) || init.type === import_utils119.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -22008,7 +22125,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-var import_utils119 = require("@typescript-eslint/utils");
+var import_utils120 = require("@typescript-eslint/utils");
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Require exported concrete classes with public behavior to declare a contract.",
@@ -22055,23 +22172,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === import_utils119.AST_NODE_TYPES.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils119.AST_NODE_TYPES.PrivateIdentifier;
+    if (member.type === import_utils120.AST_NODE_TYPES.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils120.AST_NODE_TYPES.PrivateIdentifier;
     }
-    if (member.type !== import_utils119.AST_NODE_TYPES.PropertyDefinition || member.static)
+    if (member.type !== import_utils120.AST_NODE_TYPES.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) return false;
-    return member.value?.type === import_utils119.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils119.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils119.AST_NODE_TYPES.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils120.AST_NODE_TYPES.PrivateIdentifier) return false;
+    return member.value?.type === import_utils120.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils120.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils120.AST_NODE_TYPES.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === import_utils119.AST_NODE_TYPES.ClassDeclaration) {
+  const declaration = statement.type === import_utils120.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === import_utils120.AST_NODE_TYPES.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration?.type !== import_utils120.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils119.AST_NODE_TYPES.Identifier && item.init?.type === import_utils119.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === import_utils120.AST_NODE_TYPES.Identifier && item.init?.type === import_utils120.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -22105,7 +22222,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = exportedClasses(program, classes);
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils119.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils120.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
           if (declaration.abstract || declaration.implements.length > 0 || extendsLocalAbstractBase || !hasPublicInstanceBehavior(declaration)) continue;
           context.report({
             node: declaration.id ?? declaration,
@@ -22120,7 +22237,7 @@ var require_interface_for_exported_class_default = createRule({
 function exportedClasses(program, classes) {
   const exported = /* @__PURE__ */ new Map();
   function collectExportedClass(statement) {
-    if (statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration) {
+    if (statement.type === import_utils120.AST_NODE_TYPES.ExportNamedDeclaration) {
       for (const binding of classBindings(statement)) {
         exported.set(binding.declaration, binding.name);
       }
@@ -22128,13 +22245,13 @@ function exportedClasses(program, classes) {
       collectClassSpecifiers(statement);
       return;
     }
-    if (statement.type !== import_utils119.AST_NODE_TYPES.ExportDefaultDeclaration) return;
-    if (statement.declaration.type === import_utils119.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils119.AST_NODE_TYPES.ClassExpression) {
+    if (statement.type !== import_utils120.AST_NODE_TYPES.ExportDefaultDeclaration) return;
+    if (statement.declaration.type === import_utils120.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils120.AST_NODE_TYPES.ClassExpression) {
       exported.set(
         statement.declaration,
         statement.declaration.id?.name ?? "default"
       );
-    } else if (statement.declaration.type === import_utils119.AST_NODE_TYPES.Identifier) {
+    } else if (statement.declaration.type === import_utils120.AST_NODE_TYPES.Identifier) {
       const candidate2 = classes.get(statement.declaration.name);
       if (candidate2 !== void 0) {
         exported.set(candidate2, statement.declaration.name);
@@ -22146,7 +22263,7 @@ function exportedClasses(program, classes) {
       if (specifier.exportKind === "type") continue;
       const candidate2 = classes.get(specifier.local.name);
       if (candidate2 === void 0) continue;
-      const exportedName = specifier.exported.type === import_utils119.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+      const exportedName = specifier.exported.type === import_utils120.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
       exported.set(candidate2, exportedName);
     }
   }
@@ -22157,7 +22274,7 @@ function exportedClasses(program, classes) {
 }
 
 // src/rules/require-sql-access-class.ts
-var import_utils120 = require("@typescript-eslint/utils");
+var import_utils121 = require("@typescript-eslint/utils");
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -22261,80 +22378,80 @@ function isDatabaseOperation(method, receiver) {
 }
 function databaseReceiver(node) {
   node = unwrapExpression(node);
-  if (node.type === import_utils120.AST_NODE_TYPES.Identifier)
+  if (node.type === import_utils121.AST_NODE_TYPES.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
-  const name = import_utils120.ASTUtils.getPropertyName(node);
+  if (node.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
+  const name = import_utils121.ASTUtils.getPropertyName(node);
   return name === "DB" || name !== null && DATABASE_NAMES.test(name);
 }
 function databaseRootMember(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return null;
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-      if (current.object.type === import_utils120.AST_NODE_TYPES.ThisExpression)
-        return import_utils120.ASTUtils.getPropertyName(current);
+    if (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+      if (current.object.type === import_utils121.AST_NODE_TYPES.ThisExpression)
+        return import_utils121.ASTUtils.getPropertyName(current);
       current = current.object;
       continue;
     }
-    return current.type === import_utils120.AST_NODE_TYPES.Identifier ? current.name : null;
+    return current.type === import_utils121.AST_NODE_TYPES.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-      const name = import_utils120.ASTUtils.getPropertyName(current);
+    if (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+      const name = import_utils121.ASTUtils.getPropertyName(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === import_utils120.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === import_utils121.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
-      const name = import_utils120.ASTUtils.getPropertyName(current.callee);
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
+      const name = import_utils121.ASTUtils.getPropertyName(current.callee);
       if (name !== null && BUILDER_METHODS.has(name)) return true;
       current = current.callee.object;
       continue;
     }
-    if (current.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils120.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils120.AST_NODE_TYPES.ClassExpression)
+    if (current.type === import_utils121.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils121.AST_NODE_TYPES.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -22343,25 +22460,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === import_utils120.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === import_utils121.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
   );
   if (constructor === void 0) return injected;
   const parameters = /* @__PURE__ */ new Set();
   for (const parameter of constructor.value.params) {
     for (const name of parameterNames(parameter)) parameters.add(name);
-    if (parameter.type !== import_utils120.AST_NODE_TYPES.TSParameterProperty) continue;
-    const value = parameter.parameter.type === import_utils120.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === import_utils120.AST_NODE_TYPES.Identifier) injected.add(value.name);
+    if (parameter.type !== import_utils121.AST_NODE_TYPES.TSParameterProperty) continue;
+    const value = parameter.parameter.type === import_utils121.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === import_utils121.AST_NODE_TYPES.Identifier) injected.add(value.name);
   }
   const body2 = constructor.value.body;
   if (body2 === null) return injected;
   function collectInjectedMember(statement) {
-    if (statement.type !== import_utils120.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils120.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") return;
+    if (statement.type !== import_utils121.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils121.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") return;
     const { left, right } = statement.expression;
-    if (left.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return;
+    if (left.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return;
     const target = thisRootMember(left);
     if (target === null) return;
-    const source = right.type === import_utils120.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils120.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils120.AST_NODE_TYPES.Identifier ? right.object.name : null;
+    const source = right.type === import_utils121.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils121.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils121.AST_NODE_TYPES.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   for (const statement of body2.body) {
@@ -22372,26 +22489,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-    const name = import_utils120.ASTUtils.getPropertyName(current);
+  while (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+    const name = import_utils121.ASTUtils.getPropertyName(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === import_utils120.AST_NODE_TYPES.ThisExpression ? root : null;
+  return current.type === import_utils121.AST_NODE_TYPES.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === import_utils120.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
-  if (value.type === import_utils120.AST_NODE_TYPES.AssignmentPattern) value = value.left;
-  if (value.type === import_utils120.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== import_utils120.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === import_utils121.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
+  if (value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern) value = value.left;
+  if (value.type === import_utils121.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== import_utils121.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === import_utils120.AST_NODE_TYPES.RestElement)
-        return property.argument.type === import_utils120.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === import_utils120.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-      return target.type === import_utils120.AST_NODE_TYPES.Identifier ? [target.name] : [];
+      if (property.type === import_utils121.AST_NODE_TYPES.RestElement)
+        return property.argument.type === import_utils121.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+      return target.type === import_utils121.AST_NODE_TYPES.Identifier ? [target.name] : [];
     })
   );
 }
@@ -22416,20 +22533,20 @@ var require_sql_access_class_default = createRule({
       const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === import_utils120.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils120.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      if (node.type === import_utils121.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils121.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
         if (binding?.defs.length !== 1 || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         const definition = binding.defs[0];
         return definition?.type === "Variable" && definition.node.init !== null && knownNonDatabase(definition.node.init, seen);
       }
-      return node.type === import_utils120.AST_NODE_TYPES.NewExpression && unwrappedNodeCallee?.type === import_utils120.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(unwrappedNodeCallee.name) && (import_utils120.ASTUtils.findVariable(context.sourceCode.getScope(unwrappedNodeCallee), unwrappedNodeCallee.name)?.defs.length ?? 0) === 0;
+      return node.type === import_utils121.AST_NODE_TYPES.NewExpression && unwrappedNodeCallee?.type === import_utils121.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(unwrappedNodeCallee.name) && (import_utils121.ASTUtils.findVariable(context.sourceCode.getScope(unwrappedNodeCallee), unwrappedNodeCallee.name)?.defs.length ?? 0) === 0;
     }
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils120.AST_NODE_TYPES.MemberExpression)
+        if (unwrappedNodeCallee.type !== import_utils121.AST_NODE_TYPES.MemberExpression)
           return;
-        const method = import_utils120.ASTUtils.getPropertyName(unwrappedNodeCallee);
+        const method = import_utils121.ASTUtils.getPropertyName(unwrappedNodeCallee);
         if (knownNonDatabase(unwrappedNodeCallee.object)) return;
         if (method === null || !isDatabaseOperation(method, unwrappedNodeCallee.object))
           return;
@@ -22445,7 +22562,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils121 = require("@typescript-eslint/utils");
+var import_utils122 = require("@typescript-eslint/utils");
 var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
   summary: "Require Next.js middleware and proxy matcher configuration to contain only build-time literals.",
   rationale: "Next.js must statically analyze matcher values at build time; computed values are ignored.",
@@ -22461,27 +22578,27 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function isStaticValue(node) {
   const value = unwrapExpression(node);
-  if (value.type === import_utils121.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils122.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils122.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils122.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils121.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils122.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils122.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils121.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils121.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils122.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils122.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName5(property) {
-  if (!property.computed && property.key.type === import_utils121.AST_NODE_TYPES.Identifier) return property.key.name;
-  return property.key.type === import_utils121.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
+  if (!property.computed && property.key.type === import_utils122.AST_NODE_TYPES.Identifier) return property.key.name;
+  return property.key.type === import_utils122.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
   name: "require-static-next-matcher",
@@ -22503,19 +22620,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils121.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils122.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils121.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils122.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression(declaration.init);
-          if (config.type !== import_utils121.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils121.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils122.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils122.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -22529,7 +22646,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils122 = require("@typescript-eslint/utils");
+var import_utils123 = require("@typescript-eslint/utils");
 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.",
@@ -22562,8 +22679,8 @@ var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
 };
 function staticPropertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils122.AST_NODE_TYPES.Identifier) return property.key.name;
-  if (property.key.type === import_utils122.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
+  if (property.key.type === import_utils123.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils123.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
   return null;
 }
 var require_use_form_default_values_default = createRule({
@@ -22580,7 +22697,7 @@ var require_use_form_default_values_default = createRule({
     const imported = /* @__PURE__ */ new Map();
     const uninitializedForms = /* @__PURE__ */ new Set();
     const uninitializedControls = /* @__PURE__ */ new Set();
-    const bindingNamed = (node, name) => import_utils122.ASTUtils.findVariable(context.sourceCode.getScope(node), name);
+    const bindingNamed = (node, name) => import_utils123.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) => {
@@ -22593,22 +22710,22 @@ var require_use_form_default_values_default = createRule({
     };
     const isDefinitelyUndefined = (node) => {
       const value = unwrapExpression(node);
-      return value.type === import_utils122.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils122.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
+      return value.type === import_utils123.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils123.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
     };
     const uninitializedUseFormCall = (node) => {
       node = unwrapExpression(node);
       const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-      if (node.type !== import_utils122.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils122.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useForm") return false;
+      if (node.type !== import_utils123.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils123.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useForm") return false;
       const options = node.arguments[0];
-      return options?.type !== import_utils122.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
+      return options?.type !== import_utils123.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
     };
     const initializationState = (node) => {
       if (node === void 0) return "uninitialized";
-      if (node.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) return "unknown";
+      if (node.type !== import_utils123.AST_NODE_TYPES.ObjectExpression) return "unknown";
       const initialization = /* @__PURE__ */ new Map();
       for (const property of node.properties) {
-        if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
+        if (property.type === import_utils123.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property) continue;
         const name = staticPropertyName2(property);
         if (name === "defaultValues" || name === "values") initialization.set(name, !isDefinitelyUndefined(property.value));
       }
@@ -22616,25 +22733,25 @@ var require_use_form_default_values_default = createRule({
     };
     const isUninitializedForm = (node) => {
       node = unwrapExpression(node);
-      if (node.type !== import_utils122.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils123.AST_NODE_TYPES.Identifier) return false;
       const variable = bindingOf(node);
       return variable !== null && stable(variable) && uninitializedForms.has(variable);
     };
     const isUninitializedControl = (node) => {
       node = unwrapExpression(node);
-      if (node.type === import_utils122.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils123.AST_NODE_TYPES.Identifier) {
         const variable = bindingOf(node);
         return variable !== null && stable(variable) && uninitializedControls.has(variable);
       }
-      return node.type === import_utils122.AST_NODE_TYPES.MemberExpression && import_utils122.ASTUtils.getPropertyName(node) !== null && (import_utils122.ASTUtils.getPropertyName(node) ?? "") === "control" && isUninitializedForm(node.object);
+      return node.type === import_utils123.AST_NODE_TYPES.MemberExpression && import_utils123.ASTUtils.getPropertyName(node) !== null && (import_utils123.ASTUtils.getPropertyName(node) ?? "") === "control" && isUninitializedForm(node.object);
     };
     const fieldOptionsNeedDefault = (node) => {
-      if (node?.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) return false;
+      if (node?.type !== import_utils123.AST_NODE_TYPES.ObjectExpression) return false;
       let control = null;
       let hasDefault = false;
       for (const property of node.properties) {
-        if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return false;
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
+        if (property.type === import_utils123.AST_NODE_TYPES.SpreadElement || property.computed) return false;
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property) continue;
         const name = staticPropertyName2(property);
         if (name === "control") control = property.value;
         if (name === "defaultValue") hasDefault = !isDefinitelyUndefined(property.value);
@@ -22644,14 +22761,14 @@ var require_use_form_default_values_default = createRule({
     const jsxAttribute = (node, name) => {
       let result = null;
       for (const attribute of node.attributes) {
-        if (attribute.type === import_utils122.AST_NODE_TYPES.JSXSpreadAttribute) return null;
-        if (attribute.name.type === import_utils122.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === name) result = attribute;
+        if (attribute.type === import_utils123.AST_NODE_TYPES.JSXSpreadAttribute) return null;
+        if (attribute.name.type === import_utils123.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === name) result = attribute;
       }
       return result;
     };
     const trackDestructuredControl = (pattern) => {
       for (const property of pattern.properties) {
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property || staticPropertyName2(property) !== "control" || property.value.type !== import_utils122.AST_NODE_TYPES.Identifier) continue;
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property || staticPropertyName2(property) !== "control" || property.value.type !== import_utils123.AST_NODE_TYPES.Identifier) continue;
         const variable = bindingOf(property.value);
         if (variable !== null) uninitializedControls.add(variable);
       }
@@ -22660,8 +22777,8 @@ var require_use_form_default_values_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type !== import_utils122.AST_NODE_TYPES.ImportSpecifier) continue;
-          const name = specifier.imported.type === import_utils122.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+          if (specifier.type !== import_utils123.AST_NODE_TYPES.ImportSpecifier) continue;
+          const name = specifier.imported.type === import_utils123.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);
@@ -22670,35 +22787,35 @@ var require_use_form_default_values_default = createRule({
       VariableDeclarator(node) {
         if (node.init === null) return;
         if (uninitializedUseFormCall(node.init)) {
-          if (node.id.type === import_utils122.AST_NODE_TYPES.Identifier) {
+          if (node.id.type === import_utils123.AST_NODE_TYPES.Identifier) {
             const variable = bindingOf(node.id);
             if (variable !== null) uninitializedForms.add(variable);
-          } else if (node.id.type === import_utils122.AST_NODE_TYPES.ObjectPattern) {
+          } else if (node.id.type === import_utils123.AST_NODE_TYPES.ObjectPattern) {
             trackDestructuredControl(node.id);
           }
           return;
         }
-        if (node.id.type === import_utils122.AST_NODE_TYPES.ObjectPattern && isUninitializedForm(node.init)) {
+        if (node.id.type === import_utils123.AST_NODE_TYPES.ObjectPattern && isUninitializedForm(node.init)) {
           trackDestructuredControl(node.id);
           return;
         }
-        if (node.id.type === import_utils122.AST_NODE_TYPES.Identifier && node.init.type === import_utils122.AST_NODE_TYPES.MemberExpression && import_utils122.ASTUtils.getPropertyName(node.init) !== null && (import_utils122.ASTUtils.getPropertyName(node.init) ?? "") === "control" && isUninitializedForm(node.init.object)) {
+        if (node.id.type === import_utils123.AST_NODE_TYPES.Identifier && node.init.type === import_utils123.AST_NODE_TYPES.MemberExpression && import_utils123.ASTUtils.getPropertyName(node.init) !== null && (import_utils123.ASTUtils.getPropertyName(node.init) ?? "") === "control" && isUninitializedForm(node.init.object)) {
           const variable = bindingOf(node.id);
           if (variable !== null) uninitializedControls.add(variable);
         }
       },
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils122.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === import_utils122.AST_NODE_TYPES.SpreadElement ? void 0 : node.arguments[0])) return;
+        if (unwrappedNodeCallee.type !== import_utils123.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === import_utils123.AST_NODE_TYPES.SpreadElement ? void 0 : node.arguments[0])) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       },
       JSXOpeningElement(node) {
-        if (node.name.type !== import_utils122.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
-        if (node.attributes.some((attribute) => attribute.type === import_utils122.AST_NODE_TYPES.JSXSpreadAttribute)) return;
+        if (node.name.type !== import_utils123.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.attributes.some((attribute) => attribute.type === import_utils123.AST_NODE_TYPES.JSXSpreadAttribute)) return;
         const control = jsxAttribute(node, "control");
-        if (control?.value?.type !== import_utils122.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils122.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
+        if (control?.value?.type !== import_utils123.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils123.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
         const defaultValue = jsxAttribute(node, "defaultValue");
-        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== import_utils122.AST_NODE_TYPES.JSXExpressionContainer || defaultValue.value.expression.type !== import_utils122.AST_NODE_TYPES.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
+        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== import_utils123.AST_NODE_TYPES.JSXExpressionContainer || defaultValue.value.expression.type !== import_utils123.AST_NODE_TYPES.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       }
     };
@@ -22706,7 +22823,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils123 = require("@typescript-eslint/utils");
+var import_utils124 = require("@typescript-eslint/utils");
 var ACTION_MODULE_RE = /(?:^|\/)app\/.*\/(?:actions|[^/]+-actions)\.[cm]?[jt]s$/u;
 var REQUIRE_USE_SERVER_IN_ACTIONS_FILE_DOCUMENTATION = {
   summary: "route action module missing the use server directive",
@@ -22773,7 +22890,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils124 = require("@typescript-eslint/utils");
+var import_utils125 = require("@typescript-eslint/utils");
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
   rationale: "FormData values are untrusted strings or files and need runtime validation before use.",
@@ -22799,14 +22916,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils124.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils125.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils124.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils125.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils124.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils125.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -22815,12 +22932,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils124.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils125.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils124.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils125.AST_NODE_TYPES.CallExpression) return false;
   const callee = unwrapExpression(current.callee);
-  return callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && import_utils124.ASTUtils.getPropertyName(callee) === "formData";
+  return callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && import_utils125.ASTUtils.getPropertyName(callee) === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -22841,29 +22958,29 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils124.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils125.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
     const isFormDataGetCall = (node) => {
       const callee = unwrapExpression(node.callee);
-      const calleeReceiver = callee.type === import_utils124.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-      if (callee.type !== import_utils124.AST_NODE_TYPES.MemberExpression) return false;
-      if (import_utils124.ASTUtils.getPropertyName(callee) === null || !FORM_VALUE_METHODS.has(import_utils124.ASTUtils.getPropertyName(callee) ?? "")) {
+      const calleeReceiver = callee.type === import_utils125.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+      if (callee.type !== import_utils125.AST_NODE_TYPES.MemberExpression) return false;
+      if (import_utils125.ASTUtils.getPropertyName(callee) === null || !FORM_VALUE_METHODS.has(import_utils125.ASTUtils.getPropertyName(callee) ?? "")) {
         return false;
       }
       return isFormSourceIdentifier(calleeReceiver);
     };
     const isFormSourceIdentifier = (node) => {
       node = unwrapExpression(node);
-      if (node.type !== import_utils124.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.Identifier) return false;
       const conventionalName = /formdata/i.test(node.name);
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils124.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils125.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -22876,24 +22993,24 @@ var require_zod_form_validation_default = createRule({
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
         if (isZodParseCall(parent)) return parent;
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils124.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils125.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && parent.callee.object.type === import_utils124.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && import_utils124.ASTUtils.getPropertyName(parent.callee) === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && parent.callee.object.type === import_utils125.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && import_utils125.ASTUtils.getPropertyName(parent.callee) === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression || parent.type === import_utils124.AST_NODE_TYPES.NewExpression || parent.type === import_utils124.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils124.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils124.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils124.AST_NODE_TYPES.FunctionDeclaration) return null;
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression || parent.type === import_utils125.AST_NODE_TYPES.NewExpression || parent.type === import_utils125.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils125.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils125.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils125.AST_NODE_TYPES.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils124.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.CallExpression) return false;
       const callee = unwrapExpression(node.callee);
-      const calleeReceiver = callee.type === import_utils124.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-      if (callee.type !== import_utils124.AST_NODE_TYPES.MemberExpression || import_utils124.ASTUtils.getPropertyName(callee) === null || !ZOD_PARSE_METHODS.has(import_utils124.ASTUtils.getPropertyName(callee) ?? "")) {
+      const calleeReceiver = callee.type === import_utils125.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+      if (callee.type !== import_utils125.AST_NODE_TYPES.MemberExpression || import_utils125.ASTUtils.getPropertyName(callee) === null || !ZOD_PARSE_METHODS.has(import_utils125.ASTUtils.getPropertyName(callee) ?? "")) {
         return false;
       }
       const root = zodReceiverRoot(calleeReceiver);
@@ -22907,25 +23024,25 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils124.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils125.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils124.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils124.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils124.AST_NODE_TYPES.Literal || init?.type === import_utils124.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils124.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils125.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils125.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils125.AST_NODE_TYPES.Literal || init?.type === import_utils125.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils125.AST_NODE_TYPES.FunctionExpression;
     };
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils124.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils125.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === import_utils124.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils124.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils124.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils124.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils125.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils125.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils125.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils125.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils124.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils124.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils125.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils125.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -22934,7 +23051,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils124.AST_NODE_TYPES.BlockStatement || parent.type === import_utils124.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.BlockStatement || parent.type === import_utils125.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -22949,7 +23066,7 @@ var require_zod_form_validation_default = createRule({
       if (declarationStatement === null || validationStatement === null || declarationStatement.parent !== validationStatement.parent || validationStatement.range[0] <= declarationStatement.range[1] || hasConditionalAncestorBeforeStatement(parse2, validationStatement)) {
         return null;
       }
-      if (validationStatement.type !== import_utils124.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils124.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils125.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils125.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -22962,7 +23079,7 @@ var require_zod_form_validation_default = createRule({
     const isAwaitedBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils124.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils125.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -22970,7 +23087,7 @@ var require_zod_form_validation_default = createRule({
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils124.AST_NODE_TYPES.LogicalExpression || current.type === import_utils124.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils125.AST_NODE_TYPES.LogicalExpression || current.type === import_utils125.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -22979,20 +23096,20 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = unwrapExpression(call.callee);
-      return callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && import_utils124.ASTUtils.getPropertyName(callee) !== null ? import_utils124.ASTUtils.getPropertyName(callee) ?? "" : null;
+      return callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && import_utils125.ASTUtils.getPropertyName(callee) !== null ? import_utils125.ASTUtils.getPropertyName(callee) ?? "" : null;
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils124.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils125.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils124.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils125.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils124.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils125.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -23003,23 +23120,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils124.AST_NODE_TYPES.ReturnStatement || node.type === import_utils124.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils125.AST_NODE_TYPES.ReturnStatement || node.type === import_utils125.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils124.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
       const last = node.body.at(-1);
       return last !== void 0 && blockTerminates(last);
     };
     const narrowingIf = (identifier) => {
       const comparison = identifier.parent;
-      if (comparison?.type !== import_utils124.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils124.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils125.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils125.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils124.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils125.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils124.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils125.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -23039,7 +23156,7 @@ var require_zod_form_validation_default = createRule({
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
       const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
-        (identifier) => identifier.type === import_utils124.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils125.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -23065,7 +23182,7 @@ var require_zod_form_validation_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils124.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils124.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils124.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils124.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils125.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils125.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils125.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils125.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -23086,7 +23203,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils125 = require("@typescript-eslint/utils");
+var import_utils126 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Review conflict handling for embedded inserts in replay-named callables.",
   rationale: "Names such as seed, enqueue, or upsert suggest that repeated execution deserves a conflict-policy review, but do not prove a replay contract.",
@@ -23155,7 +23272,7 @@ function expressionCallableName(current) {
 }
 
 // src/rules/stepdown.ts
-var import_utils126 = require("@typescript-eslint/utils");
+var import_utils127 = require("@typescript-eslint/utils");
 var STEPDOWN_DOCUMENTATION = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -23173,7 +23290,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils126.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils126.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils127.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils127.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.key, definition]));
@@ -23269,7 +23386,7 @@ function cycleComponents(graph) {
   return components;
 }
 function isErasedExpression2(node) {
-  return node.type === import_utils126.AST_NODE_TYPES.TSAsExpression || node.type === import_utils126.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils126.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils126.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils126.AST_NODE_TYPES.TSInstantiationExpression;
+  return node.type === import_utils127.AST_NODE_TYPES.TSAsExpression || node.type === import_utils127.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils127.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils127.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils127.AST_NODE_TYPES.TSInstantiationExpression;
 }
 function unwrapExpression4(node) {
   let current = node;
@@ -23293,11 +23410,11 @@ function localCallCount(context, node, owner) {
     if (current === void 0 || enclosingFunction5(context, current) !== owner) return null;
     const expression = wrappedExpression(current);
     const parent = expression.parent;
-    if (parent?.type === import_utils126.AST_NODE_TYPES.CallExpression && parent.callee === expression) {
+    if (parent?.type === import_utils127.AST_NODE_TYPES.CallExpression && parent.callee === expression) {
       count += 1;
       continue;
     }
-    if (parent?.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || parent.init !== expression || parent.id.type !== import_utils126.AST_NODE_TYPES.Identifier || parent.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || parent.parent.kind !== "const") return null;
+    if (parent?.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || parent.init !== expression || parent.id.type !== import_utils127.AST_NODE_TYPES.Identifier || parent.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || parent.parent.kind !== "const") return null;
     const variable = context.sourceCode.getDeclaredVariables(parent)[0];
     if (variable === void 0 || seen.has(variable) || !stableVariable(variable)) return null;
     seen.add(variable);
@@ -23312,11 +23429,11 @@ function declarationScope(context, program) {
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
     program.body.flatMap((statement) => {
-      const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils126.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils127.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
-  const exported = program.type === import_utils126.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
+  const exported = program.type === import_utils127.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
   const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1);
   const definitions = scopeDefinitions.filter(
     (definition) => !exported.has(definition.name) && !overloadNames.has(definition.name)
@@ -23328,7 +23445,7 @@ function declarationScope(context, program) {
     runtimeBarrierPrefix.push((runtimeBarrierPrefix.at(-1) ?? 0) + (isDeferredModuleStatement(statement) ? 0 : 1));
   }
   const canMove = (helper, caller) => {
-    if (helper.node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration) return true;
+    if (helper.node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration) return true;
     const helperIndex = statementIndex(helper);
     const callerIndex = statementIndex(caller);
     return helperIndex !== void 0 && callerIndex !== void 0 && runtimeBarrierPrefix[callerIndex + 1] === runtimeBarrierPrefix[helperIndex + 1];
@@ -23370,26 +23487,26 @@ function moduleCallGraph(context, scopeDefinitions) {
   return { calls, pinned };
 }
 function isDeferredModuleStatement(statement) {
-  const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-  if (node === null || node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils126.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils126.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils126.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils126.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils126.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils126.AST_NODE_TYPES.EmptyStatement) return true;
-  return node.type === import_utils126.AST_NODE_TYPES.VariableDeclaration && node.declarations.every(
-    (declaration) => declaration.id.type === import_utils126.AST_NODE_TYPES.Identifier && declaration.init !== null && isFunction(unwrapExpression4(declaration.init))
+  const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+  if (node === null || node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils127.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils127.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils127.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils127.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils127.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils127.AST_NODE_TYPES.EmptyStatement) return true;
+  return node.type === import_utils127.AST_NODE_TYPES.VariableDeclaration && node.declarations.every(
+    (declaration) => declaration.id.type === import_utils127.AST_NODE_TYPES.Identifier && declaration.init !== null && isFunction(unwrapExpression4(declaration.init))
   );
 }
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   function collectNamedExports(statement) {
-    if (statement.type !== import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
-    if (statement.declaration?.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
+    if (statement.declaration?.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils126.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils127.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils126.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils127.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils126.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils127.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
@@ -23398,23 +23515,23 @@ function exportedNames(program) {
     collectNamedExports(statement);
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils126.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils127.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ key: node.id.name, name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const" || node.declarations.length !== 1) continue;
+    if (node?.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const" || node.declarations.length !== 1) continue;
     for (const declarator of node.declarations) {
       const initializer = declarator.init === null ? null : unwrapExpression4(declarator.init);
-      if (declarator.id.type === import_utils126.AST_NODE_TYPES.Identifier && initializer !== null && isFunction(initializer)) {
+      if (declarator.id.type === import_utils127.AST_NODE_TYPES.Identifier && initializer !== null && isFunction(initializer)) {
         definitions.push({
           key: declarator.id.name,
           name: declarator.id.name,
@@ -23428,25 +23545,25 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  if (!node.computed && node.key.type === import_utils126.AST_NODE_TYPES.Identifier) return node.key.name;
-  return node.key.type === import_utils126.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
+  if (node.key.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  if (!node.computed && node.key.type === import_utils127.AST_NODE_TYPES.Identifier) return node.key.name;
+  return node.key.type === import_utils127.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
 }
 function methodKey(name, isStatic2) {
   return `${isStatic2 ? "static" : "instance"}:${name}`;
 }
 function receiverDomain(context, object, receivers, thisIsStatic) {
   const unwrapped = unwrapExpression4(object);
-  if (unwrapped.type === import_utils126.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
+  if (unwrapped.type === import_utils127.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
   return externalReceiverDomain(context, unwrapped, receivers);
 }
 function externalReceiverDomain(context, object, receivers) {
   const origin = receiverOrigin(context, object, receivers);
   if (origin === null || typeof origin === "boolean") return origin;
-  if (origin.type === import_utils126.AST_NODE_TYPES.NewExpression) {
+  if (origin.type === import_utils127.AST_NODE_TYPES.NewExpression) {
     return receiverOrigin(context, origin.callee, receivers) === true ? false : null;
   }
-  if (origin.type === import_utils126.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils126.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils126.AST_NODE_TYPES.Literal || origin.type === import_utils126.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils126.AST_NODE_TYPES.FunctionExpression) return "unrelated";
+  if (origin.type === import_utils127.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils127.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils127.AST_NODE_TYPES.Literal || origin.type === import_utils127.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils127.AST_NODE_TYPES.FunctionExpression) return "unrelated";
   return null;
 }
 function receiverOrigin(context, object, receivers) {
@@ -23454,8 +23571,8 @@ function receiverOrigin(context, object, receivers) {
   const seen = /* @__PURE__ */ new Set();
   while (true) {
     const unwrapped = unwrapExpression4(current);
-    if (unwrapped.type !== import_utils126.AST_NODE_TYPES.Identifier) return unwrapped;
-    const variable = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
+    if (unwrapped.type !== import_utils127.AST_NODE_TYPES.Identifier) return unwrapped;
+    const variable = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
     if (variable === null) return null;
     const known = receivers.get(variable);
     if (known !== void 0) return known;
@@ -23468,25 +23585,25 @@ function immutableInitializer(variable, seen) {
   if (seen.has(variable) || !stableVariable(variable) || variable.defs.length !== 1) return null;
   seen.add(variable);
   const definition = variable.defs[0];
-  if (definition?.node.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
+  if (definition?.node.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
   return definition.node.init;
 }
 function stableVariable(variable) {
   return !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils126.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils126.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils127.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils127.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
-  const nested = nestedFunction || isFunction(node) || node.type === import_utils126.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils126.AST_NODE_TYPES.ClassExpression;
+  const nested = nestedFunction || isFunction(node) || node.type === import_utils127.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils127.AST_NODE_TYPES.ClassExpression;
   forEachAstChild(node, visitorKeys, (child) => walk(child, visitorKeys, visit, nested));
 }
 function classScope(context, node, computedReferences) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils126.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils127.AST_NODE_TYPES.MethodDefinition
   );
   const counts = classMethodCounts(node.body, methods);
   const implementations = methods.filter((method) => isFunction(method.value));
@@ -23497,7 +23614,7 @@ function classScope(context, node, computedReferences) {
     return name !== null && key !== null && implementationCounts.get(key) === 1 ? [{ key, name, node: method }] : [];
   });
   const definitions = scopeDefinitions.filter(
-    ({ key, node: method }) => (method.accessibility === "private" || method.key.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) && counts.get(key) === 1 && method.decorators.length === 0 && !method.computed && method.kind === "method"
+    ({ key, node: method }) => (method.accessibility === "private" || method.key.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) && counts.get(key) === 1 && method.decorators.length === 0 && !method.computed && method.kind === "method"
   );
   if (definitions.length === 0) return;
   const methodKeys = new Set(scopeDefinitions.map((definition) => definition.key));
@@ -23513,11 +23630,11 @@ function classScope(context, node, computedReferences) {
   };
   function pinDestructuredMembers(binding, domain) {
     for (const property of binding.properties) {
-      if (property.type === import_utils126.AST_NODE_TYPES.RestElement || property.computed) {
+      if (property.type === import_utils127.AST_NODE_TYPES.RestElement || property.computed) {
         pinNames(null, domain);
-      } else if (property.key.type === import_utils126.AST_NODE_TYPES.Identifier) {
+      } else if (property.key.type === import_utils127.AST_NODE_TYPES.Identifier) {
         pinNames(property.key.name, domain);
-      } else if (property.key.type === import_utils126.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
+      } else if (property.key.type === import_utils127.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
         pinNames(property.key.value, domain);
       }
     }
@@ -23539,15 +23656,15 @@ function classScope(context, node, computedReferences) {
       }
     }
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
+      if (nestedFunction || current.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
       const domain = receiverDomain(context, current.init, receivers, method.static);
       if (domain === null || domain === "unrelated") return;
-      if (current.id.type === import_utils126.AST_NODE_TYPES.ObjectPattern) {
+      if (current.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern) {
         pinDestructuredMembers(current.id, domain);
         return;
       }
-      if (current.id.type !== import_utils126.AST_NODE_TYPES.Identifier) return;
-      if (current.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const") {
+      if (current.id.type !== import_utils127.AST_NODE_TYPES.Identifier) return;
+      if (current.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const") {
         pinNames(null, domain);
         return;
       }
@@ -23556,7 +23673,7 @@ function classScope(context, node, computedReferences) {
       const local = variable.references.every((reference) => {
         if (!reference.isRead()) return true;
         const expression = wrappedExpression(reference.identifier);
-        return enclosingFunction5(context, reference.identifier) === methodFunction && expression.parent?.type === import_utils126.AST_NODE_TYPES.MemberExpression && expression.parent.object === expression;
+        return enclosingFunction5(context, reference.identifier) === methodFunction && expression.parent?.type === import_utils127.AST_NODE_TYPES.MemberExpression && expression.parent.object === expression;
       });
       if (local) receivers.set(variable, domain);
       else pinNames(null, domain);
@@ -23568,7 +23685,7 @@ function classScope(context, node, computedReferences) {
         const domain2 = receiverDomain(context, destructuring.value, receivers, method.static);
         if (domain2 !== "unrelated") pinDestructuredMembers(destructuring.binding, domain2);
       }
-      if (current.type !== import_utils126.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return;
       const domain = receiverDomain(context, current.object, receivers, method.static);
       const targetName = referencedPropertyName(current);
       if (domain === "unrelated") return;
@@ -23602,9 +23719,9 @@ function classScope(context, node, computedReferences) {
   }
   for (const method of methods) collectMethodCalls(method);
   for (const member of node.body.body) {
-    if (member.type === import_utils126.AST_NODE_TYPES.MethodDefinition || member.type === import_utils126.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils127.AST_NODE_TYPES.MethodDefinition || member.type === import_utils127.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils126.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return;
       if (externalReceiverDomain(context, current.object, classReceivers) === "unrelated") return;
       pinNames(referencedPropertyName(current));
     });
@@ -23636,32 +23753,32 @@ function classScope(context, node, computedReferences) {
 function classReceiverBindings(context, node) {
   const classReceivers = /* @__PURE__ */ new Map();
   if (node.id !== null) {
-    const internal = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null && stableVariable(internal)) classReceivers.set(internal, true);
   }
-  if (node.type === import_utils126.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils126.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils126.AST_NODE_TYPES.Identifier && node.parent.parent.type === import_utils126.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.kind === "const") {
-    const outer = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils127.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils127.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils127.AST_NODE_TYPES.Identifier && node.parent.parent.type === import_utils127.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.kind === "const") {
+    const outer = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null && stableVariable(outer)) classReceivers.set(outer, true);
   }
   return classReceivers;
 }
 function receiverDestructuring(node) {
-  if (node.type === import_utils126.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils126.AST_NODE_TYPES.ObjectPattern && node.init !== null) {
+  if (node.type === import_utils127.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern && node.init !== null) {
     return { binding: node.id, value: node.init };
   }
-  if ((node.type === import_utils126.AST_NODE_TYPES.AssignmentPattern || node.type === import_utils126.AST_NODE_TYPES.AssignmentExpression) && node.left.type === import_utils126.AST_NODE_TYPES.ObjectPattern) {
+  if ((node.type === import_utils127.AST_NODE_TYPES.AssignmentPattern || node.type === import_utils127.AST_NODE_TYPES.AssignmentExpression) && node.left.type === import_utils127.AST_NODE_TYPES.ObjectPattern) {
     return { binding: node.left, value: node.right };
   }
   return null;
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils126.AST_NODE_TYPES.StaticBlock:
+    case import_utils127.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils126.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils126.AST_NODE_TYPES.AccessorProperty:
+    case import_utils127.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils127.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils126.AST_NODE_TYPES.MethodDefinition:
+    case import_utils127.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -23691,14 +23808,14 @@ var stepdown_default = createRule({
         classes.push(node);
       },
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression": (node) => {
-        if (isFunction(node) && node.body?.type === import_utils126.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
+        if (isFunction(node) && node.body?.type === import_utils127.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
       },
       "Program:exit": (program) => {
         declarationScope(context, program);
         for (const body2 of functionBodies) declarationScope(context, body2);
         const computedReferences = [];
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils126.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
+          if (node.type === import_utils127.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
         });
         for (const node of classes) classScope(context, node, computedReferences);
       }
@@ -23715,8 +23832,8 @@ function classMethodCounts(body2, methods) {
     }
   }
   for (const member of body2.body) {
-    if (member.type !== import_utils126.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils126.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils127.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils127.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) {
       const key = methodKey(name, member.static);
       counts.set(key, (counts.get(key) ?? 0) + 1);
@@ -23726,7 +23843,7 @@ function classMethodCounts(body2, methods) {
 }
 
 // src/rules/source-coupled-test.ts
-var import_utils127 = require("@typescript-eslint/utils");
+var import_utils128 = require("@typescript-eslint/utils");
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
@@ -23800,16 +23917,16 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
 function unwrap6(node) {
   for (; ; ) {
     node = unwrapExpression(node);
-    if (node.type === import_utils127.AST_NODE_TYPES.AwaitExpression) node = node.argument;
-    else if (node.type === import_utils127.AST_NODE_TYPES.ChainExpression) node = node.expression;
+    if (node.type === import_utils128.AST_NODE_TYPES.AwaitExpression) node = node.argument;
+    else if (node.type === import_utils128.AST_NODE_TYPES.ChainExpression) node = node.expression;
     else return node;
   }
 }
 function stringValue(node) {
   const current = unwrap6(node);
-  if (current.type === import_utils127.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils127.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+  if (current.type === import_utils128.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils128.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -23821,7 +23938,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap6(node);
-  if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils127.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils127.AST_NODE_TYPES.SpreadElement) return null;
+  if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils128.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils128.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -23843,7 +23960,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const scopes = [newScope()];
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
-      const bindingOf = (node) => import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      const bindingOf = (node) => import_utils128.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
       const assertionKind = (node) => {
         const binding = bindingOf(node);
         if (binding === null || binding.defs.length === 0) {
@@ -23877,75 +23994,75 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils127.AST_NODE_TYPES.Identifier) return visible("paths", current);
-        if (current.type === import_utils127.AST_NODE_TYPES.CallExpression || current.type === import_utils127.AST_NODE_TYPES.NewExpression) {
+        if (current.type === import_utils128.AST_NODE_TYPES.Identifier) return visible("paths", current);
+        if (current.type === import_utils128.AST_NODE_TYPES.CallExpression || current.type === import_utils128.AST_NODE_TYPES.NewExpression) {
           const callee = unwrapExpression(current.callee);
           const first = current.arguments[0];
-          if (first === void 0 || first.type === import_utils127.AST_NODE_TYPES.SpreadElement) return false;
-          if (current.type === import_utils127.AST_NODE_TYPES.NewExpression && callee.type === import_utils127.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === import_utils127.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils127.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils127.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils127.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === import_utils128.AST_NODE_TYPES.SpreadElement) return false;
+          if (current.type === import_utils128.AST_NODE_TYPES.NewExpression && callee.type === import_utils128.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === import_utils128.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils128.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils128.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils128.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
         }
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap6(node);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type === import_utils127.AST_NODE_TYPES.Identifier) {
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type === import_utils128.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return false;
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return false;
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         const object = unwrap6(calleeReceiver);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils127.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils128.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap6(node);
-        if (current.type === import_utils127.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
+        if (current.type === import_utils128.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils127.AST_NODE_TYPES.MemberExpression && import_utils127.ASTUtils.getPropertyName(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils128.AST_NODE_TYPES.MemberExpression && import_utils128.ASTUtils.getPropertyName(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(calleeReceiver) : /* @__PURE__ */ new Set();
       };
       const evidenceOrigins = (node) => {
         const current = unwrap6(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression || current.type === import_utils127.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils127.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression || current.type === import_utils128.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils128.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(calleeReceiver);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap6(node.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type === import_utils127.AST_NODE_TYPES.Identifier && assertionKind(callee) === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type === import_utils128.AST_NODE_TYPES.Identifier && assertionKind(callee) === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const matcher = import_utils127.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const matcher = import_utils128.ASTUtils.getPropertyName(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap6(calleeReceiver);
-        while (receiver.type === import_utils127.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(import_utils127.ASTUtils.getPropertyName(receiver) ?? "")) receiver = unwrap6(receiver.object);
-        const expectCallee = receiver.type === import_utils127.AST_NODE_TYPES.CallExpression ? unwrapExpression(receiver.callee) : null;
-        if (receiver.type === import_utils127.AST_NODE_TYPES.CallExpression && expectCallee?.type === import_utils127.AST_NODE_TYPES.Identifier && assertionKind(expectCallee) === "expect") {
+        while (receiver.type === import_utils128.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(import_utils128.ASTUtils.getPropertyName(receiver) ?? "")) receiver = unwrap6(receiver.object);
+        const expectCallee = receiver.type === import_utils128.AST_NODE_TYPES.CallExpression ? unwrapExpression(receiver.callee) : null;
+        if (receiver.type === import_utils128.AST_NODE_TYPES.CallExpression && expectCallee?.type === import_utils128.AST_NODE_TYPES.Identifier && assertionKind(expectCallee) === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils127.AST_NODE_TYPES.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils128.AST_NODE_TYPES.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -23967,7 +24084,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap6(node);
-        return current.type === import_utils127.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils127.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        return current.type === import_utils128.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils128.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -23977,8 +24094,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       function declareFsReaders(pattern) {
         for (const property of pattern.properties) {
-          if (property.type !== import_utils127.AST_NODE_TYPES.Property || property.value.type !== import_utils127.AST_NODE_TYPES.Identifier) continue;
-          const key = property.key.type === import_utils127.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils127.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+          if (property.type !== import_utils128.AST_NODE_TYPES.Property || property.value.type !== import_utils128.AST_NODE_TYPES.Identifier) continue;
+          const key = property.key.type === import_utils128.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils128.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
           if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
         }
       }
@@ -23987,8 +24104,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           const source = importSource(node);
           if (source === null || !FS_MODULES.has(source)) return;
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils127.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils128.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -24001,26 +24118,26 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (node.init === null) return;
           const required = requireSource(node.init);
           const initializer = unwrap6(node.init);
-          if (required !== null && initializer.type === import_utils127.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils127.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils127.AST_NODE_TYPES.Identifier) {
+          if (required !== null && initializer.type === import_utils128.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils128.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils128.AST_NODE_TYPES.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils128.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             declareFsReaders(node.id);
             return;
           }
-          if (node.id.type !== import_utils127.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils128.AST_NODE_TYPES.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils127.AST_NODE_TYPES.Identifier) declare(node.left, {});
+          if (node.left.type === import_utils128.AST_NODE_TYPES.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap6(node.right);
-          const collection = right.type === import_utils127.AST_NODE_TYPES.Identifier && visible("collections", right);
-          const left = node.left.type === import_utils127.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils127.AST_NODE_TYPES.Identifier) declare(left, { path: true });
+          const collection = right.type === import_utils128.AST_NODE_TYPES.Identifier && visible("collections", right);
+          const left = node.left.type === import_utils128.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils128.AST_NODE_TYPES.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -24038,22 +24155,22 @@ var source_coupled_test_default = createSourceCoupledRule(
   GENERAL_SOURCE_SUFFIX_RE
 );
 function importedAssertionKind(specifier) {
-  if (specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils127.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils127.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.parent.type !== import_utils127.AST_NODE_TYPES.ImportDeclaration) return null;
+  if (specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils128.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils128.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.parent.type !== import_utils128.AST_NODE_TYPES.ImportDeclaration) return null;
   const source = importSource(specifier.parent);
   if (source !== null && ASSERT_MODULES.has(source)) {
-    if (specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier) return "assert";
-    const imported2 = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+    if (specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier) return "assert";
+    const imported2 = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
     if (imported2 === "strict" || ASSERT_MATCHERS.has(imported2)) return "assert";
     return null;
   }
-  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier) return null;
-  const imported = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier) return null;
+  const imported = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
   if (imported === "assert" || imported === "expect") return imported;
   return null;
 }
 
 // src/rules/sole-export-matches-filename.ts
-var import_utils128 = require("@typescript-eslint/utils");
+var import_utils129 = require("@typescript-eslint/utils");
 
 // src/rules/_is-framework-entrypoint.ts
 var import_node_fs2 = require("fs");
@@ -24169,7 +24286,7 @@ var sole_export_matches_filename_default = createRule({
         if (only === void 0) return;
         if (isFrameworkEntrypoint(normalizedFilename, only.key)) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
-        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils128.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
+        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils129.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
@@ -24219,7 +24336,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils129 = require("@typescript-eslint/utils");
+var import_utils130 = require("@typescript-eslint/utils");
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
   rationale: "A reusable Zod schema is a runtime type contract. PascalCase mirrors that role; SCREAMING_SNAKE_CASE should remain reserved for scalar values and lookup tables.",
@@ -24351,19 +24468,19 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => import_utils129.ASTUtils.getPropertyName(callee) !== null ? import_utils129.ASTUtils.getPropertyName(callee) ?? "" : null;
+var terminalMethodName = (callee) => import_utils130.ASTUtils.getPropertyName(callee) !== null ? import_utils130.ASTUtils.getPropertyName(callee) ?? "" : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils129.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils130.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.CallExpression) {
       current = unwrapExpression(current.callee);
       continue;
     }
@@ -24375,13 +24492,13 @@ var chainMemberNames2 = (node) => {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils129.AST_NODE_TYPES.MemberExpression) {
-      if (import_utils129.ASTUtils.getPropertyName(current) === null) return [];
-      names.push(import_utils129.ASTUtils.getPropertyName(current) ?? "");
+    if (current.type === import_utils130.AST_NODE_TYPES.MemberExpression) {
+      if (import_utils130.ASTUtils.getPropertyName(current) === null) return [];
+      names.push(import_utils130.ASTUtils.getPropertyName(current) ?? "");
       current = current.object;
       continue;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.CallExpression) {
       current = unwrapExpression(current.callee);
       continue;
     }
@@ -24392,9 +24509,9 @@ var chainMemberNames2 = (node) => {
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils129.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils130.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils129.AST_NODE_TYPES.Program || owner.type === import_utils129.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils129.AST_NODE_TYPES.Program;
+  return owner.type === import_utils130.AST_NODE_TYPES.Program || owner.type === import_utils130.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils130.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -24414,7 +24531,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return import_utils129.ASTUtils.findVariable(
+      return import_utils130.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -24425,10 +24542,10 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression(expression);
-      if (init.type === import_utils129.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils129.AST_NODE_TYPES.CallExpression) return false;
+      if (init.type === import_utils130.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils130.AST_NODE_TYPES.CallExpression) return false;
       const callee = unwrapExpression(init.callee);
-      if (callee.type !== import_utils129.AST_NODE_TYPES.MemberExpression) {
+      if (callee.type !== import_utils130.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(callee);
@@ -24458,7 +24575,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils129.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils129.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils129.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils129.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils130.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils130.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils130.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils130.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -24467,7 +24584,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
         if (!isModuleDeclarator(node)) return;
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (node.id.type !== import_utils129.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils130.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -24669,6 +24786,7 @@ var RULES = {
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
   "repeated-static-call-cases": repeated_static_call_cases_default,
   "prefer-zod-infer": prefer_zod_infer_default,
+  "named-child-schema-type": named_child_schema_type_default,
   "prefer-zod-parse-output-type": prefer_zod_parse_output_type_default,
   "require-assert-never": require_assert_never_default,
   "require-fetch-timeout": require_fetch_timeout_default,
@@ -24694,6 +24812,7 @@ var LIBRARY_IMPORT_POLICY = ["error", {
 }];
 var ADVISORY_RULES = [
   "@sarj/excessive-commentary",
+  "@sarj/named-child-schema-type",
   "@sarj/no-bespoke-api-case-conversion",
   "@sarj/no-duplicate-test-case",
   "@sarj/no-json-stringify-object-equality",
@@ -24716,6 +24835,7 @@ var ADVISORY_RULES = [
   "@sarj/require-sql-access-class"
 ];
 var RECOMMENDED_RULES = {
+  "@sarj/named-child-schema-type": "warn",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",
@@ -24833,6 +24953,7 @@ var RECOMMENDED_RULES = {
   "@sarj/require-pascal-case-zod-schema-name": "error"
 };
 var STRICT_RULES = {
+  "@sarj/named-child-schema-type": "warn",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",