@sarj/eslint-plugin 15.17.11 → 15.17.13

package/dist/index.cjs

@@ -16425,6 +16425,9 @@ var MODULE_LEVEL_RESHAPERS = /* @__PURE__ */ new Set([
   "pipe",
   "preprocess"
 ]);
+function isPreferZodInferModuleReshaper(name) {
+  return MODULE_LEVEL_RESHAPERS.has(name);
+}
 var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "ZodType",
   "ZodSchema",
@@ -16432,6 +16435,9 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "ZodMiniType",
   "Schema"
 ]);
+function isPreferZodInferTypeConstraintName(name) {
+  return ZOD_TYPE_CONSTRAINTS.has(name);
+}
 var LEAF_NODE_TYPES = {
   string: [import_utils85.AST_NODE_TYPES.TSStringKeyword],
   email: [import_utils85.AST_NODE_TYPES.TSStringKeyword],
@@ -16607,6 +16613,21 @@ function unwrapNullish(annotation) {
   }
   return { core: rest.length === 0 ? null : annotation, nullable };
 }
+function preferZodInferOwnsDefaultTwin(input) {
+  if (input.constrained || input.reshaped || normalizeSchemaName(input.schemaName) !== normalizeTypeName(input.typeName)) {
+    return false;
+  }
+  const fields = twinSchemaFields(input.initializer, input.zodNamespaces);
+  const members = twinTypeMembers(input.declaration);
+  if (fields === null || members === null || fields.size !== members.size) return false;
+  for (const [name, field] of fields) {
+    const member = members.get(name);
+    if (member === void 0 || field.reshaped || field.optional !== member.optional || field.nullable !== member.nullable || member.readonly || leafAgrees(field, member.annotation) !== true) {
+      return false;
+    }
+  }
+  return true;
+}
 function leafAgrees(field, annotation) {
   if (field.domain === null) {
     return false;
@@ -16666,6 +16687,100 @@ function staticStringUnionDomain(node) {
   const domain = exactDomain(keys);
   return domain !== null && domain.size >= 2 ? domain : null;
 }
+function twinCallChain(node, zodNamespaces) {
+  const chain = [];
+  let current = node;
+  while (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+    const callee = current.callee;
+    if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils85.AST_NODE_TYPES.Identifier) {
+      return null;
+    }
+    chain.push(current);
+    if (callee.object.type === import_utils85.AST_NODE_TYPES.Identifier) {
+      return zodNamespaces.has(callee.object.name) ? chain.reverse() : null;
+    }
+    current = callee.object;
+  }
+  return null;
+}
+function twinMethodName(call) {
+  const callee = call.callee;
+  return callee.type === import_utils85.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils85.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+}
+function twinSchemaFields(initializer, zodNamespaces) {
+  const chain = twinCallChain(initializer, zodNamespaces);
+  if (chain === null || chain.length === 0) return null;
+  const [base, ...rest] = chain;
+  if (base === void 0) return null;
+  const baseMethod = twinMethodName(base);
+  if (baseMethod !== "object" && baseMethod !== "strictObject") return null;
+  if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(twinMethodName(call)))) return null;
+  const shape = base.arguments[0];
+  if (shape === void 0 || shape.type !== import_utils85.AST_NODE_TYPES.ObjectExpression) return null;
+  const fields = /* @__PURE__ */ new Map();
+  for (const property of shape.properties) {
+    if (property.type !== import_utils85.AST_NODE_TYPES.Property || property.computed) return null;
+    const { key } = property;
+    const name = key.type === import_utils85.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils85.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+    if (name === null) return null;
+    fields.set(name, twinSchemaField(property.value, zodNamespaces));
+  }
+  return fields.size === 0 ? null : fields;
+}
+function twinSchemaField(node, zodNamespaces) {
+  const modifiers = [];
+  let current = node;
+  let leaf = null;
+  let leafCall = null;
+  while (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+    const callee = current.callee;
+    if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils85.AST_NODE_TYPES.Identifier) {
+      break;
+    }
+    const receiver = callee.object;
+    if (receiver.type === import_utils85.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+      leaf = callee.property.name;
+      leafCall = current;
+      break;
+    }
+    modifiers.push(callee.property.name);
+    current = receiver;
+  }
+  return {
+    domain: modifiers.every((name) => DOMAIN_PRESERVING_MODIFIERS.has(name)) ? staticZodDomain(leaf, leafCall) : null,
+    leaf,
+    optional: modifiers.some((name) => OPTIONAL_MODIFIERS.has(name)),
+    nullable: modifiers.some((name) => NULLABLE_MODIFIERS.has(name)),
+    reshaped: modifiers.some((name) => RESHAPING_MODIFIERS.has(name))
+  };
+}
+function twinTypeMembers(declaration) {
+  let members;
+  if (declaration.type === import_utils85.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    if (declaration.typeParameters !== void 0 || (declaration.extends?.length ?? 0) > 0) return null;
+    members = declaration.body.body;
+  } else {
+    if (declaration.typeParameters !== void 0 || declaration.typeAnnotation.type !== import_utils85.AST_NODE_TYPES.TSTypeLiteral) {
+      return null;
+    }
+    members = declaration.typeAnnotation.members;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (member.type !== import_utils85.AST_NODE_TYPES.TSPropertySignature || member.computed) return null;
+    const { key } = member;
+    const name = key.type === import_utils85.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils85.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+    if (name === null) return null;
+    const annotation = member.typeAnnotation?.typeAnnotation ?? null;
+    result.set(name, {
+      optional: member.optional === true,
+      nullable: annotation !== null && unwrapNullish(annotation).nullable,
+      readonly: member.readonly === true,
+      annotation
+    });
+  }
+  return result.size === 0 ? null : result;
+}
 function nameTokens(name) {
   return name.replace(/([a-z\d])([A-Z])/gu, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2").split(/[^A-Za-z\d]+/u).filter((token) => token !== "").map((token) => token.toLowerCase());
 }
@@ -16722,27 +16837,6 @@ var prefer_zod_infer_default = createRule({
     const typeDeclarations = [];
     const constrainedTypeNames = /* @__PURE__ */ new Set();
     const reshapedSchemaNames = /* @__PURE__ */ new Set();
-    function zodCallChain(node) {
-      const chain = [];
-      let current = node;
-      while (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
-        const callee = current.callee;
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils85.AST_NODE_TYPES.Identifier) {
-          return null;
-        }
-        chain.push(current);
-        const receiver = callee.object;
-        if (receiver.type === import_utils85.AST_NODE_TYPES.Identifier) {
-          return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
-        }
-        current = receiver;
-      }
-      return null;
-    }
-    function methodName2(call) {
-      const callee = call.callee;
-      return callee.type === import_utils85.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils85.AST_NODE_TYPES.Identifier ? callee.property.name : "";
-    }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
@@ -16753,42 +16847,13 @@ var prefer_zod_infer_default = createRule({
         }
       }
     }
-    function schemaField(node) {
-      const modifiers = [];
-      let current = node;
-      let leaf = null;
-      let leafCall = null;
-      while (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
-        const callee = current.callee;
-        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils85.AST_NODE_TYPES.Identifier) {
-          break;
-        }
-        const receiver = callee.object;
-        if (receiver.type === import_utils85.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
-          leaf = callee.property.name;
-          leafCall = current;
-          break;
-        }
-        modifiers.push(callee.property.name);
-        current = receiver;
-      }
-      return {
-        domain: modifiers.every(
-          (name) => DOMAIN_PRESERVING_MODIFIERS.has(name)
-        ) ? staticZodDomain(leaf, leafCall) : null,
-        leaf,
-        optional: modifiers.some((name) => OPTIONAL_MODIFIERS.has(name)),
-        nullable: modifiers.some((name) => NULLABLE_MODIFIERS.has(name)),
-        reshaped: modifiers.some((name) => RESHAPING_MODIFIERS.has(name))
-      };
-    }
     function enumSchemaDomain(init) {
-      const chain = zodCallChain(init);
+      const chain = twinCallChain(init, zodNamespaces);
       if (chain === null || chain.length !== 1) {
         return null;
       }
       const [call] = chain;
-      if (call === void 0 || methodName2(call) !== "enum") {
+      if (call === void 0 || twinMethodName(call) !== "enum") {
         return null;
       }
       const domain = staticZodDomain("enum", call);
@@ -16832,111 +16897,25 @@ var prefer_zod_infer_default = createRule({
         });
       }
     }
