@sarj/eslint-plugin 15.15.0 → 15.16.0

package/dist/index.cjs

@@ -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;
@@ -5461,9 +5461,9 @@ var no_positional_tuple_return_default = createRule({
       TSMethodSignature(node) {
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
-        const memberName5 = staticMemberName3(node.key);
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || memberName5 === null) return;
-        report2(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName5}`);
+        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;
@@ -5474,11 +5474,11 @@ var no_positional_tuple_return_default = createRule({
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
         const annotation = node.typeAnnotation?.typeAnnotation;
-        const memberName5 = staticMemberName3(node.key);
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || memberName5 === 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) {
-          report2(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName5}`);
+          report2(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName6}`);
         }
       },
       PropertyDefinition(node) {
@@ -11861,7 +11861,7 @@ var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   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 direct ESM imports and namespace imports from node:crypto are analyzed.",
+    "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: [
@@ -11869,22 +11869,79 @@ var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
     { 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 directImports = /* @__PURE__ */ new Set();
-    const namespaceImports = /* @__PURE__ */ new Set();
+    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 !== "node:crypto") return;
+        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) {
-            namespaceImports.add(specifier.local.name);
+          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") {
-            directImports.add(specifier.local.name);
+            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);
           }
         }
       },
@@ -11894,7 +11951,12 @@ var prefer_node_crypto_hash_default = createRule({
         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, directImports, namespaceImports))
+        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" });
       }
@@ -11905,12 +11967,20 @@ 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 && !node.callee.computed && node.callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && node.callee.property.name === name;
+  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && memberName3(node.callee) === name;
 }
-function isCreateHashCall(node, directImports, namespaceImports) {
-  if (node.callee.type === import_utils68.AST_NODE_TYPES.Identifier)
-    return directImports.has(node.callee.name);
-  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils68.AST_NODE_TYPES.Identifier && namespaceImports.has(node.callee.object.name) && node.callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && node.callee.property.name === "createHash";
+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
@@ -11923,20 +11993,40 @@ var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
   limitations: [
     "Tests and generated files are excluded.",
     "ESLint rule implementations under src/rules are excluded because visitor creation and execution are synchronous by contract.",
-    "The rule covers static ESM imports and member calls through namespace/default imports from node:fs; CommonJS require flows are not inferred."
+    "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 memberName3(node) {
+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,
@@ -11973,10 +12063,32 @@ var prefer_node_fs_promises_default = createRule({
           });
         }
       },
+      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) {
-        if (node.object.type !== import_utils69.AST_NODE_TYPES.Identifier || !namespaces.has(node.object.name)) return;
-        const name = memberName3(node);
-        if (name?.endsWith("Sync") === true) {
+        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 } });
         }
       }
@@ -11998,7 +12110,7 @@ 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_utils70.AST_NODE_TYPES.Identifier) return key.name;
@@ -12011,7 +12123,7 @@ function isArrayType(node) {
 }
 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_utils70.AST_NODE_TYPES.TSUnionType) return null;
   const concrete = annotation.types.filter(
@@ -12221,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" }
           });
         }
       }
@@ -13052,14 +13164,14 @@ 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: "Reuse identical literal Zod enum domains within a module.",
-  rationale: "Repeating the same literal domain creates parallel contracts that can drift independently.",
-  remediation: "Declare one module-level named Zod enum schema and reuse it at each field or contract site.",
+  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 ordered string-literal arrays in the same module are compared."],
+  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: "duplicate-provider", title: "Do not repeat one enum domain", outcome: "match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const JobSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']) }); const StatusSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']).optional() });" }], focusPath: "src/provider.ts", expectedCount: 1, 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) {
@@ -13072,15 +13184,26 @@ function literalDomain(node) {
   }
   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: "Reuse identical literal Zod enum domains within a module." },
+    docs: { description: "Give literal Zod enum domains one reusable module-level schema." },
     schema: [],
     messages: {
-      shareEnumDomain: "This Zod enum repeats an earlier identical domain; extract and reuse one module-level named schema."
+      shareEnumDomain: "Extract this literal Zod enum to one module-level named schema and reuse it."
     }
   },
   defaultOptions: [],
@@ -13100,7 +13223,9 @@ var prefer_shared_zod_enum_default = createRule({
         const domain = literalDomain(node);
         if (domain === null) return;
         const key = JSON.stringify(domain);
-        if (seen.has(key)) context.report({ node, messageId: "shareEnumDomain" });
+        const inline = !isModuleLevelNamedSchema(node);
+        if (inline || seen.has(key))
+          context.report({ node, messageId: "shareEnumDomain" });
         else seen.add(key);
       }
     };
@@ -13116,6 +13241,7 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   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: [
@@ -13125,11 +13251,17 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
 };
 function discriminantText(sourceCode, test) {
   if (test.type !== import_utils75.AST_NODE_TYPES.BinaryExpression || test.operator !== "===") return null;
-  const leftIsCase = test.left.type === import_utils75.AST_NODE_TYPES.Literal;
-  const rightIsCase = test.right.type === import_utils75.AST_NODE_TYPES.Literal;
+  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,
@@ -14667,11 +14799,11 @@ var prefer_zod_infer_default = createRule({
           continue;
         }
         const key = member.key;
-        const propertyName5 = 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 (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;
         }
@@ -14686,7 +14818,7 @@ var prefer_zod_infer_default = createRule({
           node: annotation,
           owner,
           ownerName,
-          propertyName: propertyName5,
+          propertyName: propertyName7,
           propertyTokens
         });
       }
@@ -15214,8 +15346,141 @@ var require_fetch_timeout_default = createRule({
   }
 });
 
-// src/rules/require-port-for-service.ts
+// 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_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.",
@@ -15240,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_utils83.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils83.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils83.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_utils83.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils83.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_utils83.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils83.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_utils83.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils84.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils83.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils83.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_utils83.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils83.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_utils83.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils83.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);
@@ -15289,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_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils83.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_utils83.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils83.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils83.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_utils83.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils83.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils83.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) {
@@ -15329,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_utils83.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils83.AST_NODE_TYPES.FunctionExpression || current.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils83.AST_NODE_TYPES.ClassExpression || current.type === import_utils83.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils83.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils83.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils83.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils83.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils83.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils83.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils83.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];
@@ -15345,14 +15610,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils83.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils83.AST_NODE_TYPES.TSAsExpression || source.type === import_utils83.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils83.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils83.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);
@@ -15370,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_utils83.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;
@@ -15385,8 +15650,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils83.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils83.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);
@@ -15395,9 +15660,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils83.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils83.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils83.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);
@@ -15413,9 +15678,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils83.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils83.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils83.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: [] };
@@ -15427,11 +15692,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils83.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils83.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_utils83.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils83.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;
@@ -15441,21 +15706,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils83.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils83.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils83.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_utils83.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils84.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils83.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils83.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils83.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_utils83.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils83.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;
@@ -15482,19 +15747,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils83.AST_NODE_TYPES.ChainExpression || callee.type === import_utils83.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils83.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils83.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils83.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils83.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_utils83.AST_NODE_TYPES.ChainExpression || node.type === import_utils83.AST_NODE_TYPES.TSAsExpression || node.type === import_utils83.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils83.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils83.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils83.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils83.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_utils83.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils83.AST_NODE_TYPES.ClassExpression || current.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils83.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils83.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);
     }
@@ -15507,14 +15772,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils83.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils83.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_utils83.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_utils83.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;
@@ -15534,26 +15799,26 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils83.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_utils83.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.key.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) continue;
-      if (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 && !(member.typeAnnotation?.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils83.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils83.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;
@@ -15561,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_utils83.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_utils83.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils83.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));
   });
 };
@@ -15575,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_utils83.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils83.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_utils83.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils84.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -15600,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_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils83.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils83.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_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils83.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils83.AST_NODE_TYPES.Identifier) continue;
-          if (member.type === import_utils83.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_utils83.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils83.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils83.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils83.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_utils83.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_utils83.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils83.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils83.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils83.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils83.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(
@@ -15644,7 +15909,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils83.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils84.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -15671,7 +15936,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils83.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;
   }
@@ -15683,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_utils83.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;
@@ -15726,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_utils83.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(
@@ -15761,32 +16026,67 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-sql-access-class.ts
-var import_utils84 = require("@typescript-eslint/utils");
-var SQL_METHODS = /* @__PURE__ */ new Set([
+var import_utils85 = require("@typescript-eslint/utils");
+var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
-  "delete",
   "dump",
   "exec",
   "execute",
   "get",
-  "insert",
   "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",
-  "transaction",
   "update"
 ]);
-var DATABASE_NAMES = /^(?:db|database|connection|pool|query|transaction|tx)$/iu;
+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 and Cloudflare DB bindings; unusually named or heavily aliased clients require architectural review.",
-    "Query construction without execution is not reported."
+    "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: [
     {
@@ -15819,28 +16119,160 @@ var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
     }
   ]
 };
-function memberName4(node) {
-  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier)
+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_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
+  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_utils84.AST_NODE_TYPES.Identifier)
+  if (node.type === import_utils85.AST_NODE_TYPES.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return false;
-  const name = memberName4(node);
+  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 belongsToClass(node) {
+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_utils84.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils84.AST_NODE_TYPES.ClassExpression)
-      return true;
+    if (current.type === import_utils85.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils85.AST_NODE_TYPES.ClassExpression)
+      return current;
     current = current.parent;
   }
-  return false;
+  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",
@@ -15861,11 +16293,16 @@ var require_sql_access_class_default = createRule({
       return {};
     return {
       CallExpression(node) {
-        if (belongsToClass(node) || node.callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression)
+        if (node.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression)
           return;
-        const method = memberName4(node.callee);
-        if (method === null || !SQL_METHODS.has(method) || !databaseReceiver(node.callee.object))
+        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" });
       }
     };
@@ -15873,7 +16310,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils85 = 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.",
@@ -15886,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_utils85.AST_NODE_TYPES.TSAsExpression || node.type === import_utils85.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils85.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_utils85.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils86.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils85.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils86.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils85.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils86.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils85.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils86.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils85.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils86.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils85.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils85.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_utils85.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({
@@ -15936,19 +16373,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils85.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_utils85.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_utils85.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils86.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils85.AST_NODE_TYPES.Property || propertyName4(property) !== "matcher" || property.value.type === import_utils85.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)) {
@@ -15962,7 +16399,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils86 = 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.",
@@ -16016,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_utils86.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_utils86.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" });
@@ -16032,7 +16469,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils87 = 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",
@@ -16098,7 +16535,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils88 = 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.",
@@ -16123,14 +16560,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils88.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils89.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils88.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils89.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils88.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils89.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -16139,12 +16576,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils88.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils88.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_utils88.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils88.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",
@@ -16165,7 +16602,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils88.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils89.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -16175,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_utils88.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_utils88.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils88.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils88.AST_NODE_TYPES.Literal || init?.type === import_utils88.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils88.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_utils88.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_utils88.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils88.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);
@@ -16193,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_utils88.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_utils88.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;
@@ -16211,8 +16648,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils88.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);
@@ -16228,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_utils88.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils88.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_utils88.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils88.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils88.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils88.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_utils88.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils88.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;
@@ -16246,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_utils88.AST_NODE_TYPES.BlockStatement || parent.type === import_utils88.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;
@@ -16255,12 +16692,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === import_utils88.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils88.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_utils88.AST_NODE_TYPES.LogicalExpression || current.type === import_utils88.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;
@@ -16270,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_utils88.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -16283,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_utils88.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils88.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);
@@ -16295,16 +16732,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils88.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_utils88.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_utils88.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_utils88.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils88.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;
@@ -16315,23 +16752,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils88.AST_NODE_TYPES.ReturnStatement || node.type === import_utils88.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_utils88.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_utils88.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils88.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_utils88.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_utils88.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);
@@ -16351,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_utils88.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(
@@ -16377,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_utils88.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils88.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils88.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils88.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);
           }
@@ -16398,7 +16835,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils89 = 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.",
@@ -16462,7 +16899,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils90 = 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.",
@@ -16482,7 +16919,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils90.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils90.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils90.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]));
@@ -16579,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_utils90.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils90.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);
@@ -16604,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_utils90.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;
       }
@@ -16619,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_utils90.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils90.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_utils90.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_utils90.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_utils90.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_utils90.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils90.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils90.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils90.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_utils90.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils90.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils90.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_utils90.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_utils90.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,
@@ -16663,21 +17100,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils90.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils90.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_utils90.AST_NODE_TYPES.Identifier ? import_utils90.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_utils90.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils90.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils90.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils90.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_utils90.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils90.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils90.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);
@@ -16693,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_utils90.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils91.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -16701,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_utils90.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils90.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) => {
@@ -16711,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_utils90.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;
@@ -16720,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_utils90.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_utils90.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils90.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils90.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils90.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) {
@@ -16740,27 +17177,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils90.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils90.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils90.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_utils90.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils90.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils90.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils90.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils90.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils90.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_utils90.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils91.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils90.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_utils90.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_utils90.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils90.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);
@@ -16773,16 +17210,16 @@ function classScope(context, node, computedReferenceNames) {
       walk2(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils90.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils90.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_utils90.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_utils90.AST_NODE_TYPES.Property && property.key.type === import_utils90.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_utils90.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);
@@ -16790,12 +17227,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils90.AST_NODE_TYPES.Identifier ? import_utils90.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_utils90.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;
       }
@@ -16815,9 +17252,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils90.AST_NODE_TYPES.MethodDefinition || member.type === import_utils90.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_utils90.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);
@@ -16869,12 +17306,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils90.AST_NODE_TYPES.StaticBlock:
+    case import_utils91.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils90.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils90.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_utils90.AST_NODE_TYPES.MethodDefinition:
+    case import_utils91.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -16907,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_utils90.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils90.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);
       }
@@ -16916,7 +17353,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-var import_utils91 = 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"]);
@@ -16985,20 +17422,20 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils91.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 unwrap6(node) {
-  if (node.type === import_utils91.AST_NODE_TYPES.AwaitExpression) return unwrap6(node.argument);
-  if (node.type === import_utils91.AST_NODE_TYPES.ChainExpression) return unwrap6(node.expression);
-  if (node.type === import_utils91.AST_NODE_TYPES.TSAsExpression || node.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils91.AST_NODE_TYPES.TSTypeAssertion) return unwrap6(node.expression);
+  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 = unwrap6(node);
-  if (current.type === import_utils91.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils91.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  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) {
@@ -17006,7 +17443,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap6(node);
-  if (current.type !== import_utils91.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils91.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils91.AST_NODE_TYPES.SpreadElement) return null;
+  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() {
@@ -17046,38 +17483,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils91.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
-        if (current.type === import_utils91.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_utils91.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
-        if (current.type === import_utils91.AST_NODE_TYPES.CallExpression || current.type === import_utils91.AST_NODE_TYPES.NewExpression) {
-          return current.arguments.some((argument) => argument.type !== import_utils91.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_utils91.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 = unwrap6(node);
-        if (current.type !== import_utils91.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap6(current.callee);
-        if (callee.type === import_utils91.AST_NODE_TYPES.Identifier) {
+        if (callee.type === import_utils92.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee.name) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return false;
+        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap6(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils91.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
+        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 = unwrap6(node);
-        if (current.type === import_utils91.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
+        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_utils91.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils91.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils91.AST_NODE_TYPES.CallExpression) 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_utils91.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        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();
       };
@@ -17085,38 +17522,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils91.AST_NODE_TYPES.BinaryExpression || current.type === import_utils91.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils91.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils91.AST_NODE_TYPES.CallExpression) 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_utils91.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        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_utils91.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 = unwrap6(node.callee);
-        if (callee.type === import_utils91.AST_NODE_TYPES.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils91.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        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_utils91.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 = unwrap6(callee.object);
-        while (receiver.type === import_utils91.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap6(receiver.object);
-        if (receiver.type === import_utils91.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils91.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        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_utils91.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_utils91.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_utils91.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 = unwrap6(node.callee);
-        if (callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        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_utils91.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) => {
@@ -17137,15 +17574,15 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap6(node);
-        return current.type === import_utils91.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils91.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        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 = unwrap6(node);
-        if (current.type === import_utils91.AST_NODE_TYPES.Identifier) return [current.name];
-        if (current.type === import_utils91.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
-        if (current.type === import_utils91.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
-        if (current.type === import_utils91.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
-        if (current.type === import_utils91.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils91.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
+        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) => {
@@ -17160,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_utils91.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils91.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 });
@@ -17173,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_utils91.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_utils91.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_utils91.AST_NODE_TYPES.Property || property.value.type !== import_utils91.AST_NODE_TYPES.Identifier) continue;
-              const key = property.key.type === import_utils91.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils91.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_utils91.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_utils91.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 = unwrap6(node.right);
-          const collection = right.type === import_utils91.AST_NODE_TYPES.Identifier && visible("collections", right.name);
-          const left = node.left.type === import_utils91.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils91.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
+          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([
@@ -17217,7 +17654,7 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/sole-export-matches-filename.ts
-var import_utils92 = require("@typescript-eslint/utils");
+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.",
@@ -17234,29 +17671,21 @@ var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
 };
 var EXCLUDED_STEMS = /* @__PURE__ */ new Set([
   "common",
-  "config",
-  "constants",
-  "error",
-  "errors",
   "global",
-  "handler",
   "helpers",
   "index",
   "layout",
   "loading",
   "middleware",
   "misc",
-  "models",
   "not-found",
   "page",
   "route",
-  "schema",
   "shared",
   "template",
   "types",
   "util",
-  "utils",
-  "worker"
+  "utils"
 ]);
 function stem3(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
@@ -17268,10 +17697,10 @@ function kebabCase(name) {
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === import_utils92.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils92.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils92.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== import_utils92.AST_NODE_TYPES.VariableDeclaration) 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_utils92.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === import_utils93.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -17295,31 +17724,31 @@ var sole_export_matches_filename_default = createRule({
         const exports2 = [];
         const publicExports = /* @__PURE__ */ new Set();
         for (const statement of program.body) {
-          if (statement.type === import_utils92.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils92.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
-          if (statement.type === import_utils92.AST_NODE_TYPES.ExportDefaultDeclaration) {
+          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_utils92.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils92.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
+            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_utils92.AST_NODE_TYPES.ExportNamedDeclaration) continue;
+          if (statement.type !== import_utils93.AST_NODE_TYPES.ExportNamedDeclaration) continue;
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils92.AST_NODE_TYPES.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils93.AST_NODE_TYPES.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === import_utils92.AST_NODE_TYPES.VariableDeclaration) {
+          if (declaration?.type === import_utils93.AST_NODE_TYPES.VariableDeclaration) {
             for (const item of declaration.declarations) {
-              if (item.id.type === import_utils92.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
+              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_utils92.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            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_utils92.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            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 });
@@ -17377,7 +17806,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils93 = 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.",
@@ -17509,18 +17938,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils93.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_utils93.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils94.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils93.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils93.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -17531,13 +17960,13 @@ var chainMemberNames = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils93.AST_NODE_TYPES.MemberExpression) {
-      if (current.computed || current.property.type !== import_utils93.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_utils93.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -17548,16 +17977,16 @@ var chainMemberNames = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === import_utils93.AST_NODE_TYPES.TSAsExpression || current.type === import_utils93.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils93.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils93.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_utils93.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_utils93.AST_NODE_TYPES.Program || owner.type === import_utils93.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils93.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",
@@ -17577,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_utils93.ASTUtils.findVariable(
+      return import_utils94.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -17598,8 +18027,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === import_utils93.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils93.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils93.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);
@@ -17619,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_utils93.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils93.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils93.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils93.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);
           }
         }
@@ -17628,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_utils93.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);
@@ -17803,6 +18232,7 @@ 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,
@@ -17815,7 +18245,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.15.0"
+  version: "15.16.0"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",
@@ -17825,8 +18255,10 @@ var APPLICATION_ONLY_RULES = [
 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"
@@ -17886,7 +18318,7 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-module-level-schema": "error",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
-  "@sarj/prefer-node-fs-promises": "error",
+  "@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",
@@ -17900,6 +18332,7 @@ 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",
@@ -17972,7 +18405,7 @@ var STRICT_RULES = {
   "@sarj/prefer-module-level-schema": "error",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
-  "@sarj/prefer-node-fs-promises": "error",
+  "@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",
@@ -17986,6 +18419,7 @@ 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",