@sarj/eslint-plugin 15.14.0 → 15.16.0

package/dist/index.cjs

@@ -1274,8 +1274,8 @@ function testCallMatrixStems(comments) {
   const stems = /* @__PURE__ */ new Set();
   for (const comment of comments) {
     const body2 = stripCommentMarker(comment.value);
-    const stem3 = CALL_LABEL_RE.exec(body2)?.[1];
-    if (stem3 !== void 0 && MULTIPLIER_PSEUDOCODE_RE.test(body2)) stems.add(stem3);
+    const stem4 = CALL_LABEL_RE.exec(body2)?.[1];
+    if (stem4 !== void 0 && MULTIPLIER_PSEUDOCODE_RE.test(body2)) stems.add(stem4);
   }
   return stems;
 }
@@ -4051,8 +4051,8 @@ function privateMemberFixes(context, services, owner, members, removePrivateKeyw
       return;
     }
     if (node.type !== import_utils19.AST_NODE_TYPES.MemberExpression) return;
-    const propertyName5 = node.property.type === import_utils19.AST_NODE_TYPES.Identifier || node.property.type === import_utils19.AST_NODE_TYPES.PrivateIdentifier ? node.property.name : node.property.type === import_utils19.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
-    if (propertyName5 !== name) return;
+    const propertyName7 = node.property.type === import_utils19.AST_NODE_TYPES.Identifier || node.property.type === import_utils19.AST_NODE_TYPES.PrivateIdentifier ? node.property.name : node.property.type === import_utils19.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+    if (propertyName7 !== name) return;
     const propertySymbol = symbolAt(services, checker, node.property);
     if (node.computed || node.property.type !== import_utils19.AST_NODE_TYPES.Identifier || node.object.type !== import_utils19.AST_NODE_TYPES.ThisExpression || enclosingClass(node) !== owner || !symbols.some((symbol) => sameSymbol(symbol, propertySymbol))) {
       unsafe = true;
@@ -4924,8 +4924,8 @@ var CJS_OBJECT_EXPORT_METHODS = /* @__PURE__ */ new Set(["assign", "defineProper
 function fileParts(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
   const extension = base.match(/(\.[cm]?[jt]sx?)$/u)?.[1] ?? ".ts";
-  const [stem3 = "", ...suffixes] = base.slice(0, -extension.length).split(".");
-  return { stem: stem3, suffixes: suffixes.map((suffix) => suffix.toLowerCase()) };
+  const [stem4 = "", ...suffixes] = base.slice(0, -extension.length).split(".");
+  return { stem: stem4, suffixes: suffixes.map((suffix) => suffix.toLowerCase()) };
 }
 function declaredNames(declaration) {
   if (declaration.declare === true) return [];
@@ -5049,8 +5049,8 @@ var no_generic_single_export_module_default = createRule({
   defaultOptions: [],
   create(context) {
     const file = fileParts(context.filename);
-    const { stem: stem3 } = file;
-    if (!GENERIC_STEMS.has(stem3) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    const { stem: stem4 } = file;
+    if (!GENERIC_STEMS.has(stem4) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let hasCommonJsExport = false;
     return {
       CallExpression(node) {
@@ -5070,12 +5070,12 @@ var no_generic_single_export_module_default = createRule({
         const { name: exported, node } = onlyExport;
         if (isConventionalFrameworkUtility(context.filename, exported)) return;
         const exportedRole = exported.replaceAll(/[^a-z0-9]/giu, "").toLowerCase();
-        const pathRole = [stem3, ...file.suffixes].join("").replaceAll(/[^a-z0-9]/giu, "");
+        const pathRole = [stem4, ...file.suffixes].join("").replaceAll(/[^a-z0-9]/giu, "");
         if (exportedRole === pathRole && file.suffixes.length > 0) return;
         context.report({
           node,
           messageId: "genericSingleExport",
-          data: { stem: stem3, exported }
+          data: { stem: stem4, exported }
         });
       }
     };
@@ -5392,7 +5392,7 @@ var no_positional_tuple_return_default = createRule({
     const aliases = typeAliases(context.sourceCode.ast);
     const reportedFunctions = /* @__PURE__ */ new WeakSet();
     const functionStack = [];
-    const report = (annotation, name) => {
+    const report2 = (annotation, name) => {
       const tuple = tupleReturnType(annotation, aliases);
       if (tuple === null || tuple.elementTypes.length < MIN_ELEMENTS) return;
       context.report({
@@ -5426,7 +5426,7 @@ var no_positional_tuple_return_default = createRule({
       if (name === null) {
         return;
       }
-      report(annotation, name);
+      report2(annotation, name);
     };
     const enterFunction = (node) => {
       functionStack.push(node);
@@ -5451,34 +5451,34 @@ var no_positional_tuple_return_default = createRule({
       },
       TSDeclareFunction(node) {
         if (node.id === null || node.returnType === void 0 || node.parent.type !== import_utils28.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.type !== import_utils28.AST_NODE_TYPES.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
-        report(node.returnType.typeAnnotation, node.id.name);
+        report2(node.returnType.typeAnnotation, node.id.name);
       },
       TSCallSignatureDeclaration(node) {
         const owner = owningInterface(node);
         if (owner === null || !isExportedInterface(owner, typeExports) || node.returnType === void 0) return;
-        report(node.returnType.typeAnnotation, `${owner.id.name}.call`);
+        report2(node.returnType.typeAnnotation, `${owner.id.name}.call`);
       },
       TSMethodSignature(node) {
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
-        const memberName3 = staticMemberName3(node.key);
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || memberName3 === null) return;
-        report(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName3}`);
+        const memberName6 = staticMemberName3(node.key);
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || memberName6 === null) return;
+        report2(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName6}`);
       },
       TSTypeAliasDeclaration(node) {
         if (!typeExports.has(node.id.name)) return;
         const returnType = callableReturnType(node.typeAnnotation, aliases);
-        if (returnType !== null) report(returnType, node.id.name);
+        if (returnType !== null) report2(returnType, node.id.name);
       },
       TSPropertySignature(node) {
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
         const annotation = node.typeAnnotation?.typeAnnotation;
-        const memberName3 = staticMemberName3(node.key);
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || memberName3 === null || annotation === void 0) return;
+        const memberName6 = staticMemberName3(node.key);
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || memberName6 === null || annotation === void 0) return;
         const returnType = callableReturnType(annotation, aliases);
         if (returnType !== null) {
-          report(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName3}`);
+          report2(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName6}`);
         }
       },
       PropertyDefinition(node) {
@@ -5489,7 +5489,7 @@ var no_positional_tuple_return_default = createRule({
         const returnType = callableReturnType(annotation, aliases);
         if (returnType !== null) {
           const name = node.key.type === import_utils28.AST_NODE_TYPES.Identifier ? node.key.name : "property";
-          report(returnType, name);
+          report2(returnType, name);
         }
       }
     };
@@ -5965,7 +5965,7 @@ var no_restricted_library_load_default = createRule({
   defaultOptions: [{ libraries: [] }],
   create(context, [options]) {
     const restrictions = options.libraries;
-    function report(node, source) {
+    function report2(node, source) {
       const restriction = restrictions.find(
         (entry) => matchesModule(source, entry.module)
       );
@@ -5991,7 +5991,7 @@ var no_restricted_library_load_default = createRule({
     return {
       ImportExpression(node) {
         const source = literalModule(node.source);
-        if (source !== null) report(node.source, source);
+        if (source !== null) report2(node.source, source);
       },
       CallExpression(node) {
         let requireIdentifier = null;
@@ -6002,12 +6002,12 @@ var no_restricted_library_load_default = createRule({
         }
         if (requireIdentifier === null || !isUnshadowedRequire(requireIdentifier)) return;
         const source = literalModule(node.arguments[0]);
-        if (source !== null) report(node.arguments[0], source);
+        if (source !== null) report2(node.arguments[0], source);
       },
       TSImportEqualsDeclaration(node) {
         if (node.moduleReference.type !== import_utils32.AST_NODE_TYPES.TSExternalModuleReference) return;
         const source = literalModule(node.moduleReference.expression);
-        if (source !== null) report(node.moduleReference.expression, source);
+        if (source !== null) report2(node.moduleReference.expression, source);
       }
     };
   }
@@ -7823,7 +7823,7 @@ var no_sleep_in_test_body_default = createRule({
     if (!isTestFile(context.filename)) {
       return {};
     }
-    const report = (node) => {
+    const report2 = (node) => {
       if (!isImmediatelyConsumedSleep(node)) {
         return;
       }
@@ -7836,12 +7836,12 @@ var no_sleep_in_test_body_default = createRule({
     return {
       NewExpression(node) {
         if (isPromiseSleep(node)) {
-          report(node);
+          report2(node);
         }
       },
       CallExpression(node) {
         if (isHelperSleep(node)) {
-          report(node);
+          report2(node);
         }
       }
     };
@@ -10282,7 +10282,7 @@ function reportClass2(context, services, owner) {
 }
 function isConvertible(member) {
   if (member.type !== import_utils58.AST_NODE_TYPES.MethodDefinition && member.type !== import_utils58.AST_NODE_TYPES.PropertyDefinition && member.type !== import_utils58.AST_NODE_TYPES.AccessorProperty) return false;
-  return member.accessibility === "private" && !member.computed && member.key.type === import_utils58.AST_NODE_TYPES.Identifier && member.decorators.length === 0 && !("declare" in member && member.declare) && !member.override && !(member.type === import_utils58.AST_NODE_TYPES.MethodDefinition && member.value.body === null);
+  return member.accessibility === "private" && !(member.type === import_utils58.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor") && !member.computed && member.key.type === import_utils58.AST_NODE_TYPES.Identifier && member.decorators.length === 0 && !("declare" in member && member.declare) && !member.override && !(member.type === import_utils58.AST_NODE_TYPES.MethodDefinition && member.value.body === null);
 }
 var prefer_ecmascript_private_members_default = createRule({
   name: "prefer-ecmascript-private-members",
@@ -10480,9 +10480,9 @@ var INPUT_MODULE = /(?:^|\/)components\/ui\/input$/u;
 var INPUT_GROUP_MODULE = /(?:^|\/)components\/ui\/input-group$/u;
 var MAX_JSX_DISTANCE = 2;
 var SEARCH_EXPORTS = ["Search", "SearchIcon", "LucideSearch"];
-function localNamedImports(node, importedName6) {
+function localNamedImports(node, importedName7) {
   return node.specifiers.filter(
-    (specifier) => specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils61.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName6
+    (specifier) => specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils61.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName7
   ).map((specifier) => specifier.local.name);
 }
 function elementName(node) {
@@ -11695,8 +11695,67 @@ var prefer_module_level_schema_default = createRule({
   }
 });
 
-// src/rules/prefer-native-random-uuid.ts
+// src/rules/prefer-named-complex-return-type.ts
 var import_utils66 = require("@typescript-eslint/utils");
+var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
+  summary: "Prefer a named contract for structurally complex function return types.",
+  rationale: "A large inline return annotation hides a reusable domain concept and makes signatures difficult to scan.",
+  remediation: "Extract the return annotation to a named type or interface and reference that contract from the signature.",
+  category: "maintainability",
+  limitations: [
+    "Only explicit object types with at least three members and unions with at least three object variants are reported.",
+    "Generic wrappers such as Promise and Readonly are unwrapped one level at a time; inferred return types are outside this rule."
+  ],
+  examples: [
+    { id: "named-result", title: "Name a multi-state result", outcome: "no-match", files: [{ path: "src/queue.ts", source: "type ClaimResult = { state: 'idle' } | { state: 'waiting'; retryAt: number } | { state: 'claimed'; id: string }; export function claim(): ClaimResult { return { state: 'idle' }; }" }], focusPath: "src/queue.ts", expectedCount: 0, public: true },
+    { id: "inline-result", title: "Do not inline a multi-state result", outcome: "match", files: [{ path: "src/queue.ts", source: "export function claim(): { state: 'idle' } | { state: 'waiting'; retryAt: number } | { state: 'claimed'; id: string } { return { state: 'idle' }; }" }], focusPath: "src/queue.ts", expectedCount: 1, public: true }
+  ]
+};
+function unwrap4(node) {
+  if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments?.params.length === 1) {
+    const [inner] = node.typeArguments.params;
+    if (inner !== void 0) return unwrap4(inner);
+  }
+  return node;
+}
+function report(context, node) {
+  const annotation = node.returnType?.typeAnnotation;
+  if (annotation !== void 0 && isComplex(annotation)) {
+    context.report({ node: annotation, messageId: "nameComplexReturnType" });
+  }
+}
+function isComplex(node) {
+  const type = unwrap4(node);
+  if (type.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) return type.members.length >= 3;
+  if (type.type !== import_utils66.AST_NODE_TYPES.TSUnionType || type.types.length < 3) return false;
+  return type.types.every((member) => unwrap4(member).type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
+}
+var prefer_named_complex_return_type_default = createRule({
+  name: "prefer-named-complex-return-type",
+  documentation: PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer a named contract for structurally complex function return types." },
+    schema: [],
+    messages: {
+      nameComplexReturnType: "Extract this structurally complex return annotation to a named type or interface."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      ArrowFunctionExpression: (node) => report(context, node),
+      FunctionDeclaration: (node) => report(context, node),
+      FunctionExpression: (node) => report(context, node),
+      TSDeclareFunction: (node) => report(context, node),
+      TSMethodSignature: (node) => report(context, node)
+    };
+  }
+});
+
+// src/rules/prefer-native-random-uuid.ts
+var import_utils67 = require("@typescript-eslint/utils");
 var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
@@ -11710,7 +11769,7 @@ var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   ]
 };
 function requireUuid(node) {
-  return node?.type === import_utils66.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils66.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils66.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
+  return node?.type === import_utils67.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils67.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -11732,13 +11791,13 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return import_utils66.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return import_utils67.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
       if (variable !== null) destination.add(variable);
     }
-    function report(node) {
+    function report2(node) {
       context.report({
         node,
         messageId: "preferNative",
@@ -11754,48 +11813,291 @@ var prefer_native_random_uuid_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "uuid") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils66.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils66.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === import_utils67.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils67.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === import_utils66.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+          } else if (specifier.type === import_utils67.AST_NODE_TYPES.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== import_utils66.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils66.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== import_utils67.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils67.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === import_utils66.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils67.AST_NODE_TYPES.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== import_utils66.AST_NODE_TYPES.ObjectPattern) return;
+        if (node.id.type !== import_utils67.AST_NODE_TYPES.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === import_utils66.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils66.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils66.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils66.AST_NODE_TYPES.Identifier) {
+          if (property.type === import_utils67.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils67.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils67.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils67.AST_NODE_TYPES.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === import_utils66.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils67.AST_NODE_TYPES.Identifier) {
           const variable2 = resolve(node.callee);
-          if (variable2 !== null && directBindings.has(variable2)) report(node);
+          if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
-        if (node.callee.type !== import_utils66.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils66.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== import_utils67.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils67.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils67.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve(node.callee.object);
-        if (variable !== null && namespaceBindings.has(variable)) report(node);
+        if (variable !== null && namespaceBindings.has(variable)) report2(node);
+      }
+    };
+  }
+});
+
+// src/rules/prefer-node-crypto-hash.ts
+var import_utils68 = require("@typescript-eslint/utils");
+var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
+  summary: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
+  rationale: "A createHash-update-digest chain allocates mutable streaming state for a single in-memory value; Node's built-in hash function expresses the one-shot operation directly and can use its optimized fast path.",
+  remediation: "Import hash from node:crypto and replace a single-update chain with hash(algorithm, value, encoding). Keep createHash for streams or multiple incremental updates.",
+  category: "performance",
+  limitations: [
+    "Only bindings and inline calls with statically proven provenance from crypto or node:crypto are analyzed; arbitrary assignments and dynamic module specifiers are excluded.",
+    "Only a literal algorithm with exactly one update call is reported; streaming and incremental hashes remain valid."
+  ],
+  examples: [
+    { id: "one-shot-hash", title: "Use Node's one-shot hash API", outcome: "no-match", files: [{ path: "case.ts", source: "import { hash } from 'node:crypto'; export const digest = hash('sha256', 'value', 'hex');" }], focusPath: "case.ts", expectedCount: 0, public: true },
+    { id: "mutable-one-shot-chain", title: "Avoid mutable state for one value", outcome: "match", files: [{ path: "case.ts", source: "import { createHash } from 'node:crypto'; export const digest = createHash('sha256').update('value').digest('hex');" }], focusPath: "case.ts", expectedCount: 1, public: true }
+  ]
+};
+function memberName3(node) {
+  if (!node.computed && node.property.type === import_utils68.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils68.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return null;
+}
+function isCryptoLoader(node, resolve) {
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || node.arguments.length !== 1) return false;
+  const [argument] = node.arguments;
+  if (argument === void 0 || argument.type === import_utils68.AST_NODE_TYPES.SpreadElement || !isCryptoSpecifier(argument)) {
+    return false;
+  }
+  if (node.callee.type === import_utils68.AST_NODE_TYPES.Identifier) {
+    return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve);
+  }
+  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils68.AST_NODE_TYPES.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve) && memberName3(node.callee) === "getBuiltinModule";
+}
+function isCryptoSpecifier(node) {
+  return node.type === import_utils68.AST_NODE_TYPES.Literal && (node.value === "crypto" || node.value === "node:crypto");
+}
+function isUnshadowedBuiltinIdentifier(identifier, resolve) {
+  const variable = resolve(identifier);
+  return variable === null || variable.defs.length === 0;
+}
+function propertyName3(node) {
+  if (!node.computed && node.key.type === import_utils68.AST_NODE_TYPES.Identifier) return node.key.name;
+  if (node.key.type === import_utils68.AST_NODE_TYPES.Literal && typeof node.key.value === "string") {
+    return node.key.value;
+  }
+  return null;
+}
+var prefer_node_crypto_hash_default = createRule({
+  name: "prefer-node-crypto-hash",
+  documentation: PREFER_NODE_CRYPTO_HASH_DOCUMENTATION,
+  meta: { type: "problem", docs: { description: PREFER_NODE_CRYPTO_HASH_DOCUMENTATION.summary }, schema: [], messages: { preferNodeCryptoHash: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary." } },
+  defaultOptions: [],
+  create(context) {
+    const directBindings = /* @__PURE__ */ new Set();
+    const namespaceBindings = /* @__PURE__ */ new Set();
+    function resolve(identifier) {
+      return import_utils68.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function record(identifier, destination) {
+      const variable = resolve(identifier);
+      if (variable !== null) destination.add(variable);
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "crypto" && node.source.value !== "node:crypto") return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils68.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils68.AST_NODE_TYPES.ImportDefaultSpecifier) {
+            record(specifier.local, namespaceBindings);
+          } else if (specifier.type === import_utils68.AST_NODE_TYPES.ImportSpecifier && importedName5(specifier.imported) === "createHash") {
+            record(specifier.local, directBindings);
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve)) {
+          return;
+        }
+        if (node.id.type === import_utils68.AST_NODE_TYPES.Identifier) {
+          record(node.id, namespaceBindings);
+          return;
+        }
+        if (node.id.type !== import_utils68.AST_NODE_TYPES.ObjectPattern) return;
+        for (const property of node.id.properties) {
+          if (property.type === import_utils68.AST_NODE_TYPES.Property && propertyName3(property) === "createHash" && property.value.type === import_utils68.AST_NODE_TYPES.Identifier) {
+            record(property.value, directBindings);
+          }
+        }
+      },
+      CallExpression(node) {
+        if (!isMemberCall(node, "digest")) return;
+        const update = node.callee.object;
+        if (update.type !== import_utils68.AST_NODE_TYPES.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
+          return;
+        const create = update.callee.object;
+        if (create.type !== import_utils68.AST_NODE_TYPES.CallExpression || create.arguments.length !== 1 || create.arguments[0]?.type !== import_utils68.AST_NODE_TYPES.Literal || typeof create.arguments[0].value !== "string" || !isCreateHashCall(
+          create,
+          directBindings,
+          namespaceBindings,
+          resolve
+        ))
+          return;
+        context.report({ node, messageId: "preferNodeCryptoHash" });
+      }
+    };
+  }
+});
+function importedName5(node) {
+  return node.type === import_utils68.AST_NODE_TYPES.Identifier ? node.name : node.value;
+}
+function isMemberCall(node, name) {
+  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && memberName3(node.callee) === name;
+}
+function isCreateHashCall(node, directBindings, namespaceBindings, resolve) {
+  if (node.callee.type === import_utils68.AST_NODE_TYPES.Identifier) {
+    const variable2 = resolve(node.callee);
+    return variable2 !== null && directBindings.has(variable2);
+  }
+  if (node.callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || memberName3(node.callee) !== "createHash") {
+    return false;
+  }
+  if (isCryptoLoader(node.callee.object, resolve)) return true;
+  if (node.callee.object.type !== import_utils68.AST_NODE_TYPES.Identifier) return false;
+  const variable = resolve(node.callee.object);
+  return variable !== null && namespaceBindings.has(variable);
+}
+
+// src/rules/prefer-node-fs-promises.ts
+var import_utils69 = require("@typescript-eslint/utils");
+var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
+  summary: "Prefer promise-based Node.js filesystem APIs over synchronous calls in production modules.",
+  rationale: "Synchronous filesystem work blocks the event loop and can stall unrelated daemon, server, and worker tasks.",
+  remediation: "Import the promise API from node:fs/promises and await it; use FileHandle.sync only where a documented durability boundary requires it.",
+  category: "performance",
+  limitations: [
+    "Tests and generated files are excluded.",
+    "ESLint rule implementations under src/rules are excluded because visitor creation and execution are synchronous by contract.",
+    "Only statically identifiable node:fs loads are inspected; filesystem objects passed through arbitrary functions or assignments require type-aware analysis."
+  ],
+  examples: [
+    { id: "async-read", title: "Use the promise API", outcome: "no-match", files: [{ path: "src/store.ts", source: "import { readFile } from 'node:fs/promises'; export async function load(path: string) { return readFile(path, 'utf8'); }" }], focusPath: "src/store.ts", expectedCount: 0, public: true },
+    { id: "sync-read", title: "Do not block on a synchronous read", outcome: "match", files: [{ path: "src/store.ts", source: "import { readFileSync } from 'node:fs'; export function load(path: string) { return readFileSync(path, 'utf8'); }" }], focusPath: "src/store.ts", expectedCount: 1, public: true }
+  ]
+};
+function memberName4(node) {
+  if (!node.computed && node.property.type === import_utils69.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return null;
+}
+function unwrapAwait2(node) {
+  return node.type === import_utils69.AST_NODE_TYPES.AwaitExpression ? node.argument : node;
+}
+function isFsLoader(node) {
+  const expression = unwrapAwait2(node);
+  if (expression.type === import_utils69.AST_NODE_TYPES.ImportExpression) return isFsSpecifier(expression.source);
+  if (expression.type !== import_utils69.AST_NODE_TYPES.CallExpression || expression.arguments.length !== 1) return false;
+  const [argument] = expression.arguments;
+  if (argument === void 0 || argument.type === import_utils69.AST_NODE_TYPES.SpreadElement || !isFsSpecifier(argument)) return false;
+  if (expression.callee.type === import_utils69.AST_NODE_TYPES.Identifier) return expression.callee.name === "require";
+  return expression.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && expression.callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && expression.callee.object.name === "process" && memberName4(expression.callee) === "getBuiltinModule";
+}
+function isFsSpecifier(node) {
+  return node.type === import_utils69.AST_NODE_TYPES.Literal && (node.value === "node:fs" || node.value === "fs");
+}
+function propertyName4(node) {
+  if (!node.computed && node.key.type === import_utils69.AST_NODE_TYPES.Identifier) return node.key.name;
+  if (node.key.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.key.value === "string") return node.key.value;
+  return null;
+}
+var prefer_node_fs_promises_default = createRule({
+  name: "prefer-node-fs-promises",
+  documentation: PREFER_NODE_FS_PROMISES_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer promise-based Node.js filesystem APIs over synchronous calls in production modules." },
+    schema: [],
+    messages: {
+      preferAsyncFs: "Node filesystem API `{{name}}` is synchronous; use the promise API and await it."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const normalizedFilename = context.filename.replaceAll("\\", "/");
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text) || normalizedFilename.includes("src/rules/"))
+      return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "node:fs" && node.source.value !== "fs") return;
+        const synchronousImports = [];
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier) {
+            namespaces.add(specifier.local.name);
+            continue;
+          }
+          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier && specifier.imported.name.endsWith("Sync")) synchronousImports.push(specifier.imported.name);
+        }
+        if (synchronousImports.length > 0) {
+          context.report({
+            node,
+            messageId: "preferAsyncFs",
+            data: { name: synchronousImports.join(", ") }
+          });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init === null || !isFsLoader(node.init) && (node.init.type !== import_utils69.AST_NODE_TYPES.Identifier || !namespaces.has(node.init.name)))
+          return;
+        if (node.id.type === import_utils69.AST_NODE_TYPES.Identifier) {
+          namespaces.add(node.id.name);
+          return;
+        }
+        if (node.id.type !== import_utils69.AST_NODE_TYPES.ObjectPattern) return;
+        const synchronousImports = node.id.properties.flatMap((property) => {
+          if (property.type !== import_utils69.AST_NODE_TYPES.Property) return [];
+          const name = propertyName4(property);
+          return name?.endsWith("Sync") === true ? [name] : [];
+        });
+        if (synchronousImports.length > 0) {
+          context.report({
+            node,
+            messageId: "preferAsyncFs",
+            data: { name: synchronousImports.join(", ") }
+          });
+        }
+      },
+      MemberExpression(node) {
+        const name = memberName4(node);
+        if (name?.endsWith("Sync") !== true) return;
+        const object = unwrapAwait2(node.object);
+        if (object.type === import_utils69.AST_NODE_TYPES.Identifier && namespaces.has(object.name) || isFsLoader(object)) {
+          context.report({ node, messageId: "preferAsyncFs", data: { name } });
+        }
       }
     };
   }
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils67 = require("@typescript-eslint/utils");
+var import_utils70 = require("@typescript-eslint/utils");
 var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -11808,36 +12110,36 @@ var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   ]
 };
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
-function propertyName3(node) {
+function propertyName5(node) {
   const key = node.key;
   if (node.computed) return null;
-  if (key.type === import_utils67.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils67.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils70.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils70.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function isArrayType(node) {
-  if (node.type === import_utils67.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils67.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils67.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils70.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils70.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils70.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function nullableProperty(node) {
   if (node.optional) return null;
-  const name = propertyName3(node);
+  const name = propertyName5(node);
   const annotation = node.typeAnnotation?.typeAnnotation;
-  if (name === null || annotation?.type !== import_utils67.AST_NODE_TYPES.TSUnionType) return null;
+  if (name === null || annotation?.type !== import_utils70.AST_NODE_TYPES.TSUnionType) return null;
   const concrete = annotation.types.filter(
-    (member) => member.type !== import_utils67.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils67.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type !== import_utils70.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils70.AST_NODE_TYPES.TSUndefinedKeyword
   );
   if (concrete.length === 0 || !concrete.every(isArrayType)) return null;
-  const acceptsNull = annotation.types.some((member) => member.type === import_utils67.AST_NODE_TYPES.TSNullKeyword);
+  const acceptsNull = annotation.types.some((member) => member.type === import_utils70.AST_NODE_TYPES.TSNullKeyword);
   const acceptsUndefined = annotation.types.some(
-    (member) => member.type === import_utils67.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type === import_utils70.AST_NODE_TYPES.TSUndefinedKeyword
   );
   if (!acceptsNull && !acceptsUndefined) return null;
   return { name, node, acceptsNull, acceptsUndefined };
 }
 function shapeProperties(members) {
   return members.flatMap((member) => {
-    if (member.type !== import_utils67.AST_NODE_TYPES.TSPropertySignature) return [];
+    if (member.type !== import_utils70.AST_NODE_TYPES.TSPropertySignature) return [];
     const property = nullableProperty(member);
     return property === null ? [] : [property];
   });
@@ -11845,14 +12147,14 @@ function shapeProperties(members) {
 function typeIndex(program) {
   const index = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const exported = statement.type === import_utils67.AST_NODE_TYPES.ExportNamedDeclaration;
+    const exported = statement.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration;
     const declaration = exported ? statement.declaration : statement;
-    if (declaration?.type === import_utils67.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    if (declaration?.type === import_utils70.AST_NODE_TYPES.TSInterfaceDeclaration) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.body.body)
       });
-    } else if (declaration?.type === import_utils67.AST_NODE_TYPES.TSTypeAliasDeclaration && declaration.typeAnnotation.type === import_utils67.AST_NODE_TYPES.TSTypeLiteral) {
+    } else if (declaration?.type === import_utils70.AST_NODE_TYPES.TSTypeAliasDeclaration && declaration.typeAnnotation.type === import_utils70.AST_NODE_TYPES.TSTypeLiteral) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.typeAnnotation.members)
@@ -11862,42 +12164,42 @@ function typeIndex(program) {
   return index;
 }
 function emptyArray(node) {
-  return node.type === import_utils67.AST_NODE_TYPES.ArrayExpression && node.elements.length === 0;
+  return node.type === import_utils70.AST_NODE_TYPES.ArrayExpression && node.elements.length === 0;
 }
 function sameAccess(node, access) {
   if (access.kind === "identifier") {
-    return node.type === import_utils67.AST_NODE_TYPES.Identifier && node.name === access.name;
+    return node.type === import_utils70.AST_NODE_TYPES.Identifier && node.name === access.name;
   }
-  return node.type === import_utils67.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils67.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils67.AST_NODE_TYPES.Identifier && node.property.name === access.property;
+  return node.type === import_utils70.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && node.property.name === access.property;
 }
 function isNullGuard(node, access) {
-  if (node.type === import_utils67.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
-  if (node.type !== import_utils67.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
+  if (node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
+  if (node.type !== import_utils70.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
-  const nullish = (value) => value.type === import_utils67.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils67.AST_NODE_TYPES.Identifier && value.name === "undefined";
+  const nullish = (value) => value.type === import_utils70.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils70.AST_NODE_TYPES.Identifier && value.name === "undefined";
   return sameAccess(node.left, access) && nullish(node.right) || sameAccess(node.right, access) && nullish(node.left);
 }
 function isEmptyGuard(node, access) {
-  if (node.type === import_utils67.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
-  if (node.type !== import_utils67.AST_NODE_TYPES.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
+  if (node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
+  if (node.type !== import_utils70.AST_NODE_TYPES.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
     return false;
   }
-  const zero = (value) => value.type === import_utils67.AST_NODE_TYPES.Literal && value.value === 0;
+  const zero = (value) => value.type === import_utils70.AST_NODE_TYPES.Literal && value.value === 0;
   return memberLengthOf(node.left, access) && zero(node.right) || memberLengthOf(node.right, access) && zero(node.left);
 }
 function memberLengthOf(node, access) {
-  const target = node.type === import_utils67.AST_NODE_TYPES.ChainExpression ? node.expression : node;
-  return target.type === import_utils67.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils67.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+  const target = node.type === import_utils70.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+  return target.type === import_utils70.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils70.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
 }
 function optionalMemberLengthOf(node, access) {
-  return node.type === import_utils67.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils67.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
+  return node.type === import_utils70.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils70.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
-  if (fn.body.type !== import_utils67.AST_NODE_TYPES.BlockStatement) return false;
+  if (fn.body.type !== import_utils70.AST_NODE_TYPES.BlockStatement) return false;
   const first = fn.body.body[0];
-  if (first?.type !== import_utils67.AST_NODE_TYPES.IfStatement) return false;
-  const terminating = first.consequent.type === import_utils67.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils67.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils67.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils67.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils67.AST_NODE_TYPES.ThrowStatement);
+  if (first?.type !== import_utils70.AST_NODE_TYPES.IfStatement) return false;
+  const terminating = first.consequent.type === import_utils70.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils70.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils70.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils70.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils70.AST_NODE_TYPES.ThrowStatement);
   if (!terminating) return false;
   if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
   return contains(first.test, visitorKeys, (node) => isNullGuard(node, access)) && contains(first.test, visitorKeys, (node) => isEmptyGuard(node, access));
@@ -11915,29 +12217,29 @@ function contains(node, visitorKeys, predicate) {
 function belongsToFunction(node, fn) {
   let current = node;
   while (current !== void 0 && current !== fn) {
-    if (current !== node && (current.type === import_utils67.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils67.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils67.AST_NODE_TYPES.FunctionExpression)) return false;
+    if (current !== node && (current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression)) return false;
     current = current.parent;
   }
   return current === fn;
 }
 function directlyCoalesced(node) {
   const parent = node.parent;
-  return parent?.type === import_utils67.AST_NODE_TYPES.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
+  return parent?.type === import_utils70.AST_NODE_TYPES.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = import_utils67.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = import_utils67.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
     const parent = reference.identifier.parent;
-    if (parent?.type === import_utils67.AST_NODE_TYPES.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === import_utils67.AST_NODE_TYPES.Identifier && parent.property.name === property) return [parent];
+    if (parent?.type === import_utils70.AST_NODE_TYPES.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === import_utils70.AST_NODE_TYPES.Identifier && parent.property.name === property) return [parent];
     return [];
   });
   return accesses.length > 0 && accesses.every((access) => access !== null && directlyCoalesced(access));
@@ -11963,8 +12265,8 @@ var prefer_non_nullable_collection_default = createRule({
     let shapes = /* @__PURE__ */ new Map();
     const evidence = /* @__PURE__ */ new Map();
     function propertiesFor(annotation) {
-      if (annotation?.type === import_utils67.AST_NODE_TYPES.TSTypeLiteral) return shapeProperties(annotation.members);
-      if (annotation?.type === import_utils67.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils67.AST_NODE_TYPES.Identifier) {
+      if (annotation?.type === import_utils70.AST_NODE_TYPES.TSTypeLiteral) return shapeProperties(annotation.members);
+      if (annotation?.type === import_utils70.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils70.AST_NODE_TYPES.Identifier) {
         const shape = shapes.get(annotation.typeName.name);
         return shape?.exported === false ? shape.properties : [];
       }
@@ -11977,21 +12279,21 @@ var prefer_non_nullable_collection_default = createRule({
     }
     function checkFunction(fn) {
       for (const rawParameter of fn.params) {
-        const parameter = rawParameter.type === import_utils67.AST_NODE_TYPES.AssignmentPattern ? rawParameter.left : rawParameter;
-        if (parameter.type === import_utils67.AST_NODE_TYPES.ObjectPattern) {
+        const parameter = rawParameter.type === import_utils70.AST_NODE_TYPES.AssignmentPattern ? rawParameter.left : rawParameter;
+        if (parameter.type === import_utils70.AST_NODE_TYPES.ObjectPattern) {
           const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
           for (const property of properties2) {
             const bindingProperty = parameter.properties.find(
-              (entry) => entry.type === import_utils67.AST_NODE_TYPES.Property && !entry.computed && entry.key.type === import_utils67.AST_NODE_TYPES.Identifier && entry.key.name === property.name
+              (entry) => entry.type === import_utils70.AST_NODE_TYPES.Property && !entry.computed && entry.key.type === import_utils70.AST_NODE_TYPES.Identifier && entry.key.name === property.name
             );
             if (bindingProperty === void 0) continue;
             const value = bindingProperty.value;
-            const binding = value.type === import_utils67.AST_NODE_TYPES.AssignmentPattern ? value.left : value;
-            if (binding.type !== import_utils67.AST_NODE_TYPES.Identifier) {
+            const binding = value.type === import_utils70.AST_NODE_TYPES.AssignmentPattern ? value.left : value;
+            if (binding.type !== import_utils70.AST_NODE_TYPES.Identifier) {
               record(property, false);
               continue;
             }
-            if (value.type === import_utils67.AST_NODE_TYPES.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
+            if (value.type === import_utils70.AST_NODE_TYPES.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
               record(property, true);
               continue;
             }
@@ -12003,7 +12305,7 @@ var prefer_non_nullable_collection_default = createRule({
           }
           continue;
         }
-        if (parameter.type !== import_utils67.AST_NODE_TYPES.Identifier) continue;
+        if (parameter.type !== import_utils70.AST_NODE_TYPES.Identifier) continue;
         const properties = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
         for (const property of properties) {
           const access = {
@@ -12031,7 +12333,7 @@ var prefer_non_nullable_collection_default = createRule({
           context.report({
             node,
             messageId: "preferNonNullableCollection",
-            data: { name: propertyName3(node) ?? "collection" }
+            data: { name: propertyName5(node) ?? "collection" }
           });
         }
       }
@@ -12040,7 +12342,7 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-nullish-filter-predicate.ts
-var import_utils68 = require("@typescript-eslint/utils");
+var import_utils71 = require("@typescript-eslint/utils");
 var import_typescript = __toESM(require("typescript"), 1);
 var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   summary: "Prefer an explicit nullish predicate when `filter(Boolean)` removes only nullish values but does not narrow the result type.",
@@ -12084,7 +12386,7 @@ var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   ]
 };
 function isUnshadowedBoolean(node, context) {
-  const variable = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = import_utils71.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isBuiltinArrayFilter(node, services) {
@@ -12143,7 +12445,7 @@ function isProvablyTruthy(type, checker) {
 }
 function availableParameterName(node, context) {
   for (const name of ["value", "item", "element", "candidate"]) {
-    if (import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+    if (import_utils71.ASTUtils.findVariable(context.sourceCode.getScope(node), name) === null) return name;
   }
   return null;
 }
@@ -12165,7 +12467,7 @@ var prefer_nullish_filter_predicate_default = createRule({
     if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let services;
     try {
-      services = import_utils68.ESLintUtils.getParserServices(context);
+      services = import_utils71.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -12174,7 +12476,7 @@ var prefer_nullish_filter_predicate_default = createRule({
       CallExpression(node) {
         const callee = node.callee;
         const callback = node.arguments[0];
-        if (node.arguments.length !== 1 || callback?.type !== import_utils68.AST_NODE_TYPES.Identifier || callback.name !== "Boolean" || callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils68.AST_NODE_TYPES.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
+        if (node.arguments.length !== 1 || callback?.type !== import_utils71.AST_NODE_TYPES.Identifier || callback.name !== "Boolean" || callee.type !== import_utils71.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils71.AST_NODE_TYPES.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
         const elementType = arrayElementType(callee.object, services);
         const checker = services.program.getTypeChecker();
         if (elementType === null || !isNullishPlusTruthy(elementType, checker)) return;
@@ -12196,7 +12498,7 @@ var prefer_nullish_filter_predicate_default = createRule({
 });
 
 // src/rules/prefer-await-in-async-return.ts
-var import_utils69 = require("@typescript-eslint/utils");
+var import_utils72 = require("@typescript-eslint/utils");
 var ts4 = __toESM(require("typescript"), 1);
 var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
   summary: "Prefer explicit `await` when an async function directly returns one typed Promise `.then` transform.",
@@ -12238,10 +12540,10 @@ var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
 };
 function directAsyncReturnOwner(node) {
   const parent = node.parent;
-  if (parent.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
     return parent.async && !parent.generator ? parent : null;
   }
-  if (parent.type !== import_utils69.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
+  if (parent.type !== import_utils72.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
     return null;
   }
   let owner = parent.parent;
@@ -12251,15 +12553,15 @@ function directAsyncReturnOwner(node) {
   return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
-  return node.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils69.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils72.AST_NODE_TYPES.FunctionExpression;
 }
 function promiseThenReceiver(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils69.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
+  if (callee.type !== import_utils72.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils72.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
     return null;
   }
   const callback = node.arguments[0];
-  if (callback === void 0 || callback.type !== import_utils69.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils69.AST_NODE_TYPES.FunctionExpression) {
+  if (callback === void 0 || callback.type !== import_utils72.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils72.AST_NODE_TYPES.FunctionExpression) {
     return null;
   }
   return callee.object;
@@ -12300,32 +12602,32 @@ var prefer_await_in_async_return_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils69.ESLintUtils.getParserServices(context);
+      services = import_utils72.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = import_utils69.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
-      if (parent.type !== import_utils69.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils69.AST_NODE_TYPES.Identifier) return false;
-      const variable = import_utils69.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      if (parent.type !== import_utils72.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils72.AST_NODE_TYPES.Identifier) return false;
+      const variable = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
       return variable !== null && frameworkLoaders.has(variable);
     };
     return {
       ImportDeclaration(node) {
         if (node.source.value === "react") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils72.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils72.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
           }
         }
         if (node.source.value === "next/dynamic") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils72.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
           }
         }
       },
@@ -12343,7 +12645,7 @@ var prefer_await_in_async_return_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils70 = require("@typescript-eslint/utils");
+var import_utils73 = require("@typescript-eslint/utils");
 var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
   summary: "Require Zod (or similar) schema validation on `response.json()` / `JSON.parse()` results before property access.",
   rationale: "External JSON is untrusted at runtime even when its expected TypeScript shape is known statically.",
@@ -12355,12 +12657,12 @@ var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
     { id: "unvalidated-payload", title: "Do not trust response JSON directly", outcome: "match", files: [{ path: "src/client.ts", source: "async function load(response) { const body = await response.json(); return body.id; }" }], focusPath: "src/client.ts", expectedCount: 1, public: true }
   ]
 };
-var unwrap4 = (node) => {
+var unwrap5 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils70.AST_NODE_TYPES.TSAsExpression || current.type === import_utils70.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils70.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils70.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils73.AST_NODE_TYPES.TSAsExpression || current.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils70.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils73.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -12374,24 +12676,24 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
   "finally"
 ]);
 var isSchemaParseReference = (node) => {
-  const inner = unwrap4(node);
-  return inner !== null && inner.type === import_utils70.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils70.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  const inner = unwrap5(node);
+  return inner !== null && inner.type === import_utils73.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils73.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node, isKnownLocalText) => {
-  let current = unwrap4(node);
+  let current = unwrap5(node);
   if (current === null) return false;
-  if (current.type === import_utils70.AST_NODE_TYPES.AwaitExpression) {
-    current = unwrap4(current.argument);
+  if (current.type === import_utils73.AST_NODE_TYPES.AwaitExpression) {
+    current = unwrap5(current.argument);
   }
-  if (current === null || current.type !== import_utils70.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
     return false;
   }
-  const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression) {
+  const callee = unwrap5(current.callee);
+  if (callee === null || callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
-  const property = unwrap4(callee.property);
-  if (property === null || property.type !== import_utils70.AST_NODE_TYPES.Identifier) {
+  const property = unwrap5(callee.property);
+  if (property === null || property.type !== import_utils73.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -12400,18 +12702,18 @@ var isRawPayloadSource = (node, isKnownLocalText) => {
   if (PROMISE_CHAIN_METHODS.has(property.name)) {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
-  const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils70.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
+  const object = unwrap5(callee.object);
+  return property.name === "parse" && object !== null && object.type === import_utils73.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isDirectLocalFileRead = (node) => {
-  let current = unwrap4(node);
-  if (current?.type === import_utils70.AST_NODE_TYPES.AwaitExpression) {
-    current = unwrap4(current.argument);
+  let current = unwrap5(node);
+  if (current?.type === import_utils73.AST_NODE_TYPES.AwaitExpression) {
+    current = unwrap5(current.argument);
   }
-  if (current?.type !== import_utils70.AST_NODE_TYPES.CallExpression) return false;
-  const callee = unwrap4(current.callee);
-  const name = callee?.type === import_utils70.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils70.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils70.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+  if (current?.type !== import_utils73.AST_NODE_TYPES.CallExpression) return false;
+  const callee = unwrap5(current.callee);
+  const name = callee?.type === import_utils73.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils73.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils73.AST_NODE_TYPES.Identifier ? callee.property.name : null;
   return name !== null && FILE_READ_RE.test(name);
 };
 var isLocalFileRead = (node) => {
@@ -12438,15 +12740,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils70.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils73.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils70.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils73.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils70.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils73.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils70.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils73.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -12465,22 +12767,22 @@ var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
 var isValidationRead = (node) => {
   let current = node;
   let parent = current.parent;
-  while (parent !== null && parent !== void 0 && (parent.type === import_utils70.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils70.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils70.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils70.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils70.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils73.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils73.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils70.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils73.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils70.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils73.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils70.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils73.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "bigint",
@@ -12491,13 +12793,13 @@ var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "undefined"
 ]);
 var bindingValidationPolarity = (test, bindingName) => {
-  if (test.type === import_utils70.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils73.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = bindingValidationPolarity(test.argument, bindingName);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils70.AST_NODE_TYPES.BinaryExpression) {
-    const typeofName = (node) => node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils70.AST_NODE_TYPES.Identifier ? node.argument.name : null;
-    const literalType = (node) => node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+  if (test.type === import_utils73.AST_NODE_TYPES.BinaryExpression) {
+    const typeofName = (node) => node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils73.AST_NODE_TYPES.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === import_utils73.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
     const matches = typeofName(test.left) === bindingName && literalType(test.right) !== null || typeofName(test.right) === bindingName && literalType(test.left) !== null;
     if (!matches) return null;
     if (test.operator === "===" || test.operator === "==") {
@@ -12505,9 +12807,9 @@ var bindingValidationPolarity = (test, bindingName) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils70.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils70.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils73.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils73.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
-var plainMemberAccess = (node) => node.type === import_utils70.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.property.type === import_utils70.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
+var plainMemberAccess = (node) => node.type === import_utils73.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils73.AST_NODE_TYPES.Identifier && node.property.type === import_utils73.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
 var isSamePlainMember = (node, access) => {
   const candidate2 = plainMemberAccess(node);
   return candidate2 !== null && candidate2.object === access.object && candidate2.property === access.property;
@@ -12515,19 +12817,19 @@ var isSamePlainMember = (node, access) => {
 var nodeWithin2 = (node, container) => node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
 var isUseWithinValidatedBranch = (node, bindingName) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
@@ -12535,32 +12837,32 @@ var isUseWithinValidatedBranch = (node, bindingName) => {
 };
 var isMemberUseWithinValidatedBranch = (node, access) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
   return false;
 };
 var memberValidationPolarity = (test, access) => {
-  if (test.type === import_utils70.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils73.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = memberValidationPolarity(test.argument, access);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils70.AST_NODE_TYPES.BinaryExpression) {
-    const isMatchingTypeof = (node) => node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+  if (test.type === import_utils73.AST_NODE_TYPES.BinaryExpression) {
+    const isMatchingTypeof = (node) => node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
+    const isPrimitiveType = (node) => node.type === import_utils73.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
     if (!(isMatchingTypeof(test.left) && isPrimitiveType(test.right) || isMatchingTypeof(test.right) && isPrimitiveType(test.left))) {
       return null;
     }
@@ -12569,15 +12871,15 @@ var memberValidationPolarity = (test, access) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils70.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils70.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils73.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils73.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
 var isFullyValidatedExtractedBinding = (member, source, context) => {
   const isValidationReference = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if ((current.type === import_utils70.AST_NODE_TYPES.BinaryExpression || current.type === import_utils70.AST_NODE_TYPES.CallExpression || current.type === import_utils70.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+      if ((current.type === import_utils73.AST_NODE_TYPES.BinaryExpression || current.type === import_utils73.AST_NODE_TYPES.CallExpression || current.type === import_utils73.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
         return true;
       }
-      if (current.type !== import_utils70.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils70.AST_NODE_TYPES.MemberExpression && current.type !== import_utils70.AST_NODE_TYPES.CallExpression) {
+      if (current.type !== import_utils73.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils73.AST_NODE_TYPES.MemberExpression && current.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
         return false;
       }
     }
@@ -12585,7 +12887,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   };
   const isGuardedUse = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
+      if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12594,7 +12896,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
+      if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12603,14 +12905,14 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
         return false;
       }
     }
     return false;
   };
   const declarator = member.parent;
-  if (declarator.type !== import_utils70.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils70.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils70.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
+  if (declarator.type !== import_utils73.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils73.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils73.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
     return false;
   }
   const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
@@ -12618,7 +12920,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   let hasValueUse = false;
   for (const reference of extracted.references) {
     const identifier = reference.identifier;
-    if (identifier.type !== import_utils70.AST_NODE_TYPES.Identifier) return false;
+    if (identifier.type !== import_utils73.AST_NODE_TYPES.Identifier) return false;
     if (nodeWithin2(identifier, declarator)) continue;
     if (isValidationReference(identifier)) continue;
     hasValueUse = true;
@@ -12631,17 +12933,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils70.AST_NODE_TYPES.UnaryExpression:
-      case import_utils70.AST_NODE_TYPES.LogicalExpression:
-      case import_utils70.AST_NODE_TYPES.ChainExpression:
+      case import_utils73.AST_NODE_TYPES.UnaryExpression:
+      case import_utils73.AST_NODE_TYPES.LogicalExpression:
+      case import_utils73.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils70.AST_NODE_TYPES.IfStatement:
-      case import_utils70.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils70.AST_NODE_TYPES.WhileStatement:
-      case import_utils70.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils70.AST_NODE_TYPES.ForStatement:
+      case import_utils73.AST_NODE_TYPES.IfStatement:
+      case import_utils73.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils73.AST_NODE_TYPES.WhileStatement:
+      case import_utils73.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils73.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -12650,8 +12952,8 @@ var isGuardTestPosition = (node) => {
   return false;
 };
 var unvalidatedVariableRef = (node, scope, tracked) => {
-  const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== import_utils70.AST_NODE_TYPES.Identifier) {
+  const unwrapped = unwrap5(node);
+  if (unwrapped === null || unwrapped.type !== import_utils73.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -12679,8 +12981,8 @@ var prefer_schema_for_api_payload_default = createRule({
     const aliasGroups = /* @__PURE__ */ new Map();
     const localFileTextVariables = /* @__PURE__ */ new Set();
     const localFileTextRef = (node, scope) => {
-      const unwrapped = unwrap4(node);
-      if (unwrapped?.type !== import_utils70.AST_NODE_TYPES.Identifier) return null;
+      const unwrapped = unwrap5(node);
+      if (unwrapped?.type !== import_utils73.AST_NODE_TYPES.Identifier) return null;
       const variable = findVariable2(scope, unwrapped.name);
       return variable !== null && localFileTextVariables.has(variable) ? variable : null;
     };
@@ -12749,7 +13051,7 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils70.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils73.AST_NODE_TYPES.Identifier) {
           const variable = context.sourceCode.getDeclaredVariables(node)[0];
           if (variable !== void 0) {
             updateLocalFileText(variable, node.init, scope);
@@ -12757,7 +13059,7 @@ var prefer_schema_for_api_payload_default = createRule({
           trackInitializer(node, scope);
           return;
         }
-        if (node.id.type === import_utils70.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils70.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils73.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils73.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.init,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -12774,7 +13076,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils70.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils73.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           const isLocalText = (candidate2) => localFileTextRef(candidate2, scope) !== null;
@@ -12788,7 +13090,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils70.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils70.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils73.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils73.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.right,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -12808,15 +13110,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils70.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils73.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils70.AST_NODE_TYPES.SpreadElement) continue;
-          const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils70.AST_NODE_TYPES.Identifier) {
+          if (arg.type === import_utils73.AST_NODE_TYPES.SpreadElement) continue;
+          const unwrapped = unwrap5(arg);
+          if (unwrapped === null || unwrapped.type !== import_utils73.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -12827,20 +13129,20 @@ var prefer_schema_for_api_payload_default = createRule({
         if (isInsideAssertion(node)) return;
         if (isValidationRead(node)) return;
         const scope = context.sourceCode.getScope(node);
-        const obj = unwrap4(node.object);
+        const obj = unwrap5(node.object);
         if (isRawPayloadSource(
           obj,
           (candidate2) => localFileTextRef(candidate2, scope) !== null
         )) {
           const parent = node.parent;
-          if (parent.type === import_utils70.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils73.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils73.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        const variable = obj?.type === import_utils70.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
-        if (variable !== null && obj?.type === import_utils70.AST_NODE_TYPES.Identifier) {
+        const variable = obj?.type === import_utils73.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null && obj?.type === import_utils73.AST_NODE_TYPES.Identifier) {
           if (isUseWithinValidatedBranch(node, obj.name)) {
             return;
           }
@@ -12859,8 +13161,142 @@ var prefer_schema_for_api_payload_default = createRule({
   }
 });
 
+// src/rules/prefer-shared-zod-enum.ts
+var import_utils74 = require("@typescript-eslint/utils");
+var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
+  summary: "Give literal Zod enum domains one reusable module-level schema.",
+  rationale: "Inline or repeated literal domains hide a reusable contract and allow equivalent fields to drift independently.",
+  remediation: "Declare a module-level named Zod enum schema and reuse it at each field or contract site.",
+  category: "maintainability",
+  limitations: ["Only direct z.enum calls with string-literal arrays are inspected; computed domains require review."],
+  examples: [
+    { id: "shared-provider", title: "Reuse a named enum schema", outcome: "no-match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const ProviderSchema = z.enum(['agy', 'claude', 'sol']); const JobSchema = z.object({ provider: ProviderSchema }); const StatusSchema = z.object({ provider: ProviderSchema.optional() });" }], focusPath: "src/provider.ts", expectedCount: 0, public: true },
+    { id: "inline-provider", title: "Do not inline enum domains in object fields", outcome: "match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const JobSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']) });" }], focusPath: "src/provider.ts", expectedCount: 1, public: true }
+  ]
+};
+function literalDomain(node) {
+  const [argument] = node.arguments;
+  if (argument?.type !== import_utils74.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2) return null;
+  const values = [];
+  for (const element of argument.elements) {
+    if (element?.type !== import_utils74.AST_NODE_TYPES.Literal || typeof element.value !== "string") return null;
+    values.push(element.value);
+  }
+  return values;
+}
+function isModuleLevelNamedSchema(node) {
+  let current = node;
+  while (current.parent?.type === import_utils74.AST_NODE_TYPES.MemberExpression && current.parent.object === current) {
+    current = current.parent;
+    if (current.parent?.type === import_utils74.AST_NODE_TYPES.CallExpression && current.parent.callee === current) current = current.parent;
+  }
+  const declarator = current.parent;
+  if (declarator?.type !== import_utils74.AST_NODE_TYPES.VariableDeclarator || declarator.init !== current || declarator.id.type !== import_utils74.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils74.AST_NODE_TYPES.VariableDeclaration) return false;
+  const declarationParent = declarator.parent.parent;
+  return declarationParent.type === import_utils74.AST_NODE_TYPES.Program || declarationParent.type === import_utils74.AST_NODE_TYPES.ExportNamedDeclaration && declarationParent.parent.type === import_utils74.AST_NODE_TYPES.Program;
+}
+var prefer_shared_zod_enum_default = createRule({
+  name: "prefer-shared-zod-enum",
+  documentation: PREFER_SHARED_ZOD_ENUM_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Give literal Zod enum domains one reusable module-level schema." },
+    schema: [],
+    messages: {
+      shareEnumDomain: "Extract this literal Zod enum to one module-level named schema and reuse it."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    const zodBindings = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils74.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils74.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") zodBindings.add(specifier.local.name);
+        }
+      },
+      CallExpression(node) {
+        if (node.callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils74.AST_NODE_TYPES.Identifier || !zodBindings.has(node.callee.object.name) || node.callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier || node.callee.property.name !== "enum") return;
+        const domain = literalDomain(node);
+        if (domain === null) return;
+        const key = JSON.stringify(domain);
+        const inline = !isModuleLevelNamedSchema(node);
+        if (inline || seen.has(key))
+          context.report({ node, messageId: "shareEnumDomain" });
+        else seen.add(key);
+      }
+    };
+  }
+});
+
+// src/rules/prefer-switch-for-repeated-equality.ts
+var import_utils75 = require("@typescript-eslint/utils");
+var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
+  summary: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
+  rationale: "A switch makes finite dispatch cases visually uniform and easier to extend without duplicating the discriminant.",
+  remediation: "Replace three or more strict-equality branches over the same discriminant with a switch; keep if statements for ranges, guards, and heterogeneous predicates.",
+  category: "maintainability",
+  limitations: [
+    "Only direct if/else-if chains with at least three strict-equality tests are reported.",
+    "Case values may be literals, enum-like member references, or upper-case named constants; dynamic expressions are excluded.",
+    "The rule deliberately ignores compound predicates, loose equality, ranges, and chains that compare different discriminants."
+  ],
+  examples: [
+    { id: "switch-dispatch", title: "Make finite dispatch explicit", outcome: "no-match", files: [{ path: "src/render.ts", source: "switch (kind) { case 'a': return a(); case 'b': return b(); case 'c': return c(); default: return fallback(); }" }], focusPath: "src/render.ts", expectedCount: 0, public: true },
+    { id: "repeated-equality", title: "Avoid repeating the discriminant", outcome: "match", files: [{ path: "src/render.ts", source: "if (kind === 'a') return a(); else if (kind === 'b') return b(); else if (kind === 'c') return c();" }], focusPath: "src/render.ts", expectedCount: 1, public: true }
+  ]
+};
+function discriminantText(sourceCode, test) {
+  if (test.type !== import_utils75.AST_NODE_TYPES.BinaryExpression || test.operator !== "===") return null;
+  const leftIsCase = isCaseValue(test.left);
+  const rightIsCase = isCaseValue(test.right);
+  if (leftIsCase === rightIsCase) return null;
+  return sourceCode.getText(leftIsCase ? test.right : test.left);
+}
+function isCaseValue(node) {
+  if (node.type === import_utils75.AST_NODE_TYPES.Literal) return true;
+  if (node.type === import_utils75.AST_NODE_TYPES.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
+  if (node.type !== import_utils75.AST_NODE_TYPES.MemberExpression || node.computed) return false;
+  return node.property.type === import_utils75.AST_NODE_TYPES.Identifier && (node.object.type === import_utils75.AST_NODE_TYPES.Identifier || isCaseValue(node.object));
+}
+var prefer_switch_for_repeated_equality_default = createRule({
+  name: "prefer-switch-for-repeated-equality",
+  documentation: PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer switch over long if/else-if chains that compare one value for strict equality." },
+    schema: [],
+    messages: {
+      preferSwitch: "This if/else-if chain repeatedly compares `{{discriminant}}`; use a switch for the finite cases."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      IfStatement(node) {
+        if (node.parent.type === import_utils75.AST_NODE_TYPES.IfStatement && node.parent.alternate === node) return;
+        const first = discriminantText(context.sourceCode, node.test);
+        if (first === null) return;
+        let count = 1;
+        let current = node.alternate;
+        while (current?.type === import_utils75.AST_NODE_TYPES.IfStatement) {
+          if (discriminantText(context.sourceCode, current.test) !== first) return;
+          count += 1;
+          current = current.alternate;
+        }
+        if (count >= 3) {
+          context.report({ node, messageId: "preferSwitch", data: { discriminant: first } });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/prefer-semantic-colors.ts
-var import_utils71 = require("@typescript-eslint/utils");
+var import_utils76 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -12972,7 +13408,7 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils71.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils76.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -12982,8 +13418,8 @@ var isInsideSvg = (node) => {
 };
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils71.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils71.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils71.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils76.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils76.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils76.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -13009,7 +13445,7 @@ function isSvgLikeElementName(name) {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils71.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils71.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils71.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils71.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils76.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils76.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils76.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils76.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -13143,12 +13579,12 @@ var expandWorkspaceGlob = (root, glob) => {
   return (0, import_fs.readdirSync)(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => (0, import_path.join)(parent, entry.name));
 };
 var propName = (key) => {
-  if (key.type === import_utils71.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils71.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils76.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils76.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== import_utils71.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils71.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils71.AST_NODE_TYPES.ExportAllDeclaration) {
+  if (statement.type !== import_utils76.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils76.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils76.AST_NODE_TYPES.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -13185,43 +13621,43 @@ var prefer_semantic_colors_default = createRule({
     }
     let importsEmailOrPdfRenderer = false;
     const pendingReports = [];
-    const report = (node, messageId, data) => {
+    const report2 = (node, messageId, data) => {
       pendingReports.push({ node, messageId, data });
     };
     const reportClasses = (value, node) => {
       for (const token of classTokens(value)) {
         const base = tailwindBase(token);
         if (RAW_PALETTE_RE.test(base)) {
-          report(node, "rawPalette", { class: token });
+          report2(node, "rawPalette", { class: token });
         } else if (ARBITRARY_COLOR_RE.test(base) && !CSS_VAR_REFERENCE_RE.test(base)) {
-          report(node, "arbitraryColor", { class: token });
+          report2(node, "arbitraryColor", { class: token });
         }
       }
     };
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils71.AST_NODE_TYPES.Literal:
+        case import_utils76.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils71.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils76.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils71.AST_NODE_TYPES.ArrayExpression:
+        case import_utils76.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils71.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils76.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils71.AST_NODE_TYPES.ObjectExpression:
+        case import_utils76.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils71.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils76.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils71.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils76.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils71.AST_NODE_TYPES.LogicalExpression:
+        case import_utils76.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -13229,32 +13665,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
-        report(node, "inlineColor", { value: node.value });
+      if (node.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+        report2(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils71.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils71.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils71.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils76.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils76.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils76.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === import_utils76.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils76.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils71.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils76.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils71.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils76.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -13264,9 +13700,9 @@ var prefer_semantic_colors_default = createRule({
       },
       // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils71.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils76.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils71.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils76.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -13280,7 +13716,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -13293,7 +13729,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils72 = require("@typescript-eslint/utils");
+var import_utils77 = require("@typescript-eslint/utils");
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
   summary: "Prefer Next.js Server Actions over /api/* mutations.",
   rationale: "Server Actions preserve typed application calls and avoid an internal JSON request-response boundary.",
@@ -13482,7 +13918,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils73 = require("@typescript-eslint/utils");
+var import_utils78 = require("@typescript-eslint/utils");
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
@@ -13507,11 +13943,11 @@ var PREFER_WHOLE_OBJECT_ASSERTION_DOCUMENTATION = {
 };
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils73.AST_NODE_TYPES.Literal:
+    case import_utils78.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils73.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils78.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils73.AST_NODE_TYPES.UnaryExpression:
+    case import_utils78.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -13519,15 +13955,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils73.AST_NODE_TYPES.Identifier:
-    case import_utils73.AST_NODE_TYPES.ThisExpression:
+    case import_utils78.AST_NODE_TYPES.Identifier:
+    case import_utils78.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils73.AST_NODE_TYPES.MemberExpression:
+    case import_utils78.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils73.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils78.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -13535,7 +13971,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils73.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils78.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -13543,8 +13979,8 @@ function literalIndex(node) {
 function propertyAccess(node) {
   const path = [];
   let current = node;
-  while (current.type === import_utils73.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
-    if (current.property.type !== import_utils73.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+  while (current.type === import_utils78.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== import_utils78.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
     path.unshift(current.property.name);
     current = current.object;
   }
@@ -13572,24 +14008,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils73.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils78.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils78.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils73.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils78.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils78.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils73.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils78.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils78.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== import_utils73.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils78.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -13618,7 +14054,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils73.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils78.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -13759,7 +14195,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-var import_utils74 = require("@typescript-eslint/utils");
+var import_utils79 = require("@typescript-eslint/utils");
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -13780,67 +14216,67 @@ var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
 function staticMemberName5(node) {
-  if (!node.computed && node.property.type === import_utils74.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils74.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils79.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils79.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
-function importedName5(identifier, context, modules) {
-  const variable = import_utils74.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+function importedName6(identifier, context, modules) {
+  const variable = import_utils79.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
-    if (definition.node.type !== import_utils74.AST_NODE_TYPES.ImportSpecifier) continue;
+    if (definition.node.type !== import_utils79.AST_NODE_TYPES.ImportSpecifier) continue;
     const declaration = definition.node.parent;
-    if (declaration.type !== import_utils74.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
+    if (declaration.type !== import_utils79.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     const imported = definition.node.imported;
-    return imported.type === import_utils74.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
+    return imported.type === import_utils79.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
   }
   return null;
 }
 function isDirectTestCallback2(node, context) {
-  if (node.type !== import_utils74.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils74.AST_NODE_TYPES.FunctionExpression) return false;
+  if (node.type !== import_utils79.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils79.AST_NODE_TYPES.FunctionExpression) return false;
   const call = node.parent;
-  if (call?.type !== import_utils74.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
+  if (call?.type !== import_utils79.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
   const root = testRoot2(call.callee);
-  return root !== null && TEST_NAMES2.has(importedName5(root, context, TEST_MODULES4) ?? "");
+  return root !== null && TEST_NAMES2.has(importedName6(root, context, TEST_MODULES4) ?? "");
 }
 function testRoot2(callee) {
-  if (callee.type === import_utils74.AST_NODE_TYPES.Identifier) return callee;
-  if (callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression) return null;
+  if (callee.type === import_utils79.AST_NODE_TYPES.Identifier) return callee;
+  if (callee.type !== import_utils79.AST_NODE_TYPES.MemberExpression) return null;
   const modifier = staticMemberName5(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
-  if (node.type === import_utils74.AST_NODE_TYPES.TSAsExpression || node.type === import_utils74.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils74.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils74.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
+  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
   switch (node.type) {
-    case import_utils74.AST_NODE_TYPES.Literal:
+    case import_utils79.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils74.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils79.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils74.AST_NODE_TYPES.UnaryExpression:
+    case import_utils79.AST_NODE_TYPES.UnaryExpression:
       return (node.operator === "+" || node.operator === "-") && isStatic(node.argument);
-    case import_utils74.AST_NODE_TYPES.ArrayExpression:
-      return node.elements.every((item) => item !== null && item.type !== import_utils74.AST_NODE_TYPES.SpreadElement && isStatic(item));
-    case import_utils74.AST_NODE_TYPES.ObjectExpression:
-      return node.properties.every((property) => property.type === import_utils74.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils74.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
+    case import_utils79.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.every((item) => item !== null && item.type !== import_utils79.AST_NODE_TYPES.SpreadElement && isStatic(item));
+    case import_utils79.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.every((property) => property.type === import_utils79.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils79.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
     default:
       return false;
   }
 }
 function staticShape(node) {
-  if (node.type === import_utils74.AST_NODE_TYPES.TSAsExpression || node.type === import_utils74.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils74.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils74.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
+  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
   switch (node.type) {
-    case import_utils74.AST_NODE_TYPES.Literal:
+    case import_utils79.AST_NODE_TYPES.Literal:
       return `literal:${typeof node.value}`;
-    case import_utils74.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils79.AST_NODE_TYPES.TemplateLiteral:
       return "template";
-    case import_utils74.AST_NODE_TYPES.UnaryExpression:
+    case import_utils79.AST_NODE_TYPES.UnaryExpression:
       return `unary:${node.operator}:${staticShape(node.argument)}`;
-    case import_utils74.AST_NODE_TYPES.ArrayExpression:
-      return `array(${node.elements.map((item) => item === null || item.type === import_utils74.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
-    case import_utils74.AST_NODE_TYPES.ObjectExpression:
+    case import_utils79.AST_NODE_TYPES.ArrayExpression:
+      return `array(${node.elements.map((item) => item === null || item.type === import_utils79.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
+    case import_utils79.AST_NODE_TYPES.ObjectExpression:
       return `object(${node.properties.map((property) => {
-        if (property.type !== import_utils74.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils74.AST_NODE_TYPES.AssignmentPattern) return "invalid";
-        const key = property.key.type === import_utils74.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
+        if (property.type !== import_utils79.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils79.AST_NODE_TYPES.AssignmentPattern) return "invalid";
+        const key = property.key.type === import_utils79.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
         return `${key}:${staticShape(property.value)}`;
       }).join(",")})`;
     default:
@@ -13848,16 +14284,16 @@ function staticShape(node) {
   }
 }
 function assertionShape(statement, context) {
-  if (statement.type !== import_utils74.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils74.AST_NODE_TYPES.CallExpression) return null;
+  if (statement.type !== import_utils79.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils79.AST_NODE_TYPES.CallExpression) return null;
   const matcherCall = statement.expression;
-  if (matcherCall.callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
+  if (matcherCall.callee.type !== import_utils79.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils79.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
   const matcher = matcherCall.callee.property.name;
   if (SNAPSHOT_MATCHERS.test(matcher)) return null;
   const chain = expectCallFromMatcher(matcherCall.callee);
-  if (chain === null || chain.call.callee.type !== import_utils74.AST_NODE_TYPES.Identifier || importedName5(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
+  if (chain === null || chain.call.callee.type !== import_utils79.AST_NODE_TYPES.Identifier || importedName6(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
   const observed = chain.call.arguments[0];
   const expected = matcherCall.arguments[0];
-  if (observed?.type !== import_utils74.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils74.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils74.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils74.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
+  if (observed?.type !== import_utils79.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils79.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils79.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils79.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
   const skeleton = `${observed.callee.name}/${observed.arguments.map((item) => staticShape(item)).join(",")}/${chain.modifiers.join(".")}/${matcher}/${staticShape(expected)}`;
   const values = [...observed.arguments, expected].map((item) => context.sourceCode.getText(item)).join("\0");
   return { statement, skeleton, values };
@@ -13865,13 +14301,13 @@ function assertionShape(statement, context) {
 function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
-  while (receiver.type === import_utils74.AST_NODE_TYPES.MemberExpression) {
+  while (receiver.type === import_utils79.AST_NODE_TYPES.MemberExpression) {
     const modifier = staticMemberName5(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
   }
-  return receiver.type === import_utils74.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
+  return receiver.type === import_utils79.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
 }
 var repeated_static_call_cases_default = createRule({
   name: "repeated-static-call-cases",
@@ -13891,7 +14327,7 @@ var repeated_static_call_cases_default = createRule({
     return {
       "CallExpression > ArrowFunctionExpression, CallExpression > FunctionExpression"(node) {
         const call = node.parent;
-        if (call?.type === import_utils74.AST_NODE_TYPES.CallExpression) {
+        if (call?.type === import_utils79.AST_NODE_TYPES.CallExpression) {
           const duplicate = duplicateTestBodyCandidate(call, sourceCode);
           if (duplicate !== null && duplicate.body === node) {
             const groups = duplicateGroups.get(duplicate.container) ?? /* @__PURE__ */ new Map();
@@ -13901,7 +14337,7 @@ var repeated_static_call_cases_default = createRule({
             duplicateGroups.set(duplicate.container, groups);
           }
         }
-        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils74.AST_NODE_TYPES.BlockStatement) return;
+        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils79.AST_NODE_TYPES.BlockStatement) return;
         let run = [];
         const flush = () => {
           if (run.length >= MIN_CASES2 && new Set(run.map((item) => item.values)).size > 1) {
@@ -13942,7 +14378,7 @@ var repeated_static_call_cases_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils75 = require("@typescript-eslint/utils");
+var import_utils80 = require("@typescript-eslint/utils");
 var PREFER_ZOD_INFER_DOCUMENTATION = {
   summary: "Derive a type from its Zod schema with `z.infer` instead of hand-writing a twin declaration beside it.",
   rationale: "A derived type stays synchronized when the runtime schema changes.",
@@ -13995,47 +14431,47 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils75.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils75.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils75.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils75.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils75.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils75.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils75.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils75.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils75.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils75.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils75.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils75.AST_NODE_TYPES.TSArrayType, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils75.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils75.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils75.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils75.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils75.AST_NODE_TYPES.TSIntersectionType, import_utils75.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils80.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils80.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils80.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils80.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils80.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils80.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils80.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils80.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils80.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils80.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils80.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils80.AST_NODE_TYPES.TSArrayType, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils80.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils80.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils80.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils80.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils80.AST_NODE_TYPES.TSIntersectionType, import_utils80.AST_NODE_TYPES.TSTypeReference]
 };
 function primitiveLiteralKey(node) {
-  if (node.type !== import_utils75.AST_NODE_TYPES.Literal) {
+  if (node.type !== import_utils80.AST_NODE_TYPES.Literal) {
     return null;
   }
   if (node.value === null) {
@@ -14067,13 +14503,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "literal") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils75.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils80.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map(
-          (element) => element === null || element.type === import_utils75.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
+          (element) => element === null || element.type === import_utils80.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
         )
       );
     }
@@ -14081,13 +14517,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "enum") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils75.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils80.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map((element) => {
-          if (element === null || element.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
+          if (element === null || element.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
             return null;
           }
           const key = primitiveLiteralKey(element);
@@ -14095,10 +14531,10 @@ function staticZodDomain(leaf, call) {
         })
       );
     }
-    if (argument.type === import_utils75.AST_NODE_TYPES.ObjectExpression) {
+    if (argument.type === import_utils80.AST_NODE_TYPES.ObjectExpression) {
       return exactDomain(
         argument.properties.map((property) => {
-          if (property.type !== import_utils75.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
+          if (property.type !== import_utils80.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
             return null;
           }
           const key = primitiveLiteralKey(property.value);
@@ -14125,15 +14561,15 @@ function sameDomain(left, right) {
   return true;
 }
 function isExportedDeclaration(node) {
-  return node.parent?.type === import_utils75.AST_NODE_TYPES.ExportNamedDeclaration;
+  return node.parent?.type === import_utils80.AST_NODE_TYPES.ExportNamedDeclaration;
 }
 function isModuleLevelConst(node) {
   const declaration = node.parent;
-  if (declaration.type !== import_utils75.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== import_utils80.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === import_utils75.AST_NODE_TYPES.Program || container.type === import_utils75.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils75.AST_NODE_TYPES.Program;
+  return container.type === import_utils80.AST_NODE_TYPES.Program || container.type === import_utils80.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils80.AST_NODE_TYPES.Program;
 }
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -14142,20 +14578,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils75.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils80.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils75.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils80.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils75.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils80.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -14189,18 +14625,18 @@ function leafAgrees(field, annotation) {
     return null;
   }
   if (leaf === "date") {
-    return core.type === import_utils75.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils75.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
+    return core.type === import_utils80.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils80.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
   }
   return expected.includes(core.type);
 }
 function typeLiteralDomain(annotation) {
-  const members = annotation.type === import_utils75.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
+  const members = annotation.type === import_utils80.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
   const keys = [];
   for (const member of members) {
-    if (member.type === import_utils75.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils80.AST_NODE_TYPES.TSNullKeyword) {
       continue;
     }
-    if (member.type !== import_utils75.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils80.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     keys.push(primitiveLiteralKey(member.literal));
@@ -14208,11 +14644,11 @@ function typeLiteralDomain(annotation) {
   return exactDomain(keys);
 }
 function staticStringUnionDomain(node) {
-  if (node.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
     return null;
   }
   const keys = node.types.map((member) => {
-    if (member.type !== import_utils75.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils80.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     const key = primitiveLiteralKey(member.literal);
@@ -14280,14 +14716,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils75.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils80.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils75.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils75.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils80.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils80.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils75.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils80.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -14296,14 +14732,14 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName2(call) {
       const callee = call.callee;
-      return callee.type === import_utils75.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils75.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils80.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils80.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
       }
       for (const specifier of node.specifiers) {
-        if (specifier.type === import_utils75.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils75.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils75.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils75.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+        if (specifier.type === import_utils80.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils80.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils80.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils80.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
           zodNamespaces.add(specifier.local.name);
         }
       }
@@ -14313,13 +14749,13 @@ var prefer_zod_infer_default = createRule({
       let current = node;
       let leaf = null;
       let leafCall = null;
-      while (current.type === import_utils75.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils80.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils75.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils75.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils80.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils80.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils75.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils80.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           leafCall = current;
           break;
@@ -14350,30 +14786,30 @@ var prefer_zod_infer_default = createRule({
       return domain instanceof Set && domain.size >= 2 ? domain : null;
     }
     function inferredSchemaName(node) {
-      if (node.type !== import_utils75.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils75.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils75.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
+      if (node.type !== import_utils80.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils80.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils80.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
         return null;
       }
       const arguments_ = node.typeArguments?.params ?? [];
       const [argument] = arguments_;
-      return arguments_.length === 1 && argument?.type === import_utils75.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils75.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
+      return arguments_.length === 1 && argument?.type === import_utils80.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils80.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
     }
     function recordLiteralUnions(members, owner, ownerName, exported) {
       for (const member of members) {
-        if (member.type !== import_utils75.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
+        if (member.type !== import_utils80.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
           continue;
         }
         const key = member.key;
-        const propertyName5 = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
-        if (propertyName5 === null) {
+        const propertyName7 = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        if (propertyName7 === null) {
           continue;
         }
-        const propertyTokens = nameTokens(propertyName5);
+        const propertyTokens = nameTokens(propertyName7);
         if (propertyTokens.length < 2) {
           continue;
         }
         const annotation = member.typeAnnotation.typeAnnotation;
         const domain = staticStringUnionDomain(annotation);
-        if (domain === null || annotation.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
+        if (domain === null || annotation.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
           continue;
         }
         literalUnionOccurrences.push({
@@ -14382,7 +14818,7 @@ var prefer_zod_infer_default = createRule({
           node: annotation,
           owner,
           ownerName,
-          propertyName: propertyName5,
+          propertyName: propertyName7,
           propertyTokens
         });
       }
@@ -14404,16 +14840,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils75.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils80.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils75.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils80.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14424,11 +14860,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils75.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils80.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14443,8 +14879,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils75.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils75.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils80.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils80.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -14452,11 +14888,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils75.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils80.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils75.AST_NODE_TYPES.TSUnionType || node.type === import_utils75.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils80.AST_NODE_TYPES.TSUnionType || node.type === import_utils80.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -14500,7 +14936,7 @@ var prefer_zod_infer_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          if (statement.type === import_utils75.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type === import_utils80.AST_NODE_TYPES.ImportDeclaration) {
             recordZodImport(statement);
           }
         }
@@ -14509,7 +14945,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils75.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils80.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -14526,14 +14962,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils75.AST_NODE_TYPES.Identifier && node.property.type === import_utils75.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils80.AST_NODE_TYPES.Identifier && node.property.type === import_utils80.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils75.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils75.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils75.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils80.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils80.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils80.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -14565,7 +15001,7 @@ var prefer_zod_infer_default = createRule({
             typeName: node.id.name
           });
         }
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils75.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils80.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -14664,7 +15100,7 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils76 = require("@typescript-eslint/utils");
+var import_utils81 = require("@typescript-eslint/utils");
 var import_typescript2 = __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.",
@@ -14677,14 +15113,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils76.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils76.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils81.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils81.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils76.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils76.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils81.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils81.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils76.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils81.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -14700,7 +15136,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_utils76.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils81.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -14756,7 +15192,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils76.ESLintUtils.getParserServices(context);
+      services = import_utils81.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -14783,7 +15219,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils77 = require("@typescript-eslint/utils");
+var import_utils82 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -14809,14 +15245,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils77.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils82.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils77.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils82.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils77.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils77.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils82.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils82.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -14826,7 +15262,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === import_utils77.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils77.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils77.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils77.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils82.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils82.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils82.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -14864,30 +15300,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils77.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils82.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils77.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils82.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils77.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils77.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils77.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils82.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils77.ASTUtils.findVariable(
+      const variable = import_utils82.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_utils77.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils82.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
         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_utils77.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils77.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils77.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils82.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils82.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils82.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -14902,7 +15338,7 @@ var require_fetch_timeout_default = createRule({
         if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils77.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils82.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -14910,8 +15346,141 @@ var require_fetch_timeout_default = createRule({
   }
 });
 
+// src/rules/require-interface-for-exported-class.ts
+var import_utils83 = require("@typescript-eslint/utils");
+var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
+  summary: "Require exported concrete classes with public behavior to declare a contract.",
+  rationale: "Consumers coupled only to a concrete class cannot substitute implementations or state the supported public capability independently of implementation details.",
+  remediation: "Declare a focused interface and add an implements clause, or inherit from an intentional base contract.",
+  category: "architecture",
+  limitations: [
+    "The warning-stage rule checks module-level class declarations and direct class-expression values exported directly, through local export specifiers, or through a default identifier; re-exports and expressions wrapped in other calls require review.",
+    "An extends clause satisfies the contract only when its target is a locally declared abstract class; imported base-class contracts require an explicit implements clause.",
+    "Static factories and data-only classes without public instance methods are outside the contract requirement."
+  ],
+  examples: [
+    {
+      id: "implemented-store-contract",
+      title: "Export behavior through a focused contract",
+      outcome: "no-match",
+      files: [
+        {
+          path: "src/artifact-store.ts",
+          source: "export interface ArtifactStorage { read(id: string): Promise<Uint8Array>; } export class ArtifactStore implements ArtifactStorage { async read(id: string) { return new Uint8Array(); } }"
+        }
+      ],
+      focusPath: "src/artifact-store.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "concrete-only-store",
+      title: "Do not export behavior only through a concrete class",
+      outcome: "match",
+      files: [
+        {
+          path: "src/artifact-store.ts",
+          source: "export class ArtifactStore { async read(id: string) { return new Uint8Array(); } }"
+        }
+      ],
+      focusPath: "src/artifact-store.ts",
+      expectedCount: 1,
+      public: true
+    }
+  ]
+};
+function hasPublicInstanceBehavior(node) {
+  return node.body.body.some((member) => {
+    if (member.type === import_utils83.AST_NODE_TYPES.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils83.AST_NODE_TYPES.PrivateIdentifier;
+    }
+    if (member.type !== import_utils83.AST_NODE_TYPES.PropertyDefinition || member.static)
+      return false;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) return false;
+    return member.value?.type === import_utils83.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils83.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSFunctionType;
+  });
+}
+function classBindings(statement) {
+  const declaration = statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === import_utils83.AST_NODE_TYPES.ClassDeclaration) {
+    return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
+  }
+  if (declaration?.type !== import_utils83.AST_NODE_TYPES.VariableDeclaration) return [];
+  return declaration.declarations.flatMap(
+    (item) => item.id.type === import_utils83.AST_NODE_TYPES.Identifier && item.init?.type === import_utils83.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+  );
+}
+var require_interface_for_exported_class_default = createRule({
+  name: "require-interface-for-exported-class",
+  documentation: REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require exported concrete classes with public behavior to declare a contract."
+    },
+    schema: [],
+    messages: {
+      requireContract: "Exported class `{{name}}` has public behavior but no declared interface or base contract; add a focused contract and implement it."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isStoryFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      "Program:exit"(program) {
+        const classes = /* @__PURE__ */ new Map();
+        const abstractBases = /* @__PURE__ */ new Set();
+        for (const statement of program.body) {
+          for (const binding of classBindings(statement)) {
+            classes.set(binding.name, binding.declaration);
+            if (binding.declaration.abstract) abstractBases.add(binding.name);
+          }
+        }
+        const exported = /* @__PURE__ */ new Map();
+        for (const statement of program.body) {
+          if (statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration) {
+            for (const binding of classBindings(statement)) {
+              exported.set(binding.declaration, binding.name);
+            }
+            if (statement.source !== null || statement.exportKind === "type") continue;
+            for (const specifier of statement.specifiers) {
+              if (specifier.exportKind === "type") continue;
+              const candidate2 = classes.get(specifier.local.name);
+              if (candidate2 === void 0) continue;
+              const exportedName = specifier.exported.type === import_utils83.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+              exported.set(candidate2, exportedName);
+            }
+            continue;
+          }
+          if (statement.type !== import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration) continue;
+          if (statement.declaration.type === import_utils83.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils83.AST_NODE_TYPES.ClassExpression) {
+            exported.set(
+              statement.declaration,
+              statement.declaration.id?.name ?? "default"
+            );
+          } else if (statement.declaration.type === import_utils83.AST_NODE_TYPES.Identifier) {
+            const candidate2 = classes.get(statement.declaration.name);
+            if (candidate2 !== void 0) {
+              exported.set(candidate2, statement.declaration.name);
+            }
+          }
+        }
+        for (const [declaration, exportedName] of exported) {
+          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils83.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,
+            messageId: "requireContract",
+            data: { name: exportedName }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/require-port-for-service.ts
-var import_utils78 = require("@typescript-eslint/utils");
+var import_utils84 = require("@typescript-eslint/utils");
 var REQUIRE_PORT_FOR_SERVICE_DOCUMENTATION = {
   summary: "Advise when an exported service with injected collaborators has public methods not covered by its declared ports.",
   rationale: "A declared port keeps consumers coupled to the service capability instead of its concrete implementation.",
@@ -14936,45 +15505,45 @@ var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
 var staticMemberName6 = (member) => {
-  if (member.property.type === import_utils78.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils78.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils78.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === import_utils84.AST_NODE_TYPES.Identifier) return member.property.name;
+  return member.computed && member.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
         if (specifier.exportKind !== "type") names.add(specifier.local.name);
       }
-    } else if (statement.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils78.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils78.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils78.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils84.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils84.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils78.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils84.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils78.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils78.AST_NODE_TYPES.TSNullKeyword
+      (member) => member.type !== import_utils84.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils84.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils78.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils84.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils78.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils78.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils84.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils84.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === import_utils78.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils78.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils84.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils84.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -14985,18 +15554,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils78.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils78.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils84.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils84.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils78.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils84.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -15025,10 +15594,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === import_utils78.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils78.AST_NODE_TYPES.ClassExpression || current.type === import_utils78.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils78.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils78.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils78.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils78.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils78.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils78.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils78.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (current.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils84.AST_NODE_TYPES.ClassExpression || current.type === import_utils84.AST_NODE_TYPES.ClassDeclaration) continue;
+      const expression = current.type === import_utils84.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === import_utils84.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils84.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils84.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== import_utils84.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils84.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils84.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -15041,14 +15610,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils78.AST_NODE_TYPES.TSAsExpression || source.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils78.AST_NODE_TYPES.NewExpression) {
+      while (source.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils84.AST_NODE_TYPES.TSAsExpression || source.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
+      if (source.type === import_utils84.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils78.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils84.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === import_utils78.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils78.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils84.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils84.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -15066,7 +15635,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared, storedMemberFieldsFrom)) {
-      const fields = parameter.type === import_utils78.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === import_utils84.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
       if (fields.length === 0) continue;
       if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
       if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -15081,8 +15650,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils78.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils84.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -15091,9 +15660,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils78.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils78.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils84.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils84.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -15109,9 +15678,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils78.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils78.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils84.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils84.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -15123,11 +15692,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils78.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils84.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils78.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils84.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -15137,21 +15706,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils78.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils78.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils84.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils84.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils78.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils84.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils78.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils78.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils78.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils84.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils84.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils84.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils78.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils78.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils84.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils84.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -15178,19 +15747,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils78.AST_NODE_TYPES.ChainExpression || callee.type === import_utils78.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils78.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === import_utils84.AST_NODE_TYPES.ChainExpression || callee.type === import_utils84.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
+  return callee.type === import_utils84.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === import_utils78.AST_NODE_TYPES.ChainExpression || node.type === import_utils78.AST_NODE_TYPES.TSAsExpression || node.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils78.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils78.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === import_utils84.AST_NODE_TYPES.ChainExpression || node.type === import_utils84.AST_NODE_TYPES.TSAsExpression || node.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+  return node.type === import_utils84.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils84.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils78.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils78.AST_NODE_TYPES.ClassExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils78.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils78.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils84.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils84.AST_NODE_TYPES.ClassExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils84.AST_NODE_TYPES.FunctionExpression) return;
+    if (current.type === import_utils84.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -15203,14 +15772,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils78.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils78.AST_NODE_TYPES.MethodDefinition) {
+    if (member.type === import_utils84.AST_NODE_TYPES.StaticBlock || member.static) continue;
+    if (member.type === import_utils84.AST_NODE_TYPES.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== import_utils78.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
+    if (member.type !== import_utils84.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === import_utils78.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -15230,25 +15799,26 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === import_utils78.AST_NODE_TYPES.PropertyDefinition) {
+    if (member.type === import_utils84.AST_NODE_TYPES.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.value?.type !== import_utils78.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils78.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils78.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils78.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
+      if (member.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) continue;
+      if (member.value?.type !== import_utils84.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils84.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils84.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === import_utils84.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
       continue;
     }
-    if (member.type !== import_utils78.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils84.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils78.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils78.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils84.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -15256,13 +15826,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils78.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
   );
   if (methods.length === 0) return false;
   return methods.every((member) => {
     const result = member.value.returnType?.typeAnnotation;
     if (result === void 0) return false;
-    const returnsOwnType = result.type === import_utils78.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils84.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -15270,10 +15840,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils78.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils84.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils78.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils84.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -15295,43 +15865,43 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === import_utils78.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils78.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils84.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils84.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== import_utils78.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils84.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== import_utils78.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
-          if (member.type === import_utils78.AST_NODE_TYPES.TSMethodSignature) {
+          if (member.type !== import_utils84.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
+          if (member.type === import_utils84.AST_NODE_TYPES.TSMethodSignature) {
             callables2.add(member.key.name);
             continue;
           }
-          if (member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils78.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils78.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === import_utils84.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils84.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       continue;
     }
-    if (declaration?.type !== import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== import_utils78.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils78.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      if (member.type !== import_utils84.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
+      if (member.type === import_utils84.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -15339,7 +15909,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils78.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils84.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -15366,7 +15936,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils78.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils84.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -15378,7 +15948,7 @@ function hasServicePort(node, methods, classes, interfaces) {
   if (node.implements.length === 0) return false;
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== import_utils78.AST_NODE_TYPES.Identifier) return true;
+    if (implementation.expression.type !== import_utils84.AST_NODE_TYPES.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -15421,7 +15991,7 @@ var require_port_for_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils78.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -15455,8 +16025,292 @@ var require_port_for_service_default = createRule({
   }
 });
 
+// src/rules/require-sql-access-class.ts
+var import_utils85 = require("@typescript-eslint/utils");
+var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
+  "all",
+  "batch",
+  "dump",
+  "exec",
+  "execute",
+  "get",
+  "pragma",
+  "prepare",
+  "query",
+  "run",
+  "transaction"
+]);
+var BUILDER_TERMINAL_METHODS = /* @__PURE__ */ new Set([
+  "execute",
+  "executeQuery",
+  "executeTakeFirst",
+  "executeTakeFirstOrThrow",
+  "stream"
+]);
+var BUILDER_METHODS = /* @__PURE__ */ new Set([
+  "delete",
+  "insert",
+  "select",
+  "update"
+]);
+var BUILDER_SHORT_TERMINALS = /* @__PURE__ */ new Set([
+  "all",
+  "get",
+  "run"
+]);
+var MODEL_EXECUTION_METHODS = /* @__PURE__ */ new Set([
+  "aggregate",
+  "count",
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "delete",
+  "deleteMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "findMany",
+  "findUnique",
+  "findUniqueOrThrow",
+  "groupBy",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert"
+]);
+var DATABASE_NAMES = /^(?:db|database|connection|pool|prisma|query|transaction|tx)$/iu;
+var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
+  summary: "Keep SQL reads and writes inside a class that receives its database dependency.",
+  rationale: "Free-function database access hides connection ownership and makes transaction, retry, observability, and test boundaries inconsistent.",
+  remediation: "Move the query into a repository or store class and inject the pool, connection, transaction, or typed database binding through its constructor.",
+  category: "architecture",
+  limitations: [
+    "The rule recognizes conventional database receiver names, Cloudflare DB bindings, direct pool.query calls, explicit query-builder terminals, and Prisma-style model delegates; unusually named or heavily aliased clients require architectural review.",
+    "Query construction without a recognized execution terminal is intentionally not reported.",
+    "Constructor injection inherited from a base class or transformed through a wrapper is not inferred by this syntax-only rule."
+  ],
+  examples: [
+    {
+      id: "injected-repository",
+      title: "Own queries in an injected repository",
+      outcome: "no-match",
+      files: [
+        {
+          path: "src/user-repository.ts",
+          source: "export class UserRepository { constructor(private readonly db: Database.Database) {} find(id: string) { return this.db.prepare('SELECT id FROM user WHERE id = ?').get(id); } }"
+        }
+      ],
+      focusPath: "src/user-repository.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "free-query",
+      title: "Do not execute SQL in a free function",
+      outcome: "match",
+      files: [
+        {
+          path: "src/users.ts",
+          source: "export function find(database: Database.Database, id: string) { return database.prepare('SELECT id FROM user WHERE id = ?').get(id); }"
+        }
+      ],
+      focusPath: "src/users.ts",
+      expectedCount: 1,
+      public: true
+    }
+  ]
+};
+function memberName5(node) {
+  if (!node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Identifier)
+    return node.property.name;
+  if (node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
+    return node.property.value;
+  return null;
+}
+function isDatabaseOperation(method, receiver) {
+  if (DIRECT_EXECUTION_METHODS.has(method) && databaseReceiver(receiver))
+    return true;
+  if (!expressionHasDatabaseMarker(receiver)) return false;
+  if (BUILDER_TERMINAL_METHODS.has(method) || MODEL_EXECUTION_METHODS.has(method)) return true;
+  return BUILDER_SHORT_TERMINALS.has(method) && expressionCallsBuilder(receiver);
+}
+function databaseReceiver(node) {
+  if (node.type === import_utils85.AST_NODE_TYPES.Identifier)
+    return DATABASE_NAMES.test(node.name);
+  if (node.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+  const name = memberName5(node);
+  return name === "DB" || name !== null && DATABASE_NAMES.test(name);
+}
+function databaseRootMember(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return null;
+      current = current.callee.object;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+      if (current.object.type === import_utils85.AST_NODE_TYPES.ThisExpression)
+        return memberName5(current);
+      current = current.object;
+      continue;
+    }
+    return current.type === import_utils85.AST_NODE_TYPES.Identifier ? current.name : null;
+  }
+}
+function expressionHasDatabaseMarker(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+      current = current.callee.object;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+      const name = memberName5(current);
+      if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
+        return true;
+      current = current.object;
+      continue;
+    }
+    return current.type === import_utils85.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
+  }
+}
+function expressionCallsBuilder(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+      const name = memberName5(current.callee);
+      if (name !== null && BUILDER_METHODS.has(name)) return true;
+      current = current.callee.object;
+      continue;
+    }
+    if (current.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+    current = current.object;
+  }
+}
+function owningClass2(node) {
+  let current = node.parent;
+  while (current != null) {
+    if (current.type === import_utils85.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils85.AST_NODE_TYPES.ClassExpression)
+      return current;
+    current = current.parent;
+  }
+  return null;
+}
+function injectedMembers(owner) {
+  const injected = /* @__PURE__ */ new Set();
+  const constructor = owner.body.body.find(
+    (member) => member.type === import_utils85.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_utils85.AST_NODE_TYPES.TSParameterProperty) continue;
+    const value = parameter.parameter.type === import_utils85.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === import_utils85.AST_NODE_TYPES.Identifier) injected.add(value.name);
+  }
+  const body2 = constructor.value.body;
+  if (body2 === null) return injected;
+  for (const statement of body2.body) {
+    if (statement.type !== import_utils85.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils85.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") continue;
+    const { left, right } = statement.expression;
+    if (left.type !== import_utils85.AST_NODE_TYPES.MemberExpression) continue;
+    const target = thisRootMember(left);
+    if (target === null) continue;
+    const source = right.type === import_utils85.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils85.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils85.AST_NODE_TYPES.Identifier ? right.object.name : null;
+    if (source !== null && parameters.has(source)) injected.add(target);
+  }
+  return injected;
+}
+function thisRootMember(node) {
+  let current = node;
+  let root = null;
+  while (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+    const name = memberName5(current);
+    if (name === null) return null;
+    root = name;
+    current = current.object;
+  }
+  return current.type === import_utils85.AST_NODE_TYPES.ThisExpression ? root : null;
+}
+function parameterNames(parameter) {
+  let value = parameter;
+  if (value.type === import_utils85.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
+  if (value.type === import_utils85.AST_NODE_TYPES.AssignmentPattern) value = value.left;
+  if (value.type === import_utils85.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== import_utils85.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
+  return new Set(
+    value.properties.flatMap((property) => {
+      if (property.type === import_utils85.AST_NODE_TYPES.RestElement)
+        return property.argument.type === import_utils85.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === import_utils85.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+      return target.type === import_utils85.AST_NODE_TYPES.Identifier ? [target.name] : [];
+    })
+  );
+}
+var require_sql_access_class_default = createRule({
+  name: "require-sql-access-class",
+  documentation: REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Keep SQL reads and writes inside a class that receives its database dependency."
+    },
+    schema: [],
+    messages: {
+      moveSqlIntoClass: "Move this database operation into a repository or store class with an injected connection or pool."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
+      return {};
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression)
+          return;
+        const method = memberName5(node.callee);
+        if (method === null || !isDatabaseOperation(method, node.callee.object))
+          return;
+        const owner = owningClass2(node);
+        if (owner !== null) {
+          const root = databaseRootMember(node.callee.object);
+          if (root !== null && injectedMembers(owner).has(root)) return;
+        }
+        context.report({ node, messageId: "moveSqlIntoClass" });
+      }
+    };
+  }
+});
+
 // src/rules/require-static-next-matcher.ts
-var import_utils79 = require("@typescript-eslint/utils");
+var import_utils86 = 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.",
@@ -15469,34 +16323,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion) {
+  if (node.type === import_utils86.AST_NODE_TYPES.TSAsExpression || node.type === import_utils86.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils86.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils86.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === import_utils79.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils86.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils79.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils86.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils79.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils86.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils79.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils86.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils79.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils86.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils79.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils79.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils86.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils86.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
-function propertyName4(property) {
+function propertyName6(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils79.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils86.AST_NODE_TYPES.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -15519,19 +16373,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils79.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils79.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils86.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== import_utils79.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils86.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils79.AST_NODE_TYPES.Property || propertyName4(property) !== "matcher" || property.value.type === import_utils79.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils86.AST_NODE_TYPES.Property || propertyName6(property) !== "matcher" || property.value.type === import_utils86.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -15545,7 +16399,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils80 = require("@typescript-eslint/utils");
+var import_utils87 = require("@typescript-eslint/utils");
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "react-hook-form useForm call without defaultValues",
   rationale: "Without an explicit initial value, fields can change from uncontrolled to controlled as data arrives, reset behavior becomes ambiguous, and the form's initial shape no longer documents the values users can edit.",
@@ -15599,13 +16453,13 @@ var require_use_form_default_values_default = createRule({
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "useForm") continue;
-          const variable = import_utils80.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = import_utils87.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
           if (variable) importedHooks.add(variable);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== "Identifier") return;
-        const variable = import_utils80.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = import_utils87.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
         const options = node.arguments[0];
         if (!variable || !importedHooks.has(variable) || options !== void 0 && options.type !== "ObjectExpression" || hasDefaultValues(options)) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -15615,7 +16469,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils81 = require("@typescript-eslint/utils");
+var import_utils88 = 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",
@@ -15681,7 +16535,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils82 = require("@typescript-eslint/utils");
+var import_utils89 = 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.",
@@ -15706,14 +16560,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils82.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils89.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils82.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils89.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils82.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils89.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -15722,12 +16576,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils82.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils82.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils89.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils89.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -15748,7 +16602,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils82.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils89.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -15758,16 +16612,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils82.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils89.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils82.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils82.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils82.AST_NODE_TYPES.Literal || init?.type === import_utils82.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils82.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils89.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils89.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils89.AST_NODE_TYPES.Literal || init?.type === import_utils89.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils89.AST_NODE_TYPES.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils82.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils89.AST_NODE_TYPES.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils82.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils89.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils89.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -15776,14 +16630,14 @@ var require_zod_form_validation_default = createRule({
       return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
     };
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils82.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils89.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_utils82.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils89.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -15794,8 +16648,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils82.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils89.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils89.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -15811,16 +16665,16 @@ var require_zod_form_validation_default = createRule({
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils82.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils89.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils89.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_utils82.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils82.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils82.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils82.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils89.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils89.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils82.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils82.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils89.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils89.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -15829,7 +16683,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils82.AST_NODE_TYPES.BlockStatement || parent.type === import_utils82.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils89.AST_NODE_TYPES.BlockStatement || parent.type === import_utils89.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -15838,12 +16692,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils89.AST_NODE_TYPES.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils82.AST_NODE_TYPES.LogicalExpression || current.type === import_utils82.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils89.AST_NODE_TYPES.LogicalExpression || current.type === import_utils89.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -15853,7 +16707,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_utils82.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -15866,7 +16720,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_utils82.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils82.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils89.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils89.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -15878,16 +16732,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils82.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils89.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils82.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils89.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils89.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils82.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils89.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils89.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -15898,23 +16752,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils82.AST_NODE_TYPES.ReturnStatement || node.type === import_utils82.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils89.AST_NODE_TYPES.ReturnStatement || node.type === import_utils89.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils82.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils89.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_utils82.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils82.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils89.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils89.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils82.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils89.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils82.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils89.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);
@@ -15934,7 +16788,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_utils82.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils89.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -15960,7 +16814,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_utils82.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils82.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils82.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils82.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils89.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils89.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils89.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils89.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -15981,7 +16835,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils83 = require("@typescript-eslint/utils");
+var import_utils90 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Require embedded inserts in explicitly replayable callables to carry conflict handling.",
   rationale: "A callable named as an enqueue, seed, migration, schedule, ensure, or upsert promises replay safety.",
@@ -16045,7 +16899,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils84 = require("@typescript-eslint/utils");
+var import_utils91 = 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.",
@@ -16065,7 +16919,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils84.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils91.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils91.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true, makeFix) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -16162,8 +17016,8 @@ function moduleScope(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_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils84.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils91.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils91.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -16187,7 +17041,7 @@ function moduleScope(context, program) {
       const nearestFunction2 = [...ancestors].reverse().find(isFunction);
       const parent = identifier.parent;
       const callerDefinition = nearestFunction2 === void 0 ? void 0 : byFunction.get(nearestFunction2);
-      if (callerDefinition === void 0 || parent.type !== import_utils84.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== import_utils91.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -16202,38 +17056,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils91.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils84.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils91.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils84.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils91.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils84.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils91.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils91.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils91.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_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils91.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils84.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils91.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils84.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === import_utils91.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -16246,21 +17100,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils84.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (node.key.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === import_utils91.AST_NODE_TYPES.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils84.AST_NODE_TYPES.Identifier ? import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === import_utils91.AST_NODE_TYPES.Identifier ? import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils84.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== import_utils91.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
+  if (node.property.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk2(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -16276,7 +17130,7 @@ function walk2(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils91.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -16284,8 +17138,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== import_utils84.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils84.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils91.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils91.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -16294,7 +17148,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -16303,11 +17157,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === import_utils84.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils84.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils91.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils91.AST_NODE_TYPES.Identifier) {
+    const outer = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -16323,27 +17177,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils84.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils84.AST_NODE_TYPES.ThisExpression;
+      while (current?.type === import_utils91.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils91.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+      return current?.type === import_utils91.AST_NODE_TYPES.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils84.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils84.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils84.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== import_utils91.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils91.AST_NODE_TYPES.AssignmentPattern) return;
+      if (current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils91.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
+      const value = current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === import_utils84.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils91.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils84.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils91.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === import_utils84.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === import_utils91.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== import_utils84.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== import_utils91.AST_NODE_TYPES.Identifier) return;
+      const variable = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -16356,16 +17210,16 @@ function classScope(context, node, computedReferenceNames) {
       walk2(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils84.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
+      if (current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils91.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === import_utils84.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils91.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === import_utils84.AST_NODE_TYPES.Property && property.key.type === import_utils84.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === import_utils91.AST_NODE_TYPES.Property && property.key.type === import_utils91.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -16373,12 +17227,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils84.AST_NODE_TYPES.Identifier ? import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === import_utils91.AST_NODE_TYPES.Identifier ? import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils84.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils91.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -16398,9 +17252,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils84.AST_NODE_TYPES.MethodDefinition || member.type === import_utils84.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils91.AST_NODE_TYPES.MethodDefinition || member.type === import_utils91.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk2(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -16452,12 +17306,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils84.AST_NODE_TYPES.StaticBlock:
+    case import_utils91.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils84.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils84.AST_NODE_TYPES.AccessorProperty:
+    case import_utils91.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils91.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils84.AST_NODE_TYPES.MethodDefinition:
+    case import_utils91.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -16490,7 +17344,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk2(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils84.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils91.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -16499,7 +17353,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-var import_utils85 = require("@typescript-eslint/utils");
+var import_utils92 = require("@typescript-eslint/utils");
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|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"]);
@@ -16568,28 +17422,28 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils92.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils92.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
-function unwrap5(node) {
-  if (node.type === import_utils85.AST_NODE_TYPES.AwaitExpression) return unwrap5(node.argument);
-  if (node.type === import_utils85.AST_NODE_TYPES.ChainExpression) return unwrap5(node.expression);
-  if (node.type === import_utils85.AST_NODE_TYPES.TSAsExpression || node.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) return unwrap5(node.expression);
+function unwrap6(node) {
+  if (node.type === import_utils92.AST_NODE_TYPES.AwaitExpression) return unwrap6(node.argument);
+  if (node.type === import_utils92.AST_NODE_TYPES.ChainExpression) return unwrap6(node.expression);
+  if (node.type === import_utils92.AST_NODE_TYPES.TSAsExpression || node.type === import_utils92.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils92.AST_NODE_TYPES.TSTypeAssertion) return unwrap6(node.expression);
   return node;
 }
 function stringValue(node) {
-  const current = unwrap5(node);
-  if (current.type === import_utils85.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils85.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  const current = unwrap6(node);
+  if (current.type === import_utils92.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils92.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
   return null;
 }
 function importSource(node) {
   return typeof node.source.value === "string" ? node.source.value : null;
 }
 function requireSource(node) {
-  const current = unwrap5(node);
-  if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils85.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils85.AST_NODE_TYPES.SpreadElement) return null;
+  const current = unwrap6(node);
+  if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils92.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils92.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -16626,80 +17480,80 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         return /* @__PURE__ */ new Set();
       };
       const sourcePath = (node) => {
-        const current = unwrap5(node);
+        const current = unwrap6(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
-        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
+        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
           return sourcePath(current.left) || sourcePath(current.right);
         }
-        if (current.type === import_utils85.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
-        if (current.type === import_utils85.AST_NODE_TYPES.CallExpression || current.type === import_utils85.AST_NODE_TYPES.NewExpression) {
-          return current.arguments.some((argument) => argument.type !== import_utils85.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
+        if (current.type === import_utils92.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
+        if (current.type === import_utils92.AST_NODE_TYPES.CallExpression || current.type === import_utils92.AST_NODE_TYPES.NewExpression) {
+          return current.arguments.some((argument) => argument.type !== import_utils92.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
         }
-        if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
+        if (current.type === import_utils92.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
         return false;
       };
       const rawRead = (node) => {
-        const current = unwrap5(node);
-        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
-        const callee = unwrap5(current.callee);
-        if (callee.type === import_utils85.AST_NODE_TYPES.Identifier) {
+        const current = unwrap6(node);
+        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        const callee = unwrap6(current.callee);
+        if (callee.type === import_utils92.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee.name) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
-        const object = unwrap5(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils85.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
+        const object = unwrap6(callee.object);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils92.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
-        const current = unwrap5(node);
-        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
+        const current = unwrap6(node);
+        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
-        const callee = unwrap5(current.callee);
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils92.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        const callee = unwrap6(current.callee);
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
       const evidenceOrigins = (node) => {
-        const current = unwrap5(node);
+        const current = unwrap6(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression || current.type === import_utils85.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils85.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
-        const callee = unwrap5(current.callee);
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression || current.type === import_utils92.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils92.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        const callee = unwrap6(current.callee);
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(callee.object);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
-        const callee = unwrap5(node.callee);
-        if (callee.type === import_utils85.AST_NODE_TYPES.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        const callee = unwrap6(node.callee);
+        if (callee.type === import_utils92.AST_NODE_TYPES.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
-        let receiver = unwrap5(callee.object);
-        while (receiver.type === import_utils85.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap5(receiver.object);
-        if (receiver.type === import_utils85.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils85.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        let receiver = unwrap6(callee.object);
+        while (receiver.type === import_utils92.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap6(receiver.object);
+        if (receiver.type === import_utils92.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils92.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils85.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils92.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const rawRegexExtractionOrigins = (node) => {
-        const callee = unwrap5(node.callee);
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        const callee = unwrap6(node.callee);
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
         const argument = node.arguments[0];
-        if (argument?.type !== import_utils85.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
+        if (argument?.type !== import_utils92.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
         return rawOrigins(callee.object);
       };
       const declare = (name2, state) => {
@@ -16719,16 +17573,16 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         }
       };
       const sourceCollection = (node) => {
-        const current = unwrap5(node);
-        return current.type === import_utils85.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils85.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        const current = unwrap6(node);
+        return current.type === import_utils92.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils92.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const declaredNames2 = (node) => {
-        const current = unwrap5(node);
-        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return [current.name];
-        if (current.type === import_utils85.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
-        if (current.type === import_utils85.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
-        if (current.type === import_utils85.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
-        if (current.type === import_utils85.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils85.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
+        const current = unwrap6(node);
+        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return [current.name];
+        if (current.type === import_utils92.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
+        if (current.type === import_utils92.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
+        if (current.type === import_utils92.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
+        if (current.type === import_utils92.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils92.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
         return [];
       };
       const enterFunction = (node) => {
@@ -16743,8 +17597,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_utils85.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils85.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils92.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils92.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local.name, { fsReader: true });
             } else {
               declare(specifier.local.name, { fsObject: true });
@@ -16756,29 +17610,29 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         VariableDeclarator(node) {
           if (node.init === null) return;
           const required = requireSource(node.init);
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils85.AST_NODE_TYPES.Identifier) {
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils92.AST_NODE_TYPES.Identifier) {
             declare(node.id.name, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils85.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils92.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== import_utils85.AST_NODE_TYPES.Property || property.value.type !== import_utils85.AST_NODE_TYPES.Identifier) continue;
-              const key = property.key.type === import_utils85.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils85.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+              if (property.type !== import_utils92.AST_NODE_TYPES.Property || property.value.type !== import_utils92.AST_NODE_TYPES.Identifier) continue;
+              const key = property.key.type === import_utils92.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils92.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value.name, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils92.AST_NODE_TYPES.Identifier) return;
           declare(node.id.name, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils85.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
+          if (node.left.type === import_utils92.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
         },
         ForOfStatement(node) {
-          const right = unwrap5(node.right);
-          const collection = right.type === import_utils85.AST_NODE_TYPES.Identifier && visible("collections", right.name);
-          const left = node.left.type === import_utils85.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils85.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
+          const right = unwrap6(node.right);
+          const collection = right.type === import_utils92.AST_NODE_TYPES.Identifier && visible("collections", right.name);
+          const left = node.left.type === import_utils92.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils92.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
         },
         CallExpression(node) {
           const origins = /* @__PURE__ */ new Set([
@@ -16799,6 +17653,120 @@ var source_coupled_test_default = createSourceCoupledRule(
   GENERAL_SOURCE_SUFFIX_RE
 );
 
+// src/rules/sole-export-matches-filename.ts
+var import_utils93 = require("@typescript-eslint/utils");
+var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
+  summary: "Match a module filename to its sole named public runtime export.",
+  rationale: "When a module owns one runtime responsibility, matching names make that responsibility directly discoverable.",
+  remediation: "Rename the module stem to the kebab-case export name, or colocate genuinely related exports.",
+  category: "maintainability",
+  limitations: [
+    "Framework entrypoints, generic stems covered by no-generic-single-export-module, tests, generated files, anonymous defaults, CommonJS, and re-exports are excluded.",
+    "The rule compares the primary filename stem and preserves conventional suffixes such as .server or .worker."
+  ],
+  examples: [
+    { id: "matching-class", title: "Match a class and module", outcome: "no-match", files: [{ path: "src/artifact-store.ts", source: "export class ArtifactStore {}" }], focusPath: "src/artifact-store.ts", expectedCount: 0, public: true },
+    { id: "mismatched-class", title: "Do not hide a sole class behind another filename", outcome: "match", files: [{ path: "src/artifacts.ts", source: "export class ArtifactStore {}" }], focusPath: "src/artifacts.ts", expectedCount: 1, public: true }
+  ]
+};
+var EXCLUDED_STEMS = /* @__PURE__ */ new Set([
+  "common",
+  "global",
+  "helpers",
+  "index",
+  "layout",
+  "loading",
+  "middleware",
+  "misc",
+  "not-found",
+  "page",
+  "route",
+  "shared",
+  "template",
+  "types",
+  "util",
+  "utils"
+]);
+function stem3(filename) {
+  const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
+  return base.replace(/\.[cm]?[jt]sx?$/u, "").split(".")[0] ?? "";
+}
+function kebabCase(name) {
+  return name.replace(/([A-Z]{2,})([A-Z][a-z])/gu, "$1-$2").replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[^a-z0-9]+/giu, "-").replaceAll(/^-+|-+$/gu, "").toLowerCase();
+}
+function declarationExport(statement) {
+  const declaration = statement.declaration;
+  if (declaration === null || declaration.declare === true) return [];
+  if (declaration.type === import_utils93.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils93.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils93.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== import_utils93.AST_NODE_TYPES.VariableDeclaration) return [];
+  return declaration.declarations.flatMap(
+    (item) => item.id.type === import_utils93.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
+  );
+}
+var sole_export_matches_filename_default = createRule({
+  name: "sole-export-matches-filename",
+  documentation: SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Match a module filename to its sole named public runtime export." },
+    schema: [],
+    messages: {
+      matchSoleExport: "This module's sole runtime export is `{{exported}}`; rename the file stem to `{{expected}}`."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const fileStem = stem3(context.filename);
+    const normalizedFilename = context.filename.replaceAll("\\", "/");
+    if (EXCLUDED_STEMS.has(fileStem) || normalizedFilename.includes("/pages/") || context.filename.endsWith(".d.ts") || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      "Program:exit"(program) {
+        const exports2 = [];
+        const publicExports = /* @__PURE__ */ new Set();
+        for (const statement of program.body) {
+          if (statement.type === import_utils93.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils93.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
+          if (statement.type === import_utils93.AST_NODE_TYPES.ExportDefaultDeclaration) {
+            publicExports.add("default");
+            const declaration2 = statement.declaration;
+            if ((declaration2.type === import_utils93.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils93.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
+            else return;
+          }
+          if (statement.type !== import_utils93.AST_NODE_TYPES.ExportNamedDeclaration) continue;
+          const declaration = statement.declaration;
+          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils93.AST_NODE_TYPES.Identifier) {
+            publicExports.add(declaration.id.name);
+          }
+          if (declaration?.type === import_utils93.AST_NODE_TYPES.VariableDeclaration) {
+            for (const item of declaration.declarations) {
+              if (item.id.type === import_utils93.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
+            }
+          }
+          for (const specifier of statement.specifiers) {
+            const exported = specifier.exported.type === import_utils93.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            publicExports.add(String(exported));
+          }
+          if (statement.exportKind === "type") continue;
+          exports2.push(...declarationExport(statement));
+          for (const specifier of statement.specifiers) {
+            const exported = specifier.exported.type === import_utils93.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            publicExports.add(String(exported));
+            if (specifier.exportKind === "type") continue;
+            if (exported === "default") exports2.push({ name: specifier.local.name, node: specifier });
+            else exports2.push({ name: String(exported), node: specifier });
+          }
+        }
+        const unique = new Map(exports2.map((item) => [item.name, item]));
+        if (unique.size !== 1 || publicExports.size !== 1) return;
+        const only = [...unique.values()][0];
+        if (only === void 0) return;
+        const expected = kebabCase(only.name);
+        if (expected === "" || expected === fileStem.toLowerCase()) return;
+        context.report({ node: only.node, messageId: "matchSoleExport", data: { exported: only.name, expected } });
+      }
+    };
+  }
+});
+
 // src/rules/iac-source-coupled-test.ts
 var IAC_SOURCE_SUFFIX_RE = /(?:\.tf\.json|\.tftest\.(?:hcl|json)|\.(?:hcl|tf|tfvars))$/iu;
 var IAC_SOURCE_COUPLED_TEST_DOCUMENTATION = {
@@ -16838,7 +17806,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils86 = require("@typescript-eslint/utils");
+var import_utils94 = 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.",
@@ -16970,18 +17938,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils86.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils94.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils86.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils94.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils86.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils86.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -16992,13 +17960,13 @@ var chainMemberNames = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils86.AST_NODE_TYPES.MemberExpression) {
-      if (current.computed || current.property.type !== import_utils86.AST_NODE_TYPES.Identifier) return [];
+    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils94.AST_NODE_TYPES.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === import_utils86.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -17009,16 +17977,16 @@ var chainMemberNames = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === import_utils86.AST_NODE_TYPES.TSAsExpression || current.type === import_utils86.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils86.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils86.AST_NODE_TYPES.TSTypeAssertion) {
+  while (current.type === import_utils94.AST_NODE_TYPES.TSAsExpression || current.type === import_utils94.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils94.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils94.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils94.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils86.AST_NODE_TYPES.Program || owner.type === import_utils86.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils86.AST_NODE_TYPES.Program;
+  return owner.type === import_utils94.AST_NODE_TYPES.Program || owner.type === import_utils94.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils94.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -17038,7 +18006,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_utils86.ASTUtils.findVariable(
+      return import_utils94.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -17059,8 +18027,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === import_utils86.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils86.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils86.AST_NODE_TYPES.MemberExpression) {
+      if (init.type === import_utils94.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils94.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils94.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -17080,7 +18048,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_utils86.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils86.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils94.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils94.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils94.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils94.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -17089,7 +18057,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_utils86.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils94.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -17247,11 +18215,16 @@ var RULES = {
   "prefer-shadcn-primitives": prefer_shadcn_primitives_default,
   "prefer-module-level-constant": prefer_module_level_constant_default,
   "prefer-module-level-schema": prefer_module_level_schema_default,
+  "prefer-named-complex-return-type": prefer_named_complex_return_type_default,
   "prefer-native-random-uuid": prefer_native_random_uuid_default,
+  "prefer-node-crypto-hash": prefer_node_crypto_hash_default,
+  "prefer-node-fs-promises": prefer_node_fs_promises_default,
   "prefer-non-nullable-collection": prefer_non_nullable_collection_default,
   "prefer-nullish-filter-predicate": prefer_nullish_filter_predicate_default,
   "prefer-await-in-async-return": prefer_await_in_async_return_default,
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
+  "prefer-shared-zod-enum": prefer_shared_zod_enum_default,
+  "prefer-switch-for-repeated-equality": prefer_switch_for_repeated_equality_default,
   "prefer-semantic-colors": prefer_semantic_colors_default,
   "prefer-server-actions": prefer_server_actions_default,
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
@@ -17259,24 +18232,37 @@ var RULES = {
   "prefer-zod-infer": prefer_zod_infer_default,
   "require-assert-never": require_assert_never_default,
   "require-fetch-timeout": require_fetch_timeout_default,
+  "require-interface-for-exported-class": require_interface_for_exported_class_default,
   "require-port-for-service": require_port_for_service_default,
+  "require-sql-access-class": require_sql_access_class_default,
   "require-static-next-matcher": require_static_next_matcher_default,
   "require-zod-form-validation": require_zod_form_validation_default,
   "store-insert-requires-on-conflict": store_insert_requires_on_conflict_default,
   "stepdown": stepdown_default,
   "source-coupled-test": source_coupled_test_default,
+  "sole-export-matches-filename": sole_export_matches_filename_default,
   "require-pascal-case-zod-schema-name": require_pascal_case_zod_schema_name_default
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.14.0"
+  version: "15.16.0"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",
   "prefer-native-random-uuid",
   "prefer-shadcn-primitives"
 ];
-var ADVISORY_RULES = ["@sarj/require-pascal-case-zod-schema-name"];
+var ADVISORY_RULES = [
+  "@sarj/prefer-named-complex-return-type",
+  "@sarj/prefer-node-crypto-hash",
+  "@sarj/prefer-node-fs-promises",
+  "@sarj/prefer-shared-zod-enum",
+  "@sarj/prefer-switch-for-repeated-equality",
+  "@sarj/require-interface-for-exported-class",
+  "@sarj/require-pascal-case-zod-schema-name",
+  "@sarj/require-sql-access-class",
+  "@sarj/sole-export-matches-filename"
+];
 var RECOMMENDED_RULES = {
   "@sarj/interface-contract-members-private": "error",
   "@sarj/iac-source-coupled-test": "error",
@@ -17330,10 +18316,15 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-immutable-module-constant": "error",
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
+  "@sarj/prefer-named-complex-return-type": "warn",
+  "@sarj/prefer-node-crypto-hash": "warn",
+  "@sarj/prefer-node-fs-promises": "warn",
   "@sarj/prefer-non-nullable-collection": "error",
   "@sarj/prefer-nullish-filter-predicate": "error",
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
+  "@sarj/prefer-shared-zod-enum": "warn",
+  "@sarj/prefer-switch-for-repeated-equality": "warn",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
   "@sarj/prefer-whole-object-assertion": "error",
@@ -17341,7 +18332,9 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-zod-infer": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
+  "@sarj/require-interface-for-exported-class": "warn",
   "@sarj/require-port-for-service": "error",
+  "@sarj/require-sql-access-class": "warn",
   "@sarj/require-static-next-matcher": "error",
   "@sarj/require-use-form-default-values": "error",
   "@sarj/require-use-server-in-actions-file": "error",
@@ -17349,6 +18342,7 @@ var RECOMMENDED_RULES = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "error",
+  "@sarj/sole-export-matches-filename": "warn",
   "@sarj/test-phase-label-comment": "error",
   "@sarj/require-pascal-case-zod-schema-name": "warn"
 };
@@ -17409,10 +18403,15 @@ var STRICT_RULES = {
   "@sarj/prefer-immutable-module-constant": "error",
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
+  "@sarj/prefer-named-complex-return-type": "warn",
+  "@sarj/prefer-node-crypto-hash": "warn",
+  "@sarj/prefer-node-fs-promises": "warn",
   "@sarj/prefer-non-nullable-collection": "error",
   "@sarj/prefer-nullish-filter-predicate": "error",
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
+  "@sarj/prefer-shared-zod-enum": "warn",
+  "@sarj/prefer-switch-for-repeated-equality": "warn",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
   "@sarj/prefer-whole-object-assertion": "error",
@@ -17420,7 +18419,9 @@ var STRICT_RULES = {
   "@sarj/prefer-zod-infer": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
+  "@sarj/require-interface-for-exported-class": "warn",
   "@sarj/require-port-for-service": "error",
+  "@sarj/require-sql-access-class": "warn",
   "@sarj/require-static-next-matcher": "error",
   "@sarj/require-use-form-default-values": "error",
   "@sarj/require-use-server-in-actions-file": "error",
@@ -17428,6 +18429,7 @@ var STRICT_RULES = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "error",
+  "@sarj/sole-export-matches-filename": "warn",
   "@sarj/test-phase-label-comment": "error",
   "@sarj/require-pascal-case-zod-schema-name": "warn"
 };