-    function schemaFields(init) {
-      const chain = zodCallChain(init);
-      if (chain === null || chain.length === 0) {
-        return null;
-      }
-      const [base, ...rest] = chain;
-      if (base === void 0) {
-        return null;
-      }
-      const baseMethod = methodName2(base);
-      if (baseMethod !== "object" && baseMethod !== "strictObject") {
-        return null;
-      }
-      if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(methodName2(call)))) {
-        return null;
-      }
-      const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils85.AST_NODE_TYPES.ObjectExpression) {
-        return null;
-      }
-      const fields = /* @__PURE__ */ new Map();
-      for (const property of shape.properties) {
-        if (property.type !== import_utils85.AST_NODE_TYPES.Property || property.computed) {
-          return null;
-        }
-        const { key } = property;
-        const name = key.type === import_utils85.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils85.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
-        if (name === null) {
-          return null;
-        }
-        fields.set(name, schemaField(property.value));
-      }
-      return fields.size === 0 ? null : fields;
-    }
-    function typeMembers(members) {
-      const result = /* @__PURE__ */ new Map();
-      for (const member of members) {
-        if (member.type !== import_utils85.AST_NODE_TYPES.TSPropertySignature || member.computed) {
-          return null;
-        }
-        const { key } = member;
-        const name = key.type === import_utils85.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils85.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
-        if (name === null) {
-          return null;
-        }
-        const annotation = member.typeAnnotation?.typeAnnotation ?? null;
-        result.set(name, {
-          optional: member.optional === true,
-          nullable: annotation !== null && unwrapNullish(annotation).nullable,
-          readonly: member.readonly === true,
-          annotation
-        });
-      }
-      return result.size === 0 ? null : result;
-    }
-    function collectConstrainedNames(node) {
+    function collectConstrainedNames2(node) {
       if (node.type === import_utils85.AST_NODE_TYPES.TSTypeReference) {
         if (node.typeName.type === import_utils85.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
-          collectConstrainedNames(argument);
+          collectConstrainedNames2(argument);
         }
         return;
       }
       if (node.type === import_utils85.AST_NODE_TYPES.TSArrayType) {
-        collectConstrainedNames(node.elementType);
+        collectConstrainedNames2(node.elementType);
         return;
       }
       if (node.type === import_utils85.AST_NODE_TYPES.TSUnionType || node.type === import_utils85.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
-          collectConstrainedNames(member);
-        }
-      }
-    }
-    function isTwin(fields, members) {
-      if (!requireIdenticalShape) {
-        return true;
-      }
-      if (fields.size !== members.size) {
-        return false;
-      }
-      for (const [name, field] of fields) {
-        const member = members.get(name);
-        if (member === void 0) {
-          return false;
-        }
-        if (field.reshaped) {
-          return false;
-        }
-        if (field.optional !== member.optional) {
-          return false;
-        }
-        if (field.nullable !== member.nullable) {
-          return false;
-        }
-        if (member.readonly) {
-          return false;
-        }
-        const agrees = leafAgrees(field, member.annotation);
-        if (agrees !== true) {
-          return false;
+          collectConstrainedNames2(member);
         }
       }
-      return true;
     }
     return {
       Program(node) {
@@ -16953,9 +16932,9 @@ var prefer_zod_infer_default = createRule({
         if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier || node.init == null || !isModuleLevelConst(node)) {
           return;
         }
-        const fields = schemaFields(node.init);
+        const fields = twinSchemaFields(node.init, zodNamespaces);
         if (fields !== null) {
-          schemas.push({ name: node.id.name, fields });
+          schemas.push({ name: node.id.name, fields, initializer: node.init });
         }
         if (isModuleLevelConst(node)) {
           const domain = enumSchemaDomain(node.init);
@@ -16967,7 +16946,7 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils85.AST_NODE_TYPES.Identifier && node.property.type === import_utils85.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils85.AST_NODE_TYPES.Identifier && node.property.type === import_utils85.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
@@ -16975,11 +16954,11 @@ var prefer_zod_infer_default = createRule({
       TSTypeReference(node) {
         const { typeName } = node;
         const referenced = typeName.type === import_utils85.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils85.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils85.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
-        if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
+        if (referenced === null || !isPreferZodInferTypeConstraintName(referenced)) {
           return;
         }
         for (const argument of node.typeArguments?.params ?? []) {
-          collectConstrainedNames(argument);
+          collectConstrainedNames2(argument);
         }
       },
       TSInterfaceDeclaration(node) {
@@ -16987,9 +16966,9 @@ var prefer_zod_infer_default = createRule({
         if (node.typeParameters !== void 0 || (node.extends?.length ?? 0) > 0) {
           return;
         }
-        const members = typeMembers(node.body.body);
+        const members = twinTypeMembers(node);
         if (members !== null) {
-          typeDeclarations.push({ name: node.id.name, node: node.id, members });
+          typeDeclarations.push({ declaration: node, name: node.id.name, node: node.id, members });
         }
         recordLiteralUnions(
           node.body.body,
@@ -17011,9 +16990,9 @@ var prefer_zod_infer_default = createRule({
         if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils85.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
-        const members = typeMembers(node.typeAnnotation.members);
+        const members = twinTypeMembers(node);
         if (members !== null) {
-          typeDeclarations.push({ name: node.id.name, node: node.id, members });
+          typeDeclarations.push({ declaration: node, name: node.id.name, node: node.id, members });
         }
         recordLiteralUnions(
           node.typeAnnotation.members,
@@ -17042,7 +17021,15 @@ var prefer_zod_infer_default = createRule({
           if (schema === void 0 || reshapedSchemaNames.has(schema.name)) {
             continue;
           }
-          if (!isTwin(schema.fields, declaration.members)) {
+          if (requireIdenticalShape ? !preferZodInferOwnsDefaultTwin({
+            constrained: constrainedTypeNames.has(declaration.name),
+            declaration: declaration.declaration,
+            initializer: schema.initializer,
+            reshaped: reshapedSchemaNames.has(schema.name),
+            schemaName: schema.name,
+            typeName: declaration.name,
+            zodNamespaces
+          }) : false) {
             continue;
           }
           twinTypeNames.add(declaration.name);
@@ -17106,9 +17093,349 @@ var prefer_zod_infer_default = createRule({
   }
 });
 
-// src/rules/require-assert-never.ts
+// src/rules/prefer-zod-parse-output-type.ts
 var import_utils86 = require("@typescript-eslint/utils");
 var import_typescript2 = __toESM(require("typescript"), 1);
+var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
+  summary: "Derive a function's return contract from the local Zod schema whose parsed output it returns.",
+  rationale: "A hand-written contract can drift from the runtime-validated value even while each declaration remains locally valid.",
+  remediation: "Export or colocate the schema and derive the contract with `z.output<typeof Schema>`.",
+  category: "correctness",
+  autofix: "none",
+  limitations: [
+    "Requires TypeScript type information and a direct return of a module-level local Zod object schema's `.parse()` result.",
+    "Same-module name-correlated twins that `prefer-zod-infer` can prove are left to that established rule; this companion owns richer or renamed same-module and cross-module contracts proven by parse-return data flow.",
+    "Only a single plain non-generic object interface or object type alias with exact property keys and bidirectional assignability is reported.",
+    "Nullish conditional branches are followed; aliases, assignments, helper calls, imported schemas, and other indirect data flow are intentionally excluded.",
+    "Contracts returned from more than one distinct local schema are excluded because no single schema has unambiguous ownership.",
+    "Readonly, augmented, indexed, callable, generated, constrained, any, unknown, and never contracts are excluded rather than guessed.",
+    "The rule is report-only because moving or exporting a schema changes module ownership and requires human review."
+  ],
+  examples: [
+    {
+      id: "schema-derived-return",
+      title: "Derive the validated return contract",
+      outcome: "no-match",
+      files: [
+        {
+          path: "src/row.ts",
+          source: 'import { z } from "zod"; const RowSchema = z.object({ id: z.string() }); type Row = z.output<typeof RowSchema>; function load(): Row { return RowSchema.parse({}); }'
+        }
+      ],
+      focusPath: "src/row.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "hand-written-parsed-return",
+      title: "Do not hand-write the parsed return shape",
+      outcome: "match",
+      files: [
+        {
+          path: "src/contracts.ts",
+          source: "export interface ParsedRow { id: string }"
+        },
+        {
+          path: "src/row.ts",
+          source: 'import { z } from "zod"; import type { ParsedRow } from "./contracts.js"; const RowSchema = z.object({ id: z.string() }); function load(): ParsedRow { return RowSchema.parse({}); }'
+        }
+      ],
+      focusPath: "src/row.ts",
+      expectedCount: 1,
+      public: true
+    }
+  ]
+};
+function isModuleLevelConst2(node) {
+  const declaration = node.parent;
+  if (declaration.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+    return false;
+  }
+  const container = declaration.parent;
+  return container.type === import_utils86.AST_NODE_TYPES.Program || container.type === import_utils86.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils86.AST_NODE_TYPES.Program;
+}
+function isLocalZodObjectSchema(node, namespaces) {
+  let current = node;
+  while (current.type === import_utils86.AST_NODE_TYPES.CallExpression) {
+    const { callee } = current;
+    if (callee.type !== import_utils86.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils86.AST_NODE_TYPES.Identifier) {
+      return false;
+    }
+    if (callee.object.type === import_utils86.AST_NODE_TYPES.Identifier) {
+      return namespaces.has(callee.object.name) && (callee.property.name === "object" || callee.property.name === "strictObject");
+    }
+    current = callee.object;
+  }
+  return false;
+}
+function parsedReturnCandidate(node) {
+  const { callee } = node;
+  if (callee.type !== import_utils86.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils86.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils86.AST_NODE_TYPES.Identifier || callee.property.name !== "parse") {
+    return null;
+  }
+  const owner = directReturnOwner(node);
+  const annotation = owner?.returnType?.typeAnnotation;
+  if (annotation === void 0) return null;
+  const typeReference = returnContractReference(annotation);
+  if (typeReference === null || typeReference.typeName.type !== import_utils86.AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  return {
+    call: node,
+    schema: callee.object,
+    typeName: typeReference.typeName.name,
+    typeReference
+  };
+}
+function directReturnOwner(node) {
+  let current = node;
+  while (current.parent !== void 0) {
+    const parent = current.parent;
+    if (parent.type === import_utils86.AST_NODE_TYPES.ReturnStatement) {
+      return parent.argument === current ? enclosingFunction4(parent) : null;
+    }
+    if (parent.type === import_utils86.AST_NODE_TYPES.ArrowFunctionExpression && parent.expression && parent.body === current) {
+      return parent;
+    }
+    if (parent.type === import_utils86.AST_NODE_TYPES.AwaitExpression && parent.argument === current) {
+      current = parent;
+      continue;
+    }
+    if (parent.type === import_utils86.AST_NODE_TYPES.ConditionalExpression) {
+      const parsedWhenTrue = parent.consequent === current && isNullishExpression(parent.alternate);
+      const parsedWhenFalse = parent.alternate === current && isNullishExpression(parent.consequent);
+      if (parsedWhenTrue || parsedWhenFalse) {
+        current = parent;
+        continue;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function isNullishExpression(node) {
+  return node.type === import_utils86.AST_NODE_TYPES.Literal && node.value === null || node.type === import_utils86.AST_NODE_TYPES.Identifier && node.name === "undefined";
+}
+function enclosingFunction4(node) {
+  let current = node.parent;
+  while (current !== void 0) {
+    if (current.type === import_utils86.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils86.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils86.AST_NODE_TYPES.FunctionExpression) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function returnContractReference(node) {
+  if (node.type === import_utils86.AST_NODE_TYPES.TSUnionType) {
+    const substantive = node.types.filter(
+      (member) => member.type !== import_utils86.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils86.AST_NODE_TYPES.TSUndefinedKeyword
+    );
+    const [only] = substantive;
+    return substantive.length === 1 && only !== void 0 ? returnContractReference(only) : null;
+  }
+  if (node.type === import_utils86.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils86.AST_NODE_TYPES.Identifier && node.typeName.name === "Promise") {
+    const parameters = node.typeArguments?.params ?? [];
+    const [only] = parameters;
+    return parameters.length === 1 && only !== void 0 ? returnContractReference(only) : null;
+  }
+  return node.type === import_utils86.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils86.AST_NODE_TYPES.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
+}
+function recordZodNamespaces(node, namespaces) {
+  for (const statement of node.body) {
+    if (statement.type !== import_utils86.AST_NODE_TYPES.ImportDeclaration || !isZodModule(statement.source.value)) {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === import_utils86.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils86.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+        namespaces.add(specifier.local.name);
+      }
+    }
+  }
+}
+function collectConstrainedNames(node, names) {
+  if (node.type === import_utils86.AST_NODE_TYPES.TSTypeReference) {
+    if (node.typeName.type === import_utils86.AST_NODE_TYPES.Identifier) names.add(node.typeName.name);
+    for (const argument of node.typeArguments?.params ?? []) {
+      collectConstrainedNames(argument, names);
+    }
+    return;
+  }
+  if (node.type === import_utils86.AST_NODE_TYPES.TSArrayType) {
+    collectConstrainedNames(node.elementType, names);
+    return;
+  }
+  if (node.type === import_utils86.AST_NODE_TYPES.TSUnionType || node.type === import_utils86.AST_NODE_TYPES.TSIntersectionType) {
+    for (const member of node.types) collectConstrainedNames(member, names);
+  }
+}
+function reportCandidates(context, services, schemas, candidates, zodNamespaces, reshapedSchemas, constrainedTypeNames) {
+  const checker = services.program.getTypeChecker();
+  const schemaSymbols = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const tsIdentifier = services.esTreeNodeToTSNodeMap.get(schema.identifier);
+    const symbol = checker.getSymbolAtLocation(tsIdentifier);
+    if (symbol !== void 0) schemaSymbols.set(symbol, schema);
+  }
+  const eligible2 = [];
+  const reported = /* @__PURE__ */ new Set();
+  for (const candidate2 of candidates) {
+    const tsSchema = services.esTreeNodeToTSNodeMap.get(candidate2.schema);
+    const schemaSymbol = checker.getSymbolAtLocation(tsSchema);
+    if (schemaSymbol === void 0) continue;
+    const schema = schemaSymbols.get(schemaSymbol);
+    if (schema === void 0) continue;
+    const tsReference = services.esTreeNodeToTSNodeMap.get(candidate2.typeReference);
+    const contract = checker.getTypeAtLocation(tsReference);
+    const contractSymbol = contract.aliasSymbol ?? contract.getSymbol();
+    if (contractSymbol === void 0) continue;
+    const declaration = handWrittenObjectDeclaration(contractSymbol);
+    if (declaration === null || declaration.getSourceFile().isDeclarationFile) continue;
+    const source = declaration.getSourceFile();
+    if (isGeneratedFile(source.fileName, source.text)) continue;
+    const tsCall = services.esTreeNodeToTSNodeMap.get(candidate2.call);
+    const parsed = checker.getTypeAtLocation(tsCall);
+    const constrained = constrainedTypeNames.has(candidate2.typeName) || (parsed.aliasSymbol ?? parsed.getSymbol()) === contractSymbol;
+    if (constrained) continue;
+    if (declaration.getSourceFile() === tsSchema.getSourceFile()) {
+      const estreeDeclaration = services.tsNodeToESTreeNodeMap.get(declaration);
+      if ((estreeDeclaration.type === import_utils86.AST_NODE_TYPES.TSInterfaceDeclaration || estreeDeclaration.type === import_utils86.AST_NODE_TYPES.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
+        constrained,
+        declaration: estreeDeclaration,
+        initializer: schema.initializer,
+        reshaped: reshapedSchemas.has(schema.name),
+        schemaName: schema.name,
+        typeName: candidate2.typeName,
+        zodNamespaces
+      })) {
+        continue;
+      }
+    }
+    if (!exactObjectTypes(
+      checker,
+      checker.getNonNullableType(parsed),
+      checker.getNonNullableType(contract)
+    )) {
+      continue;
+    }
+    eligible2.push({ candidate: candidate2, contractSymbol, schema, schemaSymbol });
+  }
+  const schemasByContract = /* @__PURE__ */ new Map();
+  for (const { contractSymbol, schemaSymbol } of eligible2) {
+    const contractSchemas = schemasByContract.get(contractSymbol) ?? /* @__PURE__ */ new Set();
+    contractSchemas.add(schemaSymbol);
+    schemasByContract.set(contractSymbol, contractSchemas);
+  }
+  for (const { candidate: candidate2, contractSymbol, schema } of eligible2) {
+    if (reported.has(contractSymbol) || schemasByContract.get(contractSymbol)?.size !== 1) continue;
+    reported.add(contractSymbol);
+    context.report({
+      node: candidate2.typeReference,
+      messageId: "handWrittenParsedOutput",
+      data: { schemaName: schema.name, typeName: candidate2.typeName }
+    });
+  }
+}
+function handWrittenObjectDeclaration(symbol) {
+  const declarations = symbol.getDeclarations() ?? [];
+  const [declaration] = declarations;
+  if (declarations.length !== 1 || declaration === void 0) return null;
+  const plainMembers = (members) => members.length > 0 && members.every(
+    (member) => import_typescript2.default.isPropertySignature(member) && member.type !== void 0 && member.modifiers?.some((modifier) => modifier.kind === import_typescript2.default.SyntaxKind.ReadonlyKeyword) !== true
+  );
+  if (import_typescript2.default.isInterfaceDeclaration(declaration) && declaration.typeParameters === void 0 && declaration.heritageClauses === void 0 && plainMembers(declaration.members)) {
+    return declaration;
+  }
+  if (import_typescript2.default.isTypeAliasDeclaration(declaration) && declaration.typeParameters === void 0 && import_typescript2.default.isTypeLiteralNode(declaration.type) && plainMembers(declaration.type.members)) {
+    return declaration;
+  }
+  return null;
+}
+function exactObjectTypes(checker, parsed, contract) {
+  const unsafeFlags = import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown | import_typescript2.default.TypeFlags.Never;
+  if ((parsed.flags & unsafeFlags) !== 0 || (contract.flags & unsafeFlags) !== 0) return false;
+  if (checker.getIndexInfosOfType(parsed).length > 0 || checker.getIndexInfosOfType(contract).length > 0 || checker.getSignaturesOfType(parsed, import_typescript2.default.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(contract, import_typescript2.default.SignatureKind.Call).length > 0) {
+    return false;
+  }
+  const names = (type) => checker.getPropertiesOfType(type).map((property) => property.getName()).sort();
+  const parsedNames = names(parsed);
+  const contractNames = names(contract);
+  return parsedNames.length > 0 && parsedNames.length === contractNames.length && parsedNames.every((name, index) => name === contractNames[index]) && checker.isTypeAssignableTo(parsed, contract) && checker.isTypeAssignableTo(contract, parsed);
+}
+var prefer_zod_parse_output_type_default = createRule({
+  name: "prefer-zod-parse-output-type",
+  documentation: PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Derive a function's return contract from the local Zod schema whose parsed output it returns."
+    },
+    schema: [],
+    messages: {
+      handWrittenParsedOutput: "`{{typeName}}` exactly restates the validated output returned by `{{schemaName}}.parse()`. Export or colocate the schema and derive the contract with `z.output<typeof {{schemaName}}>` so the runtime and compile-time shapes cannot drift."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isStoryFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    let services;
+    try {
+      services = import_utils86.ESLintUtils.getParserServices(context);
+    } catch {
+      services = null;
+    }
+    if (services === null) return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    const constrainedTypeNames = /* @__PURE__ */ new Set();
+    const reshapedSchemas = /* @__PURE__ */ new Set();
+    const schemas = [];
+    const candidates = [];
+    return {
+      Program(node) {
+        recordZodNamespaces(node, namespaces);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === import_utils86.AST_NODE_TYPES.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
+          schemas.push({ identifier: node.id, initializer: node.init, name: node.id.name });
+        }
+      },
+      CallExpression(node) {
+        const candidate2 = parsedReturnCandidate(node);
+        if (candidate2 !== null) candidates.push(candidate2);
+      },
+      "MemberExpression[computed=false]"(node) {
+        if (node.object.type === import_utils86.AST_NODE_TYPES.Identifier && node.property.type === import_utils86.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+          reshapedSchemas.add(node.object.name);
+        }
+      },
+      TSTypeReference(node) {
+        const { typeName } = node;
+        const name = typeName.type === import_utils86.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils86.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils86.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        if (name === null || !isPreferZodInferTypeConstraintName(name)) return;
+        for (const argument of node.typeArguments?.params ?? []) {
+          collectConstrainedNames(argument, constrainedTypeNames);
+        }
+      },
+      "Program:exit"() {
+        reportCandidates(
+          context,
+          services,
+          schemas,
+          candidates,
+          namespaces,
+          reshapedSchemas,
+          constrainedTypeNames
+        );
+      }
+    };
+  }
+});
+
+// src/rules/require-assert-never.ts
+var import_utils87 = require("@typescript-eslint/utils");
+var import_typescript3 = __toESM(require("typescript"), 1);
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
   rationale: "An empty default silently accepts new union members instead of making the compiler identify the missing case.",
@@ -17121,14 +17448,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils86.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils86.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils87.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils87.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils86.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils86.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils87.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils87.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils86.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils87.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -17144,7 +17471,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils86.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils87.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -17156,7 +17483,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   const constituents = discriminantType.isUnion() ? discriminantType.types : [discriminantType];
   if (!discriminantType.isUnion() || constituents.length < 2) return false;
   if (constituents.every(
-    (constituent) => (constituent.flags & import_typescript2.default.TypeFlags.BooleanLiteral) !== 0
+    (constituent) => (constituent.flags & import_typescript3.default.TypeFlags.BooleanLiteral) !== 0
   )) {
     return false;
   }
@@ -17178,7 +17505,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   return [...expected].every((key) => handled.has(key));
 }
 function finiteTypeKey(type, checker) {
-  const finiteFlags = import_typescript2.default.TypeFlags.StringLiteral | import_typescript2.default.TypeFlags.NumberLiteral | import_typescript2.default.TypeFlags.BooleanLiteral | import_typescript2.default.TypeFlags.EnumLiteral | import_typescript2.default.TypeFlags.UniqueESSymbol | import_typescript2.default.TypeFlags.Null | import_typescript2.default.TypeFlags.Undefined;
+  const finiteFlags = import_typescript3.default.TypeFlags.StringLiteral | import_typescript3.default.TypeFlags.NumberLiteral | import_typescript3.default.TypeFlags.BooleanLiteral | import_typescript3.default.TypeFlags.EnumLiteral | import_typescript3.default.TypeFlags.UniqueESSymbol | import_typescript3.default.TypeFlags.Null | import_typescript3.default.TypeFlags.Undefined;
   return (type.flags & finiteFlags) !== 0 ? checker.typeToString(type) : null;
 }
 var require_assert_never_default = createRule({
@@ -17198,7 +17525,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils86.ESLintUtils.getParserServices(context);
+      services = import_utils87.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -17225,7 +17552,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils87 = require("@typescript-eslint/utils");
+var import_utils88 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an explicit abort signal on locally analyzable global fetch calls.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -17252,14 +17579,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils87.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils88.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils87.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils88.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils87.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils87.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils88.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils88.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -17269,7 +17596,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === import_utils87.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils87.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils87.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils87.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils88.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils88.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils88.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils88.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -17307,30 +17634,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils87.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils88.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils87.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils88.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils87.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils87.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils87.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils88.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils88.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils88.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils87.ASTUtils.findVariable(
+      const variable = import_utils88.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils87.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils88.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
         return false;
       }
       for (const reference of variable.references) {
         const ref = reference.identifier;
         if (ref === identifier || ref === definition.name) continue;
         const member = ref.parent;
-        if (member.type !== import_utils87.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils87.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils87.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils88.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils88.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils88.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -17338,13 +17665,13 @@ var require_fetch_timeout_default = createRule({
     }
     function isForwardedRequest(argument) {
       let value = argument;
-      if (value.type === import_utils87.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils87.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
+      if (value.type === import_utils88.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils88.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
         const definition = binding?.defs.length === 1 ? binding.defs[0] : void 0;
         if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || binding?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         value = definition.node.init;
       }
-      return value.type === import_utils87.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils87.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
+      return value.type === import_utils88.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils88.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
     }
     return {
       CallExpression(node) {
@@ -17355,7 +17682,7 @@ var require_fetch_timeout_default = createRule({
         if (first !== void 0 && (node.arguments.length === 1 && !isInlineUrl(first, resolvesToGlobal) || isForwardedRequest(first))) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils87.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils88.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -17364,7 +17691,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-var import_utils88 = require("@typescript-eslint/utils");
+var import_utils89 = require("@typescript-eslint/utils");
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
   summary: "Require exported concrete classes with public behavior to declare a contract.",
   rationale: "An explicit contract names the intended public capability separately from implementation details. TypeScript already supports structural compatibility; this is an architecture policy, not a prerequisite for substitution.",
@@ -17410,23 +17737,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === import_utils88.AST_NODE_TYPES.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils88.AST_NODE_TYPES.PrivateIdentifier;
+    if (member.type === import_utils89.AST_NODE_TYPES.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils89.AST_NODE_TYPES.PrivateIdentifier;
     }
-    if (member.type !== import_utils88.AST_NODE_TYPES.PropertyDefinition || member.static)
+    if (member.type !== import_utils89.AST_NODE_TYPES.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils88.AST_NODE_TYPES.PrivateIdentifier) return false;
-    return member.value?.type === import_utils88.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils88.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils88.AST_NODE_TYPES.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils89.AST_NODE_TYPES.PrivateIdentifier) return false;
+    return member.value?.type === import_utils89.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils89.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === import_utils88.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === import_utils88.AST_NODE_TYPES.ClassDeclaration) {
+  const declaration = statement.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === import_utils89.AST_NODE_TYPES.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== import_utils88.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration?.type !== import_utils89.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils88.AST_NODE_TYPES.Identifier && item.init?.type === import_utils88.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === import_utils89.AST_NODE_TYPES.Identifier && item.init?.type === import_utils89.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -17457,7 +17784,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = /* @__PURE__ */ new Map();
         for (const statement of program.body) {
-          if (statement.type === import_utils88.AST_NODE_TYPES.ExportNamedDeclaration) {
+          if (statement.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration) {
             for (const binding of classBindings(statement)) {
               exported.set(binding.declaration, binding.name);
             }
@@ -17466,18 +17793,18 @@ var require_interface_for_exported_class_default = createRule({
               if (specifier.exportKind === "type") continue;
               const candidate2 = classes.get(specifier.local.name);
               if (candidate2 === void 0) continue;
-              const exportedName = specifier.exported.type === import_utils88.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+              const exportedName = specifier.exported.type === import_utils89.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
               exported.set(candidate2, exportedName);
             }
             continue;
           }
-          if (statement.type !== import_utils88.AST_NODE_TYPES.ExportDefaultDeclaration) continue;
-          if (statement.declaration.type === import_utils88.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils88.AST_NODE_TYPES.ClassExpression) {
+          if (statement.type !== import_utils89.AST_NODE_TYPES.ExportDefaultDeclaration) continue;
+          if (statement.declaration.type === import_utils89.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils89.AST_NODE_TYPES.ClassExpression) {
             exported.set(
               statement.declaration,
               statement.declaration.id?.name ?? "default"
             );
-          } else if (statement.declaration.type === import_utils88.AST_NODE_TYPES.Identifier) {
+          } else if (statement.declaration.type === import_utils89.AST_NODE_TYPES.Identifier) {
             const candidate2 = classes.get(statement.declaration.name);
             if (candidate2 !== void 0) {
               exported.set(candidate2, statement.declaration.name);
@@ -17485,7 +17812,7 @@ var require_interface_for_exported_class_default = createRule({
           }
         }
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils88.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils89.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,
@@ -17499,7 +17826,7 @@ var require_interface_for_exported_class_default = createRule({
 });
 
 // src/rules/require-port-for-service.ts
-var import_utils89 = require("@typescript-eslint/utils");
+var import_utils90 = 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.",
@@ -17524,45 +17851,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_utils89.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils89.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils89.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === import_utils90.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === import_utils90.AST_NODE_TYPES.Identifier) return member.property.name;
+  return member.computed && member.property.type === import_utils90.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_utils89.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils90.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_utils89.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils89.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils90.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils90.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils89.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils89.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils90.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils90.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils89.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils90.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils89.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils90.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils89.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils89.AST_NODE_TYPES.TSNullKeyword
+      (member) => member.type !== import_utils90.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils90.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils89.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils90.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils89.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils89.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils90.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils90.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_utils89.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils89.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils90.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils90.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_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils89.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils90.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils90.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -17573,18 +17900,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_utils89.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils89.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils90.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils89.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils90.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils89.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils89.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils90.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils90.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils89.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils89.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils89.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils90.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils90.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils90.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -17613,10 +17940,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === import_utils89.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils89.AST_NODE_TYPES.FunctionExpression || current.type === import_utils89.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils89.AST_NODE_TYPES.ClassExpression || current.type === import_utils89.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils89.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils89.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils89.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils89.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils89.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils89.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils89.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (current.type === import_utils90.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils90.AST_NODE_TYPES.FunctionExpression || current.type === import_utils90.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils90.AST_NODE_TYPES.ClassExpression || current.type === import_utils90.AST_NODE_TYPES.ClassDeclaration) continue;
+      const expression = current.type === import_utils90.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === import_utils90.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils90.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils90.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== import_utils90.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils90.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils90.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -17629,14 +17956,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils89.AST_NODE_TYPES.TSAsExpression || source.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils89.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils89.AST_NODE_TYPES.NewExpression) {
+      while (source.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils90.AST_NODE_TYPES.TSAsExpression || source.type === import_utils90.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
+      if (source.type === import_utils90.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils89.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils90.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_utils89.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils89.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils90.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils90.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -17654,7 +17981,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_utils89.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === import_utils90.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;
@@ -17669,8 +17996,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils89.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils89.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils90.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils90.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -17679,9 +18006,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils89.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils89.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils89.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils90.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils90.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils90.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -17697,9 +18024,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils89.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils89.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils89.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils90.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils90.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils90.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -17711,11 +18038,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils89.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils89.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils90.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils90.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils89.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils89.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils90.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils90.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -17725,21 +18052,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils89.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils90.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils89.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils89.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils90.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils90.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils89.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils90.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils89.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils89.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils90.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils90.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils90.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils89.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils89.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils90.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils90.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -17766,19 +18093,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils89.AST_NODE_TYPES.ChainExpression || callee.type === import_utils89.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils89.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === import_utils90.AST_NODE_TYPES.ChainExpression || callee.type === import_utils90.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils90.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
+  return callee.type === import_utils90.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === import_utils89.AST_NODE_TYPES.ChainExpression || node.type === import_utils89.AST_NODE_TYPES.TSAsExpression || node.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils89.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils89.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils89.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === import_utils90.AST_NODE_TYPES.ChainExpression || node.type === import_utils90.AST_NODE_TYPES.TSAsExpression || node.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils90.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+  return node.type === import_utils90.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils90.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils89.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils89.AST_NODE_TYPES.ClassExpression || current.type === import_utils89.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils89.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils89.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils90.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils90.AST_NODE_TYPES.ClassExpression || current.type === import_utils90.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils90.AST_NODE_TYPES.FunctionExpression) return;
+    if (current.type === import_utils90.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -17791,14 +18118,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils89.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils89.AST_NODE_TYPES.MethodDefinition) {
+    if (member.type === import_utils90.AST_NODE_TYPES.StaticBlock || member.static) continue;
+    if (member.type === import_utils90.AST_NODE_TYPES.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== import_utils89.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
+    if (member.type !== import_utils90.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === import_utils89.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === import_utils90.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -17818,25 +18145,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils89.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils90.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_utils89.AST_NODE_TYPES.PropertyDefinition) {
+    if (member.type === import_utils90.AST_NODE_TYPES.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.key.type === import_utils89.AST_NODE_TYPES.PrivateIdentifier) continue;
-      if (member.value?.type !== import_utils89.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils89.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils89.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      if (member.key.type === import_utils90.AST_NODE_TYPES.PrivateIdentifier) continue;
+      if (member.value?.type !== import_utils90.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils90.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils90.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils90.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils90.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
       names.push(declaredMemberName(member) ?? "\u2026");
       continue;
     }
-    if (member.type !== import_utils89.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils90.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_utils89.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils90.AST_NODE_TYPES.PrivateIdentifier) continue;
     names.push(declaredMemberName(member) ?? "\u2026");
   }
   return names;
@@ -17844,13 +18171,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_utils89.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === import_utils90.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_utils89.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils90.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils90.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));
   });
 };
@@ -17858,10 +18185,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_utils89.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils89.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils89.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils90.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils90.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils89.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils90.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -17879,8 +18206,8 @@ function localClassAbstractness(program) {
   return classes;
 }
 function declaredMemberName(member) {
-  if (!member.computed && member.key.type === import_utils89.AST_NODE_TYPES.Identifier) return member.key.name;
-  if (member.key.type === import_utils89.AST_NODE_TYPES.Literal && typeof member.key.value === "string") return member.key.value;
+  if (!member.computed && member.key.type === import_utils90.AST_NODE_TYPES.Identifier) return member.key.name;
+  if (member.key.type === import_utils90.AST_NODE_TYPES.Literal && typeof member.key.value === "string") return member.key.value;
   return null;
 }
 function localInterfaceSurfaces(program) {
@@ -17888,45 +18215,45 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils89.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils90.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils90.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils90.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils89.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils89.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils90.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils90.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils90.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_utils89.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils89.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils90.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils90.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== import_utils89.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils90.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== import_utils89.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils90.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils90.AST_NODE_TYPES.TSPropertySignature) continue;
           const name = declaredMemberName(member);
           if (name === null) continue;
-          if (member.type === import_utils89.AST_NODE_TYPES.TSMethodSignature) {
+          if (member.type === import_utils90.AST_NODE_TYPES.TSMethodSignature) {
             callables2.add(name);
             continue;
           }
-          if (member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils90.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils89.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils89.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(name);
+          if (annotation?.type === import_utils90.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils90.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils90.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       continue;
     }
-    if (declaration?.type !== import_utils89.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== import_utils90.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_utils89.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member.type !== import_utils90.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils90.AST_NODE_TYPES.TSPropertySignature) continue;
       const name = declaredMemberName(member);
       if (name === null) continue;
-      if (member.type === import_utils89.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
+      if (member.type === import_utils90.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils90.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils90.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils90.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -17934,7 +18261,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils89.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils90.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -17961,7 +18288,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils89.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils90.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -17973,7 +18300,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_utils89.AST_NODE_TYPES.Identifier) return true;
+    if (implementation.expression.type !== import_utils90.AST_NODE_TYPES.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -18016,7 +18343,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_utils89.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === import_utils90.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -18051,7 +18378,7 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-sql-access-class.ts
-var import_utils90 = require("@typescript-eslint/utils");
+var import_utils91 = require("@typescript-eslint/utils");
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -18146,9 +18473,9 @@ var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
   ]
 };
 function memberName6(node) {
-  if (!node.computed && node.property.type === import_utils90.AST_NODE_TYPES.Identifier)
+  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier)
     return node.property.name;
-  if (node.computed && node.property.type === import_utils90.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
+  if (node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
     return node.property.value;
   return null;
 }
@@ -18160,89 +18487,89 @@ function isDatabaseOperation(method, receiver) {
   return BUILDER_SHORT_TERMINALS.has(method) && expressionCallsBuilder(receiver);
 }
 function databaseReceiver(node) {
-  if (node.type === import_utils90.AST_NODE_TYPES.Identifier)
+  if (node.type === import_utils91.AST_NODE_TYPES.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== import_utils90.AST_NODE_TYPES.MemberExpression) return false;
+  if (node.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return false;
   const name = memberName6(node);
   return name === "DB" || name !== null && DATABASE_NAMES.test(name);
 }
 function databaseRootMember(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils90.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils91.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.TSAsExpression || current.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils91.AST_NODE_TYPES.TSAsExpression || current.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils91.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils90.AST_NODE_TYPES.MemberExpression) return null;
+    if (current.type === import_utils91.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.MemberExpression) {
-      if (current.object.type === import_utils90.AST_NODE_TYPES.ThisExpression)
+    if (current.type === import_utils91.AST_NODE_TYPES.MemberExpression) {
+      if (current.object.type === import_utils91.AST_NODE_TYPES.ThisExpression)
         return memberName6(current);
       current = current.object;
       continue;
     }
-    return current.type === import_utils90.AST_NODE_TYPES.Identifier ? current.name : null;
+    return current.type === import_utils91.AST_NODE_TYPES.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils90.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils91.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.TSAsExpression || current.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils91.AST_NODE_TYPES.TSAsExpression || current.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils91.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils90.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils91.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils91.AST_NODE_TYPES.MemberExpression) {
       const name = memberName6(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === import_utils90.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === import_utils91.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils90.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils91.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.TSAsExpression || current.type === import_utils90.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils90.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils91.AST_NODE_TYPES.TSAsExpression || current.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils91.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils90.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils90.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils91.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return false;
       const name = memberName6(current.callee);
       if (name !== null && BUILDER_METHODS.has(name)) return true;
       current = current.callee.object;
       continue;
     }
-    if (current.type !== import_utils90.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils90.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils90.AST_NODE_TYPES.ClassExpression)
+    if (current.type === import_utils91.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils91.AST_NODE_TYPES.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -18251,25 +18578,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === import_utils90.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === import_utils91.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_utils90.AST_NODE_TYPES.TSParameterProperty) continue;
-    const value = parameter.parameter.type === import_utils90.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === import_utils90.AST_NODE_TYPES.Identifier) injected.add(value.name);
+    if (parameter.type !== import_utils91.AST_NODE_TYPES.TSParameterProperty) continue;
+    const value = parameter.parameter.type === import_utils91.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === import_utils91.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_utils90.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils90.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") continue;
+    if (statement.type !== import_utils91.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils91.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") continue;
     const { left, right } = statement.expression;
-    if (left.type !== import_utils90.AST_NODE_TYPES.MemberExpression) continue;
+    if (left.type !== import_utils91.AST_NODE_TYPES.MemberExpression) continue;
     const target = thisRootMember(left);
     if (target === null) continue;
-    const source = right.type === import_utils90.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils90.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils90.AST_NODE_TYPES.Identifier ? right.object.name : null;
+    const source = right.type === import_utils91.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils91.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils91.AST_NODE_TYPES.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   return injected;
@@ -18277,26 +18604,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === import_utils90.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils91.AST_NODE_TYPES.MemberExpression) {
     const name = memberName6(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === import_utils90.AST_NODE_TYPES.ThisExpression ? root : null;
+  return current.type === import_utils91.AST_NODE_TYPES.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === import_utils90.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
-  if (value.type === import_utils90.AST_NODE_TYPES.AssignmentPattern) value = value.left;
-  if (value.type === import_utils90.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== import_utils90.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === import_utils91.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
+  if (value.type === import_utils91.AST_NODE_TYPES.AssignmentPattern) value = value.left;
+  if (value.type === import_utils91.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== import_utils91.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === import_utils90.AST_NODE_TYPES.RestElement)
-        return property.argument.type === import_utils90.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === import_utils90.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-      return target.type === import_utils90.AST_NODE_TYPES.Identifier ? [target.name] : [];
+      if (property.type === import_utils91.AST_NODE_TYPES.RestElement)
+        return property.argument.type === import_utils91.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === import_utils91.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+      return target.type === import_utils91.AST_NODE_TYPES.Identifier ? [target.name] : [];
     })
   );
 }
@@ -18320,17 +18647,17 @@ var require_sql_access_class_default = createRule({
     function knownNonDatabase(node, seen = /* @__PURE__ */ new Set()) {
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === import_utils90.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils90.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      if (node.type === import_utils91.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
         if (binding?.defs.length !== 1 || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         const definition = binding.defs[0];
         return definition?.type === "Variable" && definition.node.init !== null && knownNonDatabase(definition.node.init, seen);
       }
-      return node.type === import_utils90.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils90.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (import_utils90.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
+      return node.type === import_utils91.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils91.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils90.AST_NODE_TYPES.MemberExpression)
+        if (node.callee.type !== import_utils91.AST_NODE_TYPES.MemberExpression)
           return;
         const method = memberName6(node.callee);
         if (knownNonDatabase(node.callee.object)) return;
@@ -18348,7 +18675,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils91 = require("@typescript-eslint/utils");
+var import_utils92 = 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.",
@@ -18363,34 +18690,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === import_utils91.AST_NODE_TYPES.TSAsExpression || node.type === import_utils91.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils91.AST_NODE_TYPES.TSTypeAssertion) {
+  if (node.type === import_utils92.AST_NODE_TYPES.TSAsExpression || node.type === import_utils92.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils92.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils92.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === import_utils91.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils92.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils91.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils92.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils91.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils92.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils91.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils92.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils91.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils92.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils91.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils91.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils92.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils92.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName5(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils91.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils92.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({
@@ -18413,19 +18740,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils91.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils92.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils91.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils92.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== import_utils91.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils92.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils91.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils91.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils92.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils92.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -18439,7 +18766,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils92 = require("@typescript-eslint/utils");
+var import_utils93 = require("@typescript-eslint/utils");
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "react-hook-form useForm call without explicit initial or reactive values",
   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.",
@@ -18493,13 +18820,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_utils92.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = import_utils93.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_utils92.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = import_utils93.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" || hasInitializationOrUnknownOptions(options)) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -18509,7 +18836,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils93 = require("@typescript-eslint/utils");
+var import_utils94 = 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",
@@ -18576,7 +18903,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils94 = require("@typescript-eslint/utils");
+var import_utils95 = 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.",
@@ -18602,14 +18929,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils94.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils95.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils95.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils95.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -18618,12 +18945,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils94.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils95.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils94.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils95.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils94.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils94.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils95.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils95.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -18644,7 +18971,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils94.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils95.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -18654,16 +18981,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils94.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils95.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils94.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils94.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils94.AST_NODE_TYPES.Literal || init?.type === import_utils94.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils94.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils95.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils95.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils95.AST_NODE_TYPES.Literal || init?.type === import_utils95.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils95.AST_NODE_TYPES.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils94.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils95.AST_NODE_TYPES.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== import_utils94.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils94.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils95.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -18672,14 +18999,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_utils94.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils95.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_utils94.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils95.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -18690,8 +19017,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils94.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils94.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils95.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -18700,15 +19027,15 @@ var require_zod_form_validation_default = createRule({
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
         if (isZodParseCall(parent)) return parent;
-        if (parent.type === import_utils94.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils94.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils95.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils95.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils94.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils94.AST_NODE_TYPES.MemberExpression && !parent.callee.computed && parent.callee.object.type === import_utils94.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === import_utils94.AST_NODE_TYPES.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils95.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils95.AST_NODE_TYPES.MemberExpression && !parent.callee.computed && parent.callee.object.type === import_utils95.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === import_utils95.AST_NODE_TYPES.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils94.AST_NODE_TYPES.CallExpression || parent.type === import_utils94.AST_NODE_TYPES.NewExpression || parent.type === import_utils94.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils94.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils94.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils94.AST_NODE_TYPES.FunctionDeclaration) return null;
+        if (parent.type === import_utils95.AST_NODE_TYPES.CallExpression || parent.type === import_utils95.AST_NODE_TYPES.NewExpression || parent.type === import_utils95.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils95.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils95.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils95.AST_NODE_TYPES.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
@@ -18716,16 +19043,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_utils94.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils94.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils95.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils95.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_utils94.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils94.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils94.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils94.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils95.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils95.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils95.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils95.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils94.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils94.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils95.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils95.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -18734,7 +19061,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils94.AST_NODE_TYPES.BlockStatement || parent.type === import_utils94.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils95.AST_NODE_TYPES.BlockStatement || parent.type === import_utils95.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -18743,12 +19070,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === import_utils94.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils94.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      return callee.type === import_utils95.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils95.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_utils94.AST_NODE_TYPES.LogicalExpression || current.type === import_utils94.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils95.AST_NODE_TYPES.LogicalExpression || current.type === import_utils95.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -18758,7 +19085,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_utils94.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils95.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -18771,7 +19098,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_utils94.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils94.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils95.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils95.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -18783,16 +19110,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils94.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils95.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils94.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils95.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils94.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils95.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils94.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils94.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils95.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils95.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -18803,23 +19130,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils94.AST_NODE_TYPES.ReturnStatement || node.type === import_utils94.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils95.AST_NODE_TYPES.ReturnStatement || node.type === import_utils95.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils94.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils95.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_utils94.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils94.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils95.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils95.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils94.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils95.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils94.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils95.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);
@@ -18839,7 +19166,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_utils94.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils95.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -18865,7 +19192,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_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")) {
+          if (specifier.type === import_utils95.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils95.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils95.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils95.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -18886,7 +19213,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils95 = require("@typescript-eslint/utils");
+var import_utils96 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Review conflict handling for embedded inserts in replay-named callables.",
   rationale: "Names such as seed, enqueue, or upsert suggest that repeated execution deserves a conflict-policy review, but do not prove a replay contract.",
@@ -18955,7 +19282,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils96 = require("@typescript-eslint/utils");
+var import_utils97 = 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.",
@@ -18973,7 +19300,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils96.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils96.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils97.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils97.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils97.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -19068,8 +19395,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_utils96.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils96.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils97.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils97.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -19093,7 +19420,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_utils96.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== import_utils97.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -19108,38 +19435,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils96.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils97.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils97.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils96.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils97.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils96.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils97.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils96.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils97.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils96.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils96.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils96.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils97.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils97.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils97.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils97.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_utils96.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils96.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils97.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils97.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils97.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_utils96.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils97.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils96.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === import_utils97.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -19152,21 +19479,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils96.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils96.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (node.key.type === import_utils97.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === import_utils97.AST_NODE_TYPES.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils96.AST_NODE_TYPES.Identifier ? import_utils96.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === import_utils97.AST_NODE_TYPES.Identifier ? import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils96.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils96.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== import_utils97.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
+  if (node.property.type === import_utils97.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils96.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils97.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -19182,7 +19509,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils96.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils97.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -19190,8 +19517,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_utils96.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils96.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils97.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils97.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -19200,7 +19527,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils96.AST_NODE_TYPES.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === import_utils97.AST_NODE_TYPES.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -19209,11 +19536,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = import_utils96.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === import_utils96.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils96.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils96.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils96.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils97.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils97.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils97.AST_NODE_TYPES.Identifier) {
+    const outer = import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -19229,27 +19556,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils96.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils96.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils96.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils96.AST_NODE_TYPES.ThisExpression;
+      while (current?.type === import_utils97.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils97.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils97.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+      return current?.type === import_utils97.AST_NODE_TYPES.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils96.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils96.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils96.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils96.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils96.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils96.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== import_utils97.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils97.AST_NODE_TYPES.AssignmentPattern) return;
+      if (current.type === import_utils97.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils97.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === import_utils97.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
+      const value = current.type === import_utils97.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === import_utils96.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils97.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils96.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils97.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === import_utils96.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === import_utils97.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== import_utils96.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils96.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== import_utils97.AST_NODE_TYPES.Identifier) return;
+      const variable = import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -19262,16 +19589,16 @@ function classScope(context, node, computedReferenceNames) {
       walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils96.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils96.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
+      if (current.type === import_utils97.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils97.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === import_utils96.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils97.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === import_utils96.AST_NODE_TYPES.Property && property.key.type === import_utils96.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === import_utils97.AST_NODE_TYPES.Property && property.key.type === import_utils97.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== import_utils96.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils97.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -19279,12 +19606,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils96.AST_NODE_TYPES.Identifier ? import_utils96.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === import_utils97.AST_NODE_TYPES.Identifier ? import_utils97.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_utils96.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils97.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -19304,9 +19631,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils96.AST_NODE_TYPES.MethodDefinition || member.type === import_utils96.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils97.AST_NODE_TYPES.MethodDefinition || member.type === import_utils97.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils96.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils97.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);
@@ -19328,12 +19655,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils96.AST_NODE_TYPES.StaticBlock:
+    case import_utils97.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils96.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils96.AST_NODE_TYPES.AccessorProperty:
+    case import_utils97.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils97.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils96.AST_NODE_TYPES.MethodDefinition:
+    case import_utils97.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -19365,7 +19692,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils96.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils97.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -19374,7 +19701,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-var import_utils97 = require("@typescript-eslint/utils");
+var import_utils98 = 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"]);
@@ -19443,21 +19770,21 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils98.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils98.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap7(node) {
-  if (node.type === import_utils97.AST_NODE_TYPES.AwaitExpression) return unwrap7(node.argument);
-  if (node.type === import_utils97.AST_NODE_TYPES.ChainExpression) return unwrap7(node.expression);
-  if (node.type === import_utils97.AST_NODE_TYPES.TSAsExpression || node.type === import_utils97.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils97.AST_NODE_TYPES.TSTypeAssertion) return unwrap7(node.expression);
+  if (node.type === import_utils98.AST_NODE_TYPES.AwaitExpression) return unwrap7(node.argument);
+  if (node.type === import_utils98.AST_NODE_TYPES.ChainExpression) return unwrap7(node.expression);
+  if (node.type === import_utils98.AST_NODE_TYPES.TSAsExpression || node.type === import_utils98.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils98.AST_NODE_TYPES.TSTypeAssertion) return unwrap7(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap7(node);
-  if (current.type === import_utils97.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils97.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === import_utils97.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+  if (current.type === import_utils98.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils98.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === import_utils98.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -19469,7 +19796,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap7(node);
-  if (current.type !== import_utils97.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils97.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils97.AST_NODE_TYPES.SpreadElement) return null;
+  if (current.type !== import_utils98.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils98.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils98.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -19491,7 +19818,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const scopes = [newScope()];
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
-      const bindingOf = (node) => import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      const bindingOf = (node) => import_utils98.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
       const visible = (kind, node) => {
         const name2 = bindingOf(node);
         if (name2 === null || name2.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
@@ -19514,37 +19841,37 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils97.AST_NODE_TYPES.Identifier) return visible("paths", current);
-        if (current.type === import_utils97.AST_NODE_TYPES.CallExpression || current.type === import_utils97.AST_NODE_TYPES.NewExpression) {
+        if (current.type === import_utils98.AST_NODE_TYPES.Identifier) return visible("paths", current);
+        if (current.type === import_utils98.AST_NODE_TYPES.CallExpression || current.type === import_utils98.AST_NODE_TYPES.NewExpression) {
           const callee = current.callee;
           const first = current.arguments[0];
-          if (first === void 0 || first.type === import_utils97.AST_NODE_TYPES.SpreadElement) return false;
-          if (current.type === import_utils97.AST_NODE_TYPES.NewExpression && callee.type === import_utils97.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === import_utils97.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils97.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils97.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils97.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === import_utils98.AST_NODE_TYPES.SpreadElement) return false;
+          if (current.type === import_utils98.AST_NODE_TYPES.NewExpression && callee.type === import_utils98.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === import_utils98.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils98.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils98.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils98.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
         }
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap7(node);
-        if (current.type !== import_utils97.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils98.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap7(current.callee);
-        if (callee.type === import_utils97.AST_NODE_TYPES.Identifier) {
+        if (callee.type === import_utils98.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils97.AST_NODE_TYPES.MemberExpression) return false;
+        if (callee.type !== import_utils98.AST_NODE_TYPES.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap7(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils97.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils98.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap7(node);
-        if (current.type === import_utils97.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
+        if (current.type === import_utils98.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils97.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils97.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils97.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils98.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils98.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils98.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== import_utils97.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils98.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();
       };
@@ -19552,32 +19879,32 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils97.AST_NODE_TYPES.BinaryExpression || current.type === import_utils97.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils97.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils97.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils98.AST_NODE_TYPES.BinaryExpression || current.type === import_utils98.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils98.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils98.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== import_utils97.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils98.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_utils97.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils98.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap7(node.callee);
-        if (callee.type === import_utils97.AST_NODE_TYPES.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils97.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === import_utils98.AST_NODE_TYPES.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils98.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils97.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils98.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap7(callee.object);
-        while (receiver.type === import_utils97.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
-        if (receiver.type === import_utils97.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils97.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === import_utils98.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
+        if (receiver.type === import_utils98.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils98.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_utils97.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils98.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils97.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_utils97.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils98.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_utils98.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -19599,7 +19926,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap7(node);
-        return current.type === import_utils97.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils97.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        return current.type === import_utils98.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils98.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -19612,8 +19939,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_utils97.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils97.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils98.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils98.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -19626,30 +19953,30 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (node.init === null) return;
           const required = requireSource(node.init);
           const initializer = unwrap7(node.init);
-          if (required !== null && initializer.type === import_utils97.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils97.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils97.AST_NODE_TYPES.Identifier) {
+          if (required !== null && initializer.type === import_utils98.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils98.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils98.AST_NODE_TYPES.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils97.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils98.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== import_utils97.AST_NODE_TYPES.Property || property.value.type !== import_utils97.AST_NODE_TYPES.Identifier) continue;
-              const key = property.key.type === import_utils97.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils97.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+              if (property.type !== import_utils98.AST_NODE_TYPES.Property || property.value.type !== import_utils98.AST_NODE_TYPES.Identifier) continue;
+              const key = property.key.type === import_utils98.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils98.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== import_utils97.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils98.AST_NODE_TYPES.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils97.AST_NODE_TYPES.Identifier) declare(node.left, {});
+          if (node.left.type === import_utils98.AST_NODE_TYPES.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap7(node.right);
-          const collection = right.type === import_utils97.AST_NODE_TYPES.Identifier && visible("collections", right);
-          const left = node.left.type === import_utils97.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils97.AST_NODE_TYPES.Identifier) declare(left, { path: true });
+          const collection = right.type === import_utils98.AST_NODE_TYPES.Identifier && visible("collections", right);
+          const left = node.left.type === import_utils98.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils98.AST_NODE_TYPES.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -19668,7 +19995,7 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/sole-export-matches-filename.ts
-var import_utils98 = require("@typescript-eslint/utils");
+var import_utils99 = 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.",
@@ -19712,10 +20039,10 @@ function kebabCase(name) {
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === import_utils98.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils98.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils98.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== import_utils98.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration.type === import_utils99.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils99.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils99.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== import_utils99.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils98.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === import_utils99.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -19739,32 +20066,32 @@ var sole_export_matches_filename_default = createRule({
         const exports2 = [];
         const publicExports = /* @__PURE__ */ new Set();
         for (const statement of program.body) {
-          if (statement.type === import_utils98.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils98.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
-          if (statement.type === import_utils98.AST_NODE_TYPES.ExportDefaultDeclaration) {
+          if (statement.type === import_utils99.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils99.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
+          if (statement.type === import_utils99.AST_NODE_TYPES.ExportDefaultDeclaration) {
             publicExports.add("default");
             const declaration2 = statement.declaration;
-            if ((declaration2.type === import_utils98.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils98.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
+            if ((declaration2.type === import_utils99.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils99.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
             else return;
           }
-          if (statement.type !== import_utils98.AST_NODE_TYPES.ExportNamedDeclaration) continue;
+          if (statement.type !== import_utils99.AST_NODE_TYPES.ExportNamedDeclaration) continue;
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils98.AST_NODE_TYPES.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils99.AST_NODE_TYPES.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === import_utils98.AST_NODE_TYPES.VariableDeclaration) {
-            if (declaration.declarations.some((item) => item.id.type !== import_utils98.AST_NODE_TYPES.Identifier)) return;
+          if (declaration?.type === import_utils99.AST_NODE_TYPES.VariableDeclaration) {
+            if (declaration.declarations.some((item) => item.id.type !== import_utils99.AST_NODE_TYPES.Identifier)) return;
             for (const item of declaration.declarations) {
-              if (item.id.type === import_utils98.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
+              if (item.id.type === import_utils99.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
             }
           }
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === import_utils98.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === import_utils99.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_utils98.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === import_utils99.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 });
@@ -19776,7 +20103,7 @@ var sole_export_matches_filename_default = createRule({
         const only = [...unique.values()][0];
         if (only === void 0) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
-        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils98.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
+        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils99.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
@@ -19826,7 +20153,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils99 = require("@typescript-eslint/utils");
+var import_utils100 = 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.",
@@ -19958,18 +20285,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils99.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils100.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils99.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils100.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils99.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils100.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils99.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils100.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -19980,13 +20307,13 @@ var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils99.AST_NODE_TYPES.MemberExpression) {
-      if (current.computed || current.property.type !== import_utils99.AST_NODE_TYPES.Identifier) return [];
+    if (current.type === import_utils100.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils100.AST_NODE_TYPES.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === import_utils99.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils100.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -19997,16 +20324,16 @@ var chainMemberNames2 = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === import_utils99.AST_NODE_TYPES.TSAsExpression || current.type === import_utils99.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils99.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils99.AST_NODE_TYPES.TSTypeAssertion) {
+  while (current.type === import_utils100.AST_NODE_TYPES.TSAsExpression || current.type === import_utils100.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils100.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils100.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils99.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils100.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils99.AST_NODE_TYPES.Program || owner.type === import_utils99.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils99.AST_NODE_TYPES.Program;
+  return owner.type === import_utils100.AST_NODE_TYPES.Program || owner.type === import_utils100.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils100.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -20026,7 +20353,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_utils99.ASTUtils.findVariable(
+      return import_utils100.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -20047,8 +20374,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === import_utils99.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils99.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils99.AST_NODE_TYPES.MemberExpression) {
+      if (init.type === import_utils100.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils100.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils100.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -20068,7 +20395,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_utils99.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils99.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils99.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils99.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils100.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils100.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils100.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils100.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -20077,7 +20404,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_utils99.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils100.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -20256,6 +20583,7 @@ var RULES = {
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
   "repeated-static-call-cases": repeated_static_call_cases_default,
   "prefer-zod-infer": prefer_zod_infer_default,
+  "prefer-zod-parse-output-type": prefer_zod_parse_output_type_default,
   "require-assert-never": require_assert_never_default,
   "require-fetch-timeout": require_fetch_timeout_default,
   "require-interface-for-exported-class": require_interface_for_exported_class_default,
@@ -20271,7 +20599,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.11"
+  version: "15.17.13"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {
@@ -20294,6 +20622,7 @@ var ADVISORY_RULES = [
   "@sarj/prefer-shared-zod-enum",
   "@sarj/prefer-switch-for-repeated-equality",
   "@sarj/prefer-whole-object-assertion",
+  "@sarj/prefer-zod-parse-output-type",
   "@sarj/require-interface-for-exported-class",
   "@sarj/require-sql-access-class",
   "@sarj/sole-export-matches-filename"
@@ -20375,6 +20704,7 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-whole-object-assertion": "warn",
   "@sarj/repeated-static-call-cases": "error",
   "@sarj/prefer-zod-infer": "error",
+  "@sarj/prefer-zod-parse-output-type": "warn",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
   "@sarj/require-interface-for-exported-class": "warn",
@@ -20472,6 +20802,7 @@ var STRICT_RULES = {
   "@sarj/prefer-whole-object-assertion": "warn",
   "@sarj/repeated-static-call-cases": "error",
   "@sarj/prefer-zod-infer": "error",
+  "@sarj/prefer-zod-parse-output-type": "warn",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
   "@sarj/require-interface-for-exported-class": "warn",