@sarj/eslint-plugin 15.17.11 → 15.17.13

package/dist/index.js

@@ -16411,6 +16411,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",
@@ -16418,6 +16421,9 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "ZodMiniType",
   "Schema"
 ]);
+function isPreferZodInferTypeConstraintName(name) {
+  return ZOD_TYPE_CONSTRAINTS.has(name);
+}
 var LEAF_NODE_TYPES = {
   string: [AST_NODE_TYPES69.TSStringKeyword],
   email: [AST_NODE_TYPES69.TSStringKeyword],
@@ -16593,6 +16599,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;
@@ -16652,6 +16673,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 === AST_NODE_TYPES69.CallExpression) {
+    const callee = current.callee;
+    if (callee.type !== AST_NODE_TYPES69.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES69.Identifier) {
+      return null;
+    }
+    chain.push(current);
+    if (callee.object.type === AST_NODE_TYPES69.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 === AST_NODE_TYPES69.MemberExpression && callee.property.type === AST_NODE_TYPES69.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 !== AST_NODE_TYPES69.ObjectExpression) return null;
+  const fields = /* @__PURE__ */ new Map();
+  for (const property of shape.properties) {
+    if (property.type !== AST_NODE_TYPES69.Property || property.computed) return null;
+    const { key } = property;
+    const name = key.type === AST_NODE_TYPES69.Identifier ? key.name : key.type === AST_NODE_TYPES69.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 === AST_NODE_TYPES69.CallExpression) {
+    const callee = current.callee;
+    if (callee.type !== AST_NODE_TYPES69.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES69.Identifier) {
+      break;
+    }
+    const receiver = callee.object;
+    if (receiver.type === AST_NODE_TYPES69.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 === AST_NODE_TYPES69.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 !== AST_NODE_TYPES69.TSTypeLiteral) {
+      return null;
+    }
+    members = declaration.typeAnnotation.members;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (member.type !== AST_NODE_TYPES69.TSPropertySignature || member.computed) return null;
+    const { key } = member;
+    const name = key.type === AST_NODE_TYPES69.Identifier ? key.name : key.type === AST_NODE_TYPES69.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());
 }
@@ -16708,27 +16823,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 === AST_NODE_TYPES69.CallExpression) {
-        const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES69.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES69.Identifier) {
-          return null;
-        }
-        chain.push(current);
-        const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES69.Identifier) {
-          return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
-        }
-        current = receiver;
-      }
-      return null;
-    }
-    function methodName2(call) {
-      const callee = call.callee;
-      return callee.type === AST_NODE_TYPES69.MemberExpression && callee.property.type === AST_NODE_TYPES69.Identifier ? callee.property.name : "";
-    }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
@@ -16739,42 +16833,13 @@ var prefer_zod_infer_default = createRule({
         }
       }
     }
-    function schemaField(node) {
-      const modifiers = [];
-      let current = node;
-      let leaf = null;
-      let leafCall = null;
-      while (current.type === AST_NODE_TYPES69.CallExpression) {
-        const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES69.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES69.Identifier) {
-          break;
-        }
-        const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES69.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);
@@ -16818,112 +16883,26 @@ 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 !== AST_NODE_TYPES69.ObjectExpression) {
-        return null;
-      }
-      const fields = /* @__PURE__ */ new Map();
-      for (const property of shape.properties) {
-        if (property.type !== AST_NODE_TYPES69.Property || property.computed) {
-          return null;
-        }
-        const { key } = property;
-        const name = key.type === AST_NODE_TYPES69.Identifier ? key.name : key.type === AST_NODE_TYPES69.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 !== AST_NODE_TYPES69.TSPropertySignature || member.computed) {
-          return null;
-        }
-        const { key } = member;
-        const name = key.type === AST_NODE_TYPES69.Identifier ? key.name : key.type === AST_NODE_TYPES69.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 === AST_NODE_TYPES69.TSTypeReference) {
         if (node.typeName.type === AST_NODE_TYPES69.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
-          collectConstrainedNames(argument);
+          collectConstrainedNames2(argument);
         }
         return;
       }
       if (node.type === AST_NODE_TYPES69.TSArrayType) {
-        collectConstrainedNames(node.elementType);
+        collectConstrainedNames2(node.elementType);
         return;
       }
       if (node.type === AST_NODE_TYPES69.TSUnionType || node.type === AST_NODE_TYPES69.TSIntersectionType) {
         for (const member of node.types) {
-          collectConstrainedNames(member);
+          collectConstrainedNames2(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;
-        }
-      }
-      return true;
-    }
     return {
       Program(node) {
         for (const statement of node.body) {
@@ -16939,9 +16918,9 @@ var prefer_zod_infer_default = createRule({
         if (node.id.type !== AST_NODE_TYPES69.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);
@@ -16953,7 +16932,7 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === AST_NODE_TYPES69.Identifier && node.property.type === AST_NODE_TYPES69.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === AST_NODE_TYPES69.Identifier && node.property.type === AST_NODE_TYPES69.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
@@ -16961,11 +16940,11 @@ var prefer_zod_infer_default = createRule({
       TSTypeReference(node) {
         const { typeName } = node;
         const referenced = typeName.type === AST_NODE_TYPES69.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES69.TSQualifiedName && typeName.right.type === AST_NODE_TYPES69.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) {
@@ -16973,9 +16952,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,
@@ -16997,9 +16976,9 @@ var prefer_zod_infer_default = createRule({
         if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES69.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,
@@ -17028,7 +17007,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);
@@ -17092,12 +17079,355 @@ var prefer_zod_infer_default = createRule({
   }
 });
 
-// src/rules/require-assert-never.ts
+// src/rules/prefer-zod-parse-output-type.ts
 import {
-  ESLintUtils as ESLintUtils7,
-  AST_NODE_TYPES as AST_NODE_TYPES70
+  AST_NODE_TYPES as AST_NODE_TYPES70,
+  ESLintUtils as ESLintUtils7
 } from "@typescript-eslint/utils";
 import ts5 from "typescript";
+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 !== AST_NODE_TYPES70.VariableDeclaration || declaration.kind !== "const") {
+    return false;
+  }
+  const container = declaration.parent;
+  return container.type === AST_NODE_TYPES70.Program || container.type === AST_NODE_TYPES70.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES70.Program;
+}
+function isLocalZodObjectSchema(node, namespaces) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES70.CallExpression) {
+    const { callee } = current;
+    if (callee.type !== AST_NODE_TYPES70.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES70.Identifier) {
+      return false;
+    }
+    if (callee.object.type === AST_NODE_TYPES70.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 !== AST_NODE_TYPES70.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES70.Identifier || callee.property.type !== AST_NODE_TYPES70.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 !== AST_NODE_TYPES70.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 === AST_NODE_TYPES70.ReturnStatement) {
+      return parent.argument === current ? enclosingFunction4(parent) : null;
+    }
+    if (parent.type === AST_NODE_TYPES70.ArrowFunctionExpression && parent.expression && parent.body === current) {
+      return parent;
+    }
+    if (parent.type === AST_NODE_TYPES70.AwaitExpression && parent.argument === current) {
+      current = parent;
+      continue;
+    }
+    if (parent.type === AST_NODE_TYPES70.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 === AST_NODE_TYPES70.Literal && node.value === null || node.type === AST_NODE_TYPES70.Identifier && node.name === "undefined";
+}
+function enclosingFunction4(node) {
+  let current = node.parent;
+  while (current !== void 0) {
+    if (current.type === AST_NODE_TYPES70.ArrowFunctionExpression || current.type === AST_NODE_TYPES70.FunctionDeclaration || current.type === AST_NODE_TYPES70.FunctionExpression) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function returnContractReference(node) {
+  if (node.type === AST_NODE_TYPES70.TSUnionType) {
+    const substantive = node.types.filter(
+      (member) => member.type !== AST_NODE_TYPES70.TSNullKeyword && member.type !== AST_NODE_TYPES70.TSUndefinedKeyword
+    );
+    const [only] = substantive;
+    return substantive.length === 1 && only !== void 0 ? returnContractReference(only) : null;
+  }
+  if (node.type === AST_NODE_TYPES70.TSTypeReference && node.typeName.type === AST_NODE_TYPES70.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 === AST_NODE_TYPES70.TSTypeReference && node.typeName.type === AST_NODE_TYPES70.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
+}
+function recordZodNamespaces(node, namespaces) {
+  for (const statement of node.body) {
+    if (statement.type !== AST_NODE_TYPES70.ImportDeclaration || !isZodModule(statement.source.value)) {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === AST_NODE_TYPES70.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES70.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES70.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES70.Identifier && specifier.imported.name === "z") {
+        namespaces.add(specifier.local.name);
+      }
+    }
+  }
+}
+function collectConstrainedNames(node, names) {
+  if (node.type === AST_NODE_TYPES70.TSTypeReference) {
+    if (node.typeName.type === AST_NODE_TYPES70.Identifier) names.add(node.typeName.name);
+    for (const argument of node.typeArguments?.params ?? []) {
+      collectConstrainedNames(argument, names);
+    }
+    return;
+  }
+  if (node.type === AST_NODE_TYPES70.TSArrayType) {
+    collectConstrainedNames(node.elementType, names);
+    return;
+  }
+  if (node.type === AST_NODE_TYPES70.TSUnionType || node.type === AST_NODE_TYPES70.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 === AST_NODE_TYPES70.TSInterfaceDeclaration || estreeDeclaration.type === AST_NODE_TYPES70.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) => ts5.isPropertySignature(member) && member.type !== void 0 && member.modifiers?.some((modifier) => modifier.kind === ts5.SyntaxKind.ReadonlyKeyword) !== true
+  );
+  if (ts5.isInterfaceDeclaration(declaration) && declaration.typeParameters === void 0 && declaration.heritageClauses === void 0 && plainMembers(declaration.members)) {
+    return declaration;
+  }
+  if (ts5.isTypeAliasDeclaration(declaration) && declaration.typeParameters === void 0 && ts5.isTypeLiteralNode(declaration.type) && plainMembers(declaration.type.members)) {
+    return declaration;
+  }
+  return null;
+}
+function exactObjectTypes(checker, parsed, contract) {
+  const unsafeFlags = ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.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, ts5.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(contract, ts5.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 = ESLintUtils7.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 === AST_NODE_TYPES70.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 === AST_NODE_TYPES70.Identifier && node.property.type === AST_NODE_TYPES70.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+          reshapedSchemas.add(node.object.name);
+        }
+      },
+      TSTypeReference(node) {
+        const { typeName } = node;
+        const name = typeName.type === AST_NODE_TYPES70.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES70.TSQualifiedName && typeName.right.type === AST_NODE_TYPES70.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
+import {
+  ESLintUtils as ESLintUtils8,
+  AST_NODE_TYPES as AST_NODE_TYPES71
+} from "@typescript-eslint/utils";
+import ts6 from "typescript";
 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.",
@@ -17110,14 +17440,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === AST_NODE_TYPES70.EmptyStatement) return false;
-  if (statement.type === AST_NODE_TYPES70.BreakStatement) {
+  if (statement.type === AST_NODE_TYPES71.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES71.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === AST_NODE_TYPES70.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES70.TSInterfaceDeclaration) {
+  if (statement.type === AST_NODE_TYPES71.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES71.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === AST_NODE_TYPES70.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES71.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -17133,7 +17463,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 === AST_NODE_TYPES70.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES71.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -17145,7 +17475,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 & ts5.TypeFlags.BooleanLiteral) !== 0
+    (constituent) => (constituent.flags & ts6.TypeFlags.BooleanLiteral) !== 0
   )) {
     return false;
   }
@@ -17167,7 +17497,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   return [...expected].every((key) => handled.has(key));
 }
 function finiteTypeKey(type, checker) {
-  const finiteFlags = ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral | ts5.TypeFlags.EnumLiteral | ts5.TypeFlags.UniqueESSymbol | ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
+  const finiteFlags = ts6.TypeFlags.StringLiteral | ts6.TypeFlags.NumberLiteral | ts6.TypeFlags.BooleanLiteral | ts6.TypeFlags.EnumLiteral | ts6.TypeFlags.UniqueESSymbol | ts6.TypeFlags.Null | ts6.TypeFlags.Undefined;
   return (type.flags & finiteFlags) !== 0 ? checker.typeToString(type) : null;
 }
 var require_assert_never_default = createRule({
@@ -17187,7 +17517,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = ESLintUtils7.getParserServices(context);
+      services = ESLintUtils8.getParserServices(context);
     } catch {
       services = null;
     }
@@ -17214,7 +17544,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES71, ASTUtils as ASTUtils40 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES72, ASTUtils as ASTUtils40 } from "@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.",
@@ -17241,14 +17571,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== AST_NODE_TYPES71.ObjectExpression) {
+  if (init.type !== AST_NODE_TYPES72.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === AST_NODE_TYPES71.SpreadElement) {
+    if (prop.type === AST_NODE_TYPES72.SpreadElement) {
       return false;
     }
-    if (prop.key.type === AST_NODE_TYPES71.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES71.Literal && prop.key.value === "signal") {
+    if (prop.key.type === AST_NODE_TYPES72.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES72.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -17258,7 +17588,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === AST_NODE_TYPES71.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES71.TemplateLiteral || node.type === AST_NODE_TYPES71.NewExpression && node.callee.type === AST_NODE_TYPES71.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === AST_NODE_TYPES72.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES72.TemplateLiteral || node.type === AST_NODE_TYPES72.NewExpression && node.callee.type === AST_NODE_TYPES72.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -17300,10 +17630,10 @@ var require_fetch_timeout_default = createRule({
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === AST_NODE_TYPES71.Identifier) {
+      if (callee.type === AST_NODE_TYPES72.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === AST_NODE_TYPES71.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES71.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES71.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === AST_NODE_TYPES72.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES72.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES72.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
       const variable = ASTUtils40.findVariable(
@@ -17312,14 +17642,14 @@ var require_fetch_timeout_default = createRule({
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== AST_NODE_TYPES71.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== AST_NODE_TYPES72.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 !== AST_NODE_TYPES71.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES71.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES71.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== AST_NODE_TYPES72.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES72.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES72.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -17327,13 +17657,13 @@ var require_fetch_timeout_default = createRule({
     }
     function isForwardedRequest(argument) {
       let value = argument;
-      if (value.type === AST_NODE_TYPES71.Identifier) {
+      if (value.type === AST_NODE_TYPES72.Identifier) {
         const binding = ASTUtils40.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 === AST_NODE_TYPES71.NewExpression && value.callee.type === AST_NODE_TYPES71.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
+      return value.type === AST_NODE_TYPES72.NewExpression && value.callee.type === AST_NODE_TYPES72.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
     }
     return {
       CallExpression(node) {
@@ -17344,7 +17674,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 === AST_NODE_TYPES71.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES72.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -17353,7 +17683,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES72 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES73 } from "@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.",
@@ -17399,23 +17729,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === AST_NODE_TYPES72.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== AST_NODE_TYPES72.PrivateIdentifier;
+    if (member.type === AST_NODE_TYPES73.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== AST_NODE_TYPES73.PrivateIdentifier;
     }
-    if (member.type !== AST_NODE_TYPES72.PropertyDefinition || member.static)
+    if (member.type !== AST_NODE_TYPES73.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === AST_NODE_TYPES72.PrivateIdentifier) return false;
-    return member.value?.type === AST_NODE_TYPES72.ArrowFunctionExpression || member.value?.type === AST_NODE_TYPES72.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES72.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === AST_NODE_TYPES73.PrivateIdentifier) return false;
+    return member.value?.type === AST_NODE_TYPES73.ArrowFunctionExpression || member.value?.type === AST_NODE_TYPES73.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === AST_NODE_TYPES72.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === AST_NODE_TYPES72.ClassDeclaration) {
+  const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === AST_NODE_TYPES73.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== AST_NODE_TYPES72.VariableDeclaration) return [];
+  if (declaration?.type !== AST_NODE_TYPES73.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === AST_NODE_TYPES72.Identifier && item.init?.type === AST_NODE_TYPES72.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === AST_NODE_TYPES73.Identifier && item.init?.type === AST_NODE_TYPES73.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -17446,7 +17776,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = /* @__PURE__ */ new Map();
         for (const statement of program.body) {
-          if (statement.type === AST_NODE_TYPES72.ExportNamedDeclaration) {
+          if (statement.type === AST_NODE_TYPES73.ExportNamedDeclaration) {
             for (const binding of classBindings(statement)) {
               exported.set(binding.declaration, binding.name);
             }
@@ -17455,18 +17785,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 === AST_NODE_TYPES72.Identifier ? specifier.exported.name : specifier.exported.value;
+              const exportedName = specifier.exported.type === AST_NODE_TYPES73.Identifier ? specifier.exported.name : specifier.exported.value;
               exported.set(candidate2, exportedName);
             }
             continue;
           }
-          if (statement.type !== AST_NODE_TYPES72.ExportDefaultDeclaration) continue;
-          if (statement.declaration.type === AST_NODE_TYPES72.ClassDeclaration || statement.declaration.type === AST_NODE_TYPES72.ClassExpression) {
+          if (statement.type !== AST_NODE_TYPES73.ExportDefaultDeclaration) continue;
+          if (statement.declaration.type === AST_NODE_TYPES73.ClassDeclaration || statement.declaration.type === AST_NODE_TYPES73.ClassExpression) {
             exported.set(
               statement.declaration,
               statement.declaration.id?.name ?? "default"
             );
-          } else if (statement.declaration.type === AST_NODE_TYPES72.Identifier) {
+          } else if (statement.declaration.type === AST_NODE_TYPES73.Identifier) {
             const candidate2 = classes.get(statement.declaration.name);
             if (candidate2 !== void 0) {
               exported.set(candidate2, statement.declaration.name);
@@ -17474,7 +17804,7 @@ var require_interface_for_exported_class_default = createRule({
           }
         }
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === AST_NODE_TYPES72.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === AST_NODE_TYPES73.Identifier && abstractBases.has(declaration.superClass.name);
           if (declaration.abstract || declaration.implements.length > 0 || extendsLocalAbstractBase || !hasPublicInstanceBehavior(declaration)) continue;
           context.report({
             node: declaration.id ?? declaration,
@@ -17488,7 +17818,7 @@ var require_interface_for_exported_class_default = createRule({
 });
 
 // src/rules/require-port-for-service.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES73 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES74 } from "@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.",
@@ -17513,45 +17843,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 === AST_NODE_TYPES73.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === AST_NODE_TYPES73.Identifier) return member.property.name;
-  return member.computed && member.property.type === AST_NODE_TYPES73.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === AST_NODE_TYPES74.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === AST_NODE_TYPES74.Identifier) return member.property.name;
+  return member.computed && member.property.type === AST_NODE_TYPES74.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 === AST_NODE_TYPES73.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === AST_NODE_TYPES74.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 === AST_NODE_TYPES73.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES73.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES74.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES74.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === AST_NODE_TYPES73.TSExportAssignment && statement.expression.type === AST_NODE_TYPES73.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES74.TSExportAssignment && statement.expression.type === AST_NODE_TYPES74.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES73.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES73.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES74.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES74.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === AST_NODE_TYPES73.TSUnionType) {
+  if (annotation?.type === AST_NODE_TYPES74.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== AST_NODE_TYPES73.TSUndefinedKeyword && member.type !== AST_NODE_TYPES73.TSNullKeyword
+      (member) => member.type !== AST_NODE_TYPES74.TSUndefinedKeyword && member.type !== AST_NODE_TYPES74.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES73.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES74.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === AST_NODE_TYPES73.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES73.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === AST_NODE_TYPES74.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES74.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === AST_NODE_TYPES73.Identifier ? name.name : name.type === AST_NODE_TYPES73.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === AST_NODE_TYPES74.Identifier ? name.name : name.type === AST_NODE_TYPES74.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== AST_NODE_TYPES73.Identifier) continue;
+    if (member.type !== AST_NODE_TYPES74.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== AST_NODE_TYPES74.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -17562,18 +17892,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES73.TSInterfaceDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES74.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES74.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== AST_NODE_TYPES73.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== AST_NODE_TYPES74.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === AST_NODE_TYPES73.TSFunctionType || aliased.type === AST_NODE_TYPES73.TSConstructorType) {
+    if (aliased.type === AST_NODE_TYPES74.TSFunctionType || aliased.type === AST_NODE_TYPES74.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === AST_NODE_TYPES73.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES73.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES73.TSTypeLiteral) : [];
+    const literals = aliased.type === AST_NODE_TYPES74.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES74.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES74.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -17602,10 +17932,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === AST_NODE_TYPES73.ArrowFunctionExpression || current.type === AST_NODE_TYPES73.FunctionExpression || current.type === AST_NODE_TYPES73.FunctionDeclaration || current.type === AST_NODE_TYPES73.ClassExpression || current.type === AST_NODE_TYPES73.ClassDeclaration) continue;
-      const expression = current.type === AST_NODE_TYPES73.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === AST_NODE_TYPES73.AssignmentExpression && expression.left.type === AST_NODE_TYPES73.MemberExpression && expression.left.object.type === AST_NODE_TYPES73.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== AST_NODE_TYPES73.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES73.MemberExpression || expression.left.object.type !== AST_NODE_TYPES73.ThisExpression || storedField === null) {
+      if (current.type === AST_NODE_TYPES74.ArrowFunctionExpression || current.type === AST_NODE_TYPES74.FunctionExpression || current.type === AST_NODE_TYPES74.FunctionDeclaration || current.type === AST_NODE_TYPES74.ClassExpression || current.type === AST_NODE_TYPES74.ClassDeclaration) continue;
+      const expression = current.type === AST_NODE_TYPES74.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === AST_NODE_TYPES74.AssignmentExpression && expression.left.type === AST_NODE_TYPES74.MemberExpression && expression.left.object.type === AST_NODE_TYPES74.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== AST_NODE_TYPES74.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES74.MemberExpression || expression.left.object.type !== AST_NODE_TYPES74.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -17618,14 +17948,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === AST_NODE_TYPES73.TSNonNullExpression || source.type === AST_NODE_TYPES73.TSAsExpression || source.type === AST_NODE_TYPES73.TSSatisfiesExpression || source.type === AST_NODE_TYPES73.TSTypeAssertion) source = source.expression;
-      if (source.type === AST_NODE_TYPES73.NewExpression) {
+      while (source.type === AST_NODE_TYPES74.TSNonNullExpression || source.type === AST_NODE_TYPES74.TSAsExpression || source.type === AST_NODE_TYPES74.TSSatisfiesExpression || source.type === AST_NODE_TYPES74.TSTypeAssertion) source = source.expression;
+      if (source.type === AST_NODE_TYPES74.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === AST_NODE_TYPES73.Identifier) {
+      } else if (source.type === AST_NODE_TYPES74.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === AST_NODE_TYPES73.MemberExpression && source.object.type === AST_NODE_TYPES73.Identifier) {
+      } else if (source.type === AST_NODE_TYPES74.MemberExpression && source.object.type === AST_NODE_TYPES74.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -17643,7 +17973,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 === AST_NODE_TYPES73.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === AST_NODE_TYPES74.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;
@@ -17658,8 +17988,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === AST_NODE_TYPES73.AssignmentPattern) target = target.left;
-  if (target.type === AST_NODE_TYPES73.ObjectPattern) {
+  if (target.type === AST_NODE_TYPES74.AssignmentPattern) target = target.left;
+  if (target.type === AST_NODE_TYPES74.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -17668,9 +17998,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES73.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES73.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES73.Identifier) return [];
+  if (target.type === AST_NODE_TYPES74.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES74.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES74.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -17686,9 +18016,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES73.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES73.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES73.Identifier) return null;
+  if (target.type === AST_NODE_TYPES74.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES74.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES74.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -17700,11 +18030,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== AST_NODE_TYPES73.Property || property.computed) continue;
-    if (property.key.type !== AST_NODE_TYPES73.Identifier) continue;
+    if (property.type !== AST_NODE_TYPES74.Property || property.computed) continue;
+    if (property.key.type !== AST_NODE_TYPES74.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === AST_NODE_TYPES73.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== AST_NODE_TYPES73.Identifier) continue;
+    const bound = property.value.type === AST_NODE_TYPES74.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== AST_NODE_TYPES74.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -17714,21 +18044,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === AST_NODE_TYPES73.TSTypeLiteral) {
+  if (annotation.type === AST_NODE_TYPES74.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== AST_NODE_TYPES73.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES73.Identifier) {
+  if (annotation.type !== AST_NODE_TYPES74.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES74.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === AST_NODE_TYPES73.CallExpression) {
+  if (node.type === AST_NODE_TYPES74.CallExpression) {
     const { callee } = node;
-    if (callee.type === AST_NODE_TYPES73.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === AST_NODE_TYPES73.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES73.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === AST_NODE_TYPES74.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === AST_NODE_TYPES74.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES74.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === AST_NODE_TYPES73.TSTypeReference && node.typeName.type === AST_NODE_TYPES73.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === AST_NODE_TYPES74.TSTypeReference && node.typeName.type === AST_NODE_TYPES74.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -17755,19 +18085,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === AST_NODE_TYPES73.ChainExpression || callee.type === AST_NODE_TYPES73.TSAsExpression || callee.type === AST_NODE_TYPES73.TSNonNullExpression || callee.type === AST_NODE_TYPES73.TSSatisfiesExpression || callee.type === AST_NODE_TYPES73.TSTypeAssertion) callee = callee.expression;
-  return callee.type === AST_NODE_TYPES73.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === AST_NODE_TYPES74.ChainExpression || callee.type === AST_NODE_TYPES74.TSAsExpression || callee.type === AST_NODE_TYPES74.TSNonNullExpression || callee.type === AST_NODE_TYPES74.TSSatisfiesExpression || callee.type === AST_NODE_TYPES74.TSTypeAssertion) callee = callee.expression;
+  return callee.type === AST_NODE_TYPES74.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === AST_NODE_TYPES73.ChainExpression || node.type === AST_NODE_TYPES73.TSAsExpression || node.type === AST_NODE_TYPES73.TSNonNullExpression || node.type === AST_NODE_TYPES73.TSSatisfiesExpression || node.type === AST_NODE_TYPES73.TSTypeAssertion) node = node.expression;
-  return node.type === AST_NODE_TYPES73.MemberExpression && node.object.type === AST_NODE_TYPES73.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === AST_NODE_TYPES74.ChainExpression || node.type === AST_NODE_TYPES74.TSAsExpression || node.type === AST_NODE_TYPES74.TSNonNullExpression || node.type === AST_NODE_TYPES74.TSSatisfiesExpression || node.type === AST_NODE_TYPES74.TSTypeAssertion) node = node.expression;
+  return node.type === AST_NODE_TYPES74.MemberExpression && node.object.type === AST_NODE_TYPES74.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === AST_NODE_TYPES73.ClassDeclaration || current.type === AST_NODE_TYPES73.ClassExpression || current.type === AST_NODE_TYPES73.FunctionDeclaration || current.type === AST_NODE_TYPES73.FunctionExpression) return;
-    if (current.type === AST_NODE_TYPES73.CallExpression) {
+    if (current.type === AST_NODE_TYPES74.ClassDeclaration || current.type === AST_NODE_TYPES74.ClassExpression || current.type === AST_NODE_TYPES74.FunctionDeclaration || current.type === AST_NODE_TYPES74.FunctionExpression) return;
+    if (current.type === AST_NODE_TYPES74.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -17780,14 +18110,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === AST_NODE_TYPES73.StaticBlock || member.static) continue;
-    if (member.type === AST_NODE_TYPES73.MethodDefinition) {
+    if (member.type === AST_NODE_TYPES74.StaticBlock || member.static) continue;
+    if (member.type === AST_NODE_TYPES74.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== AST_NODE_TYPES73.PropertyDefinition || member.value === null) continue;
+    if (member.type !== AST_NODE_TYPES74.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === AST_NODE_TYPES73.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === AST_NODE_TYPES74.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -17807,25 +18137,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES73.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES74.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES74.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === AST_NODE_TYPES73.PropertyDefinition) {
+    if (member.type === AST_NODE_TYPES74.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.key.type === AST_NODE_TYPES73.PrivateIdentifier) continue;
-      if (member.value?.type !== AST_NODE_TYPES73.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES73.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES73.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      if (member.key.type === AST_NODE_TYPES74.PrivateIdentifier) continue;
+      if (member.value?.type !== AST_NODE_TYPES74.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES74.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES74.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES74.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES74.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
       names.push(declaredMemberName(member) ?? "\u2026");
       continue;
     }
-    if (member.type !== AST_NODE_TYPES73.MethodDefinition) continue;
+    if (member.type !== AST_NODE_TYPES74.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === AST_NODE_TYPES73.PrivateIdentifier) continue;
+    if (member.key.type === AST_NODE_TYPES74.PrivateIdentifier) continue;
     names.push(declaredMemberName(member) ?? "\u2026");
   }
   return names;
@@ -17833,13 +18163,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES73.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === AST_NODE_TYPES74.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 === AST_NODE_TYPES73.TSTypeReference && result.typeName.type === AST_NODE_TYPES73.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === AST_NODE_TYPES74.TSTypeReference && result.typeName.type === AST_NODE_TYPES74.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -17847,10 +18177,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration || statement.type === AST_NODE_TYPES73.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES73.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === AST_NODE_TYPES74.ExportNamedDeclaration || statement.type === AST_NODE_TYPES74.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES74.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === AST_NODE_TYPES73.Identifier) {
+      if (declaration.superClass?.type === AST_NODE_TYPES74.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -17868,8 +18198,8 @@ function localClassAbstractness(program) {
   return classes;
 }
 function declaredMemberName(member) {
-  if (!member.computed && member.key.type === AST_NODE_TYPES73.Identifier) return member.key.name;
-  if (member.key.type === AST_NODE_TYPES73.Literal && typeof member.key.value === "string") return member.key.value;
+  if (!member.computed && member.key.type === AST_NODE_TYPES74.Identifier) return member.key.name;
+  if (member.key.type === AST_NODE_TYPES74.Literal && typeof member.key.value === "string") return member.key.value;
   return null;
 }
 function localInterfaceSurfaces(program) {
@@ -17877,45 +18207,45 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES73.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES73.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES73.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES74.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES74.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES74.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES74.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES73.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES73.TSTypeAliasDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES74.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES74.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES73.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES74.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === AST_NODE_TYPES73.TSTypeReference && part.typeName.type === AST_NODE_TYPES73.Identifier) {
+        if (part.type === AST_NODE_TYPES74.TSTypeReference && part.typeName.type === AST_NODE_TYPES74.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== AST_NODE_TYPES73.TSTypeLiteral) continue;
+        if (part.type !== AST_NODE_TYPES74.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== AST_NODE_TYPES73.TSMethodSignature && member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
+          if (member.type !== AST_NODE_TYPES74.TSMethodSignature && member.type !== AST_NODE_TYPES74.TSPropertySignature) continue;
           const name = declaredMemberName(member);
           if (name === null) continue;
-          if (member.type === AST_NODE_TYPES73.TSMethodSignature) {
+          if (member.type === AST_NODE_TYPES74.TSMethodSignature) {
             callables2.add(name);
             continue;
           }
-          if (member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
+          if (member.type !== AST_NODE_TYPES74.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === AST_NODE_TYPES73.TSFunctionType || annotation?.type === AST_NODE_TYPES73.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(name);
+          if (annotation?.type === AST_NODE_TYPES74.TSFunctionType || annotation?.type === AST_NODE_TYPES74.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES74.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 !== AST_NODE_TYPES73.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== AST_NODE_TYPES74.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== AST_NODE_TYPES73.TSMethodSignature && member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
+      if (member.type !== AST_NODE_TYPES74.TSMethodSignature && member.type !== AST_NODE_TYPES74.TSPropertySignature) continue;
       const name = declaredMemberName(member);
       if (name === null) continue;
-      if (member.type === AST_NODE_TYPES73.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
+      if (member.type === AST_NODE_TYPES74.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES74.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES74.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES74.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -17923,7 +18253,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === AST_NODE_TYPES73.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === AST_NODE_TYPES74.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -17950,7 +18280,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== AST_NODE_TYPES73.Identifier) return true;
+    if (node.superClass.type !== AST_NODE_TYPES74.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -17962,7 +18292,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 !== AST_NODE_TYPES73.Identifier) return true;
+    if (implementation.expression.type !== AST_NODE_TYPES74.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -18005,7 +18335,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 === AST_NODE_TYPES73.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === AST_NODE_TYPES74.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -18040,7 +18370,7 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-sql-access-class.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES74, ASTUtils as ASTUtils41 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES75, ASTUtils as ASTUtils41 } from "@typescript-eslint/utils";
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -18135,9 +18465,9 @@ var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
   ]
 };
 function memberName6(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES74.Identifier)
+  if (!node.computed && node.property.type === AST_NODE_TYPES75.Identifier)
     return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES74.Literal && typeof node.property.value === "string")
+  if (node.computed && node.property.type === AST_NODE_TYPES75.Literal && typeof node.property.value === "string")
     return node.property.value;
   return null;
 }
@@ -18149,89 +18479,89 @@ function isDatabaseOperation(method, receiver) {
   return BUILDER_SHORT_TERMINALS.has(method) && expressionCallsBuilder(receiver);
 }
 function databaseReceiver(node) {
-  if (node.type === AST_NODE_TYPES74.Identifier)
+  if (node.type === AST_NODE_TYPES75.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== AST_NODE_TYPES74.MemberExpression) return false;
+  if (node.type !== AST_NODE_TYPES75.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 === AST_NODE_TYPES74.ChainExpression) {
+    if (current.type === AST_NODE_TYPES75.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.TSAsExpression || current.type === AST_NODE_TYPES74.TSNonNullExpression || current.type === AST_NODE_TYPES74.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES75.TSAsExpression || current.type === AST_NODE_TYPES75.TSNonNullExpression || current.type === AST_NODE_TYPES75.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES74.MemberExpression) return null;
+    if (current.type === AST_NODE_TYPES75.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES75.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.MemberExpression) {
-      if (current.object.type === AST_NODE_TYPES74.ThisExpression)
+    if (current.type === AST_NODE_TYPES75.MemberExpression) {
+      if (current.object.type === AST_NODE_TYPES75.ThisExpression)
         return memberName6(current);
       current = current.object;
       continue;
     }
-    return current.type === AST_NODE_TYPES74.Identifier ? current.name : null;
+    return current.type === AST_NODE_TYPES75.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES74.ChainExpression) {
+    if (current.type === AST_NODE_TYPES75.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.TSAsExpression || current.type === AST_NODE_TYPES74.TSNonNullExpression || current.type === AST_NODE_TYPES74.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES75.TSAsExpression || current.type === AST_NODE_TYPES75.TSNonNullExpression || current.type === AST_NODE_TYPES75.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES74.MemberExpression) return false;
+    if (current.type === AST_NODE_TYPES75.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES75.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.MemberExpression) {
+    if (current.type === AST_NODE_TYPES75.MemberExpression) {
       const name = memberName6(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === AST_NODE_TYPES74.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === AST_NODE_TYPES75.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES74.ChainExpression) {
+    if (current.type === AST_NODE_TYPES75.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.TSAsExpression || current.type === AST_NODE_TYPES74.TSNonNullExpression || current.type === AST_NODE_TYPES74.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES75.TSAsExpression || current.type === AST_NODE_TYPES75.TSNonNullExpression || current.type === AST_NODE_TYPES75.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES74.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES74.MemberExpression) return false;
+    if (current.type === AST_NODE_TYPES75.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES75.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 !== AST_NODE_TYPES74.MemberExpression) return false;
+    if (current.type !== AST_NODE_TYPES75.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === AST_NODE_TYPES74.ClassDeclaration || current.type === AST_NODE_TYPES74.ClassExpression)
+    if (current.type === AST_NODE_TYPES75.ClassDeclaration || current.type === AST_NODE_TYPES75.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -18240,25 +18570,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === AST_NODE_TYPES74.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === AST_NODE_TYPES75.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 !== AST_NODE_TYPES74.TSParameterProperty) continue;
-    const value = parameter.parameter.type === AST_NODE_TYPES74.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === AST_NODE_TYPES74.Identifier) injected.add(value.name);
+    if (parameter.type !== AST_NODE_TYPES75.TSParameterProperty) continue;
+    const value = parameter.parameter.type === AST_NODE_TYPES75.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === AST_NODE_TYPES75.Identifier) injected.add(value.name);
   }
   const body2 = constructor.value.body;
   if (body2 === null) return injected;
   for (const statement of body2.body) {
-    if (statement.type !== AST_NODE_TYPES74.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES74.AssignmentExpression || statement.expression.operator !== "=") continue;
+    if (statement.type !== AST_NODE_TYPES75.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES75.AssignmentExpression || statement.expression.operator !== "=") continue;
     const { left, right } = statement.expression;
-    if (left.type !== AST_NODE_TYPES74.MemberExpression) continue;
+    if (left.type !== AST_NODE_TYPES75.MemberExpression) continue;
     const target = thisRootMember(left);
     if (target === null) continue;
-    const source = right.type === AST_NODE_TYPES74.Identifier ? right.name : right.type === AST_NODE_TYPES74.MemberExpression && right.object.type === AST_NODE_TYPES74.Identifier ? right.object.name : null;
+    const source = right.type === AST_NODE_TYPES75.Identifier ? right.name : right.type === AST_NODE_TYPES75.MemberExpression && right.object.type === AST_NODE_TYPES75.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   return injected;
@@ -18266,26 +18596,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === AST_NODE_TYPES74.MemberExpression) {
+  while (current.type === AST_NODE_TYPES75.MemberExpression) {
     const name = memberName6(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === AST_NODE_TYPES74.ThisExpression ? root : null;
+  return current.type === AST_NODE_TYPES75.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === AST_NODE_TYPES74.TSParameterProperty) value = value.parameter;
-  if (value.type === AST_NODE_TYPES74.AssignmentPattern) value = value.left;
-  if (value.type === AST_NODE_TYPES74.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== AST_NODE_TYPES74.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === AST_NODE_TYPES75.TSParameterProperty) value = value.parameter;
+  if (value.type === AST_NODE_TYPES75.AssignmentPattern) value = value.left;
+  if (value.type === AST_NODE_TYPES75.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== AST_NODE_TYPES75.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === AST_NODE_TYPES74.RestElement)
-        return property.argument.type === AST_NODE_TYPES74.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === AST_NODE_TYPES74.AssignmentPattern ? property.value.left : property.value;
-      return target.type === AST_NODE_TYPES74.Identifier ? [target.name] : [];
+      if (property.type === AST_NODE_TYPES75.RestElement)
+        return property.argument.type === AST_NODE_TYPES75.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === AST_NODE_TYPES75.AssignmentPattern ? property.value.left : property.value;
+      return target.type === AST_NODE_TYPES75.Identifier ? [target.name] : [];
     })
   );
 }
@@ -18309,17 +18639,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 === AST_NODE_TYPES74.Identifier) {
+      if (node.type === AST_NODE_TYPES75.Identifier) {
         const binding = ASTUtils41.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 === AST_NODE_TYPES74.NewExpression && node.callee.type === AST_NODE_TYPES74.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (ASTUtils41.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
+      return node.type === AST_NODE_TYPES75.NewExpression && node.callee.type === AST_NODE_TYPES75.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (ASTUtils41.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES74.MemberExpression)
+        if (node.callee.type !== AST_NODE_TYPES75.MemberExpression)
           return;
         const method = memberName6(node.callee);
         if (knownNonDatabase(node.callee.object)) return;
@@ -18337,7 +18667,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES75 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES76 } from "@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.",
@@ -18352,34 +18682,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === AST_NODE_TYPES75.TSAsExpression || node.type === AST_NODE_TYPES75.TSSatisfiesExpression || node.type === AST_NODE_TYPES75.TSNonNullExpression || node.type === AST_NODE_TYPES75.TSTypeAssertion) {
+  if (node.type === AST_NODE_TYPES76.TSAsExpression || node.type === AST_NODE_TYPES76.TSSatisfiesExpression || node.type === AST_NODE_TYPES76.TSNonNullExpression || node.type === AST_NODE_TYPES76.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === AST_NODE_TYPES75.Literal) {
+  if (value.type === AST_NODE_TYPES76.Literal) {
     return true;
   }
-  if (value.type === AST_NODE_TYPES75.TemplateLiteral) {
+  if (value.type === AST_NODE_TYPES76.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === AST_NODE_TYPES75.ArrayExpression) {
+  if (value.type === AST_NODE_TYPES76.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== AST_NODE_TYPES75.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== AST_NODE_TYPES76.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === AST_NODE_TYPES75.ObjectExpression) {
+  if (value.type === AST_NODE_TYPES76.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === AST_NODE_TYPES75.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES75.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === AST_NODE_TYPES76.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES76.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName5(property) {
   if (property.computed) return null;
-  if (property.key.type === AST_NODE_TYPES75.Identifier) return property.key.name;
+  if (property.key.type === AST_NODE_TYPES76.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -18402,19 +18732,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== AST_NODE_TYPES75.VariableDeclaration) {
+        if (node.declaration?.type !== AST_NODE_TYPES76.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== AST_NODE_TYPES75.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== AST_NODE_TYPES76.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== AST_NODE_TYPES75.ObjectExpression) {
+          if (config.type !== AST_NODE_TYPES76.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== AST_NODE_TYPES75.Property || propertyName5(property) !== "matcher" || property.value.type === AST_NODE_TYPES75.AssignmentPattern) {
+            if (property.type !== AST_NODE_TYPES76.Property || propertyName5(property) !== "matcher" || property.value.type === AST_NODE_TYPES76.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -18566,7 +18896,7 @@ var require_use_server_in_actions_file_default = createRule({
 
 // src/rules/require-zod-form-validation.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES76,
+  AST_NODE_TYPES as AST_NODE_TYPES77,
   ASTUtils as ASTUtils43
 } from "@typescript-eslint/utils";
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
@@ -18594,14 +18924,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES76.Identifier) {
+    if (current.type === AST_NODE_TYPES77.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES76.CallExpression) {
+    if (current.type === AST_NODE_TYPES77.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES76.MemberExpression) {
+    if (current.type === AST_NODE_TYPES77.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -18610,12 +18940,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === AST_NODE_TYPES76.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES77.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES76.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES77.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES76.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES76.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES77.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES77.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -18646,16 +18976,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES76.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES77.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === AST_NODE_TYPES76.ObjectExpression || init?.type === AST_NODE_TYPES76.ArrayExpression || init?.type === AST_NODE_TYPES76.Literal || init?.type === AST_NODE_TYPES76.ArrowFunctionExpression || init?.type === AST_NODE_TYPES76.FunctionExpression;
+      return init?.type === AST_NODE_TYPES77.ObjectExpression || init?.type === AST_NODE_TYPES77.ArrayExpression || init?.type === AST_NODE_TYPES77.Literal || init?.type === AST_NODE_TYPES77.ArrowFunctionExpression || init?.type === AST_NODE_TYPES77.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== AST_NODE_TYPES76.CallExpression) return false;
+      if (node.type !== AST_NODE_TYPES77.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES76.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES76.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES77.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES77.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -18664,14 +18994,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 !== AST_NODE_TYPES76.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES77.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 === AST_NODE_TYPES76.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES77.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -18682,8 +19012,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES76.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES76.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES77.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES77.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -18692,15 +19022,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 === AST_NODE_TYPES76.CallExpression && parent.callee.type === AST_NODE_TYPES76.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES77.CallExpression && parent.callee.type === AST_NODE_TYPES77.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 === AST_NODE_TYPES76.CallExpression && parent.callee.type === AST_NODE_TYPES76.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES76.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES76.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES77.CallExpression && parent.callee.type === AST_NODE_TYPES77.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES77.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES77.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES76.CallExpression || parent.type === AST_NODE_TYPES76.NewExpression || parent.type === AST_NODE_TYPES76.TaggedTemplateExpression || parent.type === AST_NODE_TYPES76.ArrowFunctionExpression || parent.type === AST_NODE_TYPES76.FunctionExpression || parent.type === AST_NODE_TYPES76.FunctionDeclaration) return null;
+        if (parent.type === AST_NODE_TYPES77.CallExpression || parent.type === AST_NODE_TYPES77.NewExpression || parent.type === AST_NODE_TYPES77.TaggedTemplateExpression || parent.type === AST_NODE_TYPES77.ArrowFunctionExpression || parent.type === AST_NODE_TYPES77.FunctionExpression || parent.type === AST_NODE_TYPES77.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
@@ -18708,16 +19038,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 === AST_NODE_TYPES76.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES76.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES77.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES77.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === AST_NODE_TYPES76.TSAsExpression || parent.type === AST_NODE_TYPES76.TSSatisfiesExpression || parent.type === AST_NODE_TYPES76.TSNonNullExpression || parent.type === AST_NODE_TYPES76.ChainExpression) && parent.expression === current) {
+      while ((parent.type === AST_NODE_TYPES77.TSAsExpression || parent.type === AST_NODE_TYPES77.TSSatisfiesExpression || parent.type === AST_NODE_TYPES77.TSNonNullExpression || parent.type === AST_NODE_TYPES77.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === AST_NODE_TYPES76.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES76.Identifier) {
+      if (parent.type === AST_NODE_TYPES77.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES77.Identifier) {
         return parent;
       }
       return null;
@@ -18726,7 +19056,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === AST_NODE_TYPES76.BlockStatement || parent.type === AST_NODE_TYPES76.Program) {
+        if (parent.type === AST_NODE_TYPES77.BlockStatement || parent.type === AST_NODE_TYPES77.Program) {
           return current;
         }
         current = parent;
@@ -18735,12 +19065,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES76.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES76.Identifier ? callee.property.name : null;
+      return callee.type === AST_NODE_TYPES77.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES77.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === AST_NODE_TYPES76.LogicalExpression || current.type === AST_NODE_TYPES76.ConditionalExpression) {
+        if (current.type === AST_NODE_TYPES77.LogicalExpression || current.type === AST_NODE_TYPES77.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -18750,7 +19080,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 === AST_NODE_TYPES76.AwaitExpression) return true;
+        if (current.type === AST_NODE_TYPES77.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -18763,7 +19093,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 !== AST_NODE_TYPES76.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES76.ExpressionStatement) {
+      if (validationStatement.type !== AST_NODE_TYPES77.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES77.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -18775,16 +19105,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === AST_NODE_TYPES76.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === AST_NODE_TYPES77.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== AST_NODE_TYPES76.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== AST_NODE_TYPES77.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === AST_NODE_TYPES76.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === AST_NODE_TYPES77.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES76.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES76.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES77.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES77.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -18795,23 +19125,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === AST_NODE_TYPES76.ReturnStatement || node.type === AST_NODE_TYPES76.ThrowStatement) {
+      if (node.type === AST_NODE_TYPES77.ReturnStatement || node.type === AST_NODE_TYPES77.ThrowStatement) {
         return true;
       }
-      if (node.type !== AST_NODE_TYPES76.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== AST_NODE_TYPES77.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 !== AST_NODE_TYPES76.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES76.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== AST_NODE_TYPES77.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES77.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === AST_NODE_TYPES76.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === AST_NODE_TYPES77.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === AST_NODE_TYPES76.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === AST_NODE_TYPES77.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -18831,7 +19161,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 === AST_NODE_TYPES76.Identifier
+        (identifier) => identifier.type === AST_NODE_TYPES77.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -18857,7 +19187,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 === AST_NODE_TYPES76.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES76.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES76.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES76.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES77.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES77.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES77.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES77.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -18947,7 +19277,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils44 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES78, ASTUtils as ASTUtils44 } from "@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.",
@@ -18965,7 +19295,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === AST_NODE_TYPES77.ArrowFunctionExpression || node.type === AST_NODE_TYPES77.FunctionDeclaration || node.type === AST_NODE_TYPES77.FunctionExpression;
+  return node.type === AST_NODE_TYPES78.ArrowFunctionExpression || node.type === AST_NODE_TYPES78.FunctionDeclaration || node.type === AST_NODE_TYPES78.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -19060,8 +19390,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 === AST_NODE_TYPES77.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === AST_NODE_TYPES77.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === AST_NODE_TYPES78.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === AST_NODE_TYPES78.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -19085,7 +19415,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 !== AST_NODE_TYPES77.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES78.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -19100,38 +19430,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== AST_NODE_TYPES77.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === AST_NODE_TYPES77.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== AST_NODE_TYPES78.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === AST_NODE_TYPES78.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === AST_NODE_TYPES77.VariableDeclaration) {
+    if (statement.declaration?.type === AST_NODE_TYPES78.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === AST_NODE_TYPES77.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === AST_NODE_TYPES78.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES77.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES78.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === AST_NODE_TYPES77.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES77.Identifier) names.add(statement.declaration.name);
-    if (statement.type === AST_NODE_TYPES77.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES77.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === AST_NODE_TYPES78.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES78.Identifier) names.add(statement.declaration.name);
+    if (statement.type === AST_NODE_TYPES78.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES78.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 === AST_NODE_TYPES77.ExportNamedDeclaration || statement.type === AST_NODE_TYPES77.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === AST_NODE_TYPES77.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === AST_NODE_TYPES78.ExportNamedDeclaration || statement.type === AST_NODE_TYPES78.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === AST_NODE_TYPES78.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== AST_NODE_TYPES77.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== AST_NODE_TYPES78.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === AST_NODE_TYPES77.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === AST_NODE_TYPES78.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -19144,21 +19474,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === AST_NODE_TYPES77.Identifier ? node.key.name : null;
+  if (node.key.type === AST_NODE_TYPES78.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === AST_NODE_TYPES78.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils44.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES78.Identifier ? ASTUtils44.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== AST_NODE_TYPES77.ThisExpression && !isClassReference) return null;
-  if (node.property.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES77.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES77.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== AST_NODE_TYPES78.ThisExpression && !isClassReference) return null;
+  if (node.property.type === AST_NODE_TYPES78.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES78.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES78.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES77.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES77.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === AST_NODE_TYPES78.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES78.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES78.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -19174,7 +19504,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES77.MethodDefinition
+    (member) => member.type === AST_NODE_TYPES78.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -19182,8 +19512,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 !== AST_NODE_TYPES77.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === AST_NODE_TYPES77.Identifier ? member.key.name : null;
+    if (member.type !== AST_NODE_TYPES78.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === AST_NODE_TYPES78.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -19192,7 +19522,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES77.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES78.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -19204,7 +19534,7 @@ function classScope(context, node, computedReferenceNames) {
     const internal = ASTUtils44.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === AST_NODE_TYPES77.ClassExpression && node.parent.type === AST_NODE_TYPES77.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES77.Identifier) {
+  if (node.type === AST_NODE_TYPES78.ClassExpression && node.parent.type === AST_NODE_TYPES78.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES78.Identifier) {
     const outer = ASTUtils44.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
@@ -19221,26 +19551,26 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === AST_NODE_TYPES77.TSAsExpression || current?.type === AST_NODE_TYPES77.TSSatisfiesExpression || current?.type === AST_NODE_TYPES77.TSNonNullExpression) current = current.expression;
-      return current?.type === AST_NODE_TYPES77.ThisExpression;
+      while (current?.type === AST_NODE_TYPES78.TSAsExpression || current?.type === AST_NODE_TYPES78.TSSatisfiesExpression || current?.type === AST_NODE_TYPES78.TSNonNullExpression) current = current.expression;
+      return current?.type === AST_NODE_TYPES78.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== AST_NODE_TYPES77.VariableDeclarator && current.type !== AST_NODE_TYPES77.AssignmentPattern) return;
-      if (current.type === AST_NODE_TYPES77.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES77.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === AST_NODE_TYPES77.VariableDeclarator ? current.id : current.left;
-      const value = current.type === AST_NODE_TYPES77.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== AST_NODE_TYPES78.VariableDeclarator && current.type !== AST_NODE_TYPES78.AssignmentPattern) return;
+      if (current.type === AST_NODE_TYPES78.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES78.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === AST_NODE_TYPES78.VariableDeclarator ? current.id : current.left;
+      const value = current.type === AST_NODE_TYPES78.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === AST_NODE_TYPES77.ObjectPattern) {
+      if (binding.type === AST_NODE_TYPES78.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === AST_NODE_TYPES77.RestElement) {
+          if (property.type === AST_NODE_TYPES78.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === AST_NODE_TYPES77.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === AST_NODE_TYPES78.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== AST_NODE_TYPES77.Identifier) return;
+      if (binding.type !== AST_NODE_TYPES78.Identifier) return;
       const variable = ASTUtils44.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
@@ -19254,16 +19584,16 @@ function classScope(context, node, computedReferenceNames) {
       walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === AST_NODE_TYPES77.VariableDeclarator && current.id.type === AST_NODE_TYPES77.ObjectPattern && thisValue(current.init)) {
+      if (current.type === AST_NODE_TYPES78.VariableDeclarator && current.id.type === AST_NODE_TYPES78.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === AST_NODE_TYPES77.RestElement) {
+          if (property.type === AST_NODE_TYPES78.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === AST_NODE_TYPES77.Property && property.key.type === AST_NODE_TYPES77.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === AST_NODE_TYPES78.Property && property.key.type === AST_NODE_TYPES78.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== AST_NODE_TYPES77.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES78.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -19271,12 +19601,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils44.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES78.Identifier ? ASTUtils44.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 !== AST_NODE_TYPES77.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES78.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -19296,9 +19626,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === AST_NODE_TYPES77.MethodDefinition || member.type === AST_NODE_TYPES77.TSAbstractMethodDefinition) continue;
+    if (member.type === AST_NODE_TYPES78.MethodDefinition || member.type === AST_NODE_TYPES78.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== AST_NODE_TYPES77.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES78.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -19320,12 +19650,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case AST_NODE_TYPES77.StaticBlock:
+    case AST_NODE_TYPES78.StaticBlock:
       return true;
-    case AST_NODE_TYPES77.PropertyDefinition:
-    case AST_NODE_TYPES77.AccessorProperty:
+    case AST_NODE_TYPES78.PropertyDefinition:
+    case AST_NODE_TYPES78.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case AST_NODE_TYPES77.MethodDefinition:
+    case AST_NODE_TYPES78.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -19357,7 +19687,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === AST_NODE_TYPES77.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES77.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === AST_NODE_TYPES78.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES78.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -19366,7 +19696,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES78, ASTUtils as ASTUtils45 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES79, ASTUtils as ASTUtils45 } from "@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"]);
@@ -19435,21 +19765,21 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES78.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES78.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === AST_NODE_TYPES79.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES79.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap7(node) {
-  if (node.type === AST_NODE_TYPES78.AwaitExpression) return unwrap7(node.argument);
-  if (node.type === AST_NODE_TYPES78.ChainExpression) return unwrap7(node.expression);
-  if (node.type === AST_NODE_TYPES78.TSAsExpression || node.type === AST_NODE_TYPES78.TSNonNullExpression || node.type === AST_NODE_TYPES78.TSTypeAssertion) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES79.AwaitExpression) return unwrap7(node.argument);
+  if (node.type === AST_NODE_TYPES79.ChainExpression) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES79.TSAsExpression || node.type === AST_NODE_TYPES79.TSNonNullExpression || node.type === AST_NODE_TYPES79.TSTypeAssertion) return unwrap7(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap7(node);
-  if (current.type === AST_NODE_TYPES78.Literal && typeof current.value === "string") return current.value;
-  if (current.type === AST_NODE_TYPES78.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === AST_NODE_TYPES78.BinaryExpression && current.operator === "+") {
+  if (current.type === AST_NODE_TYPES79.Literal && typeof current.value === "string") return current.value;
+  if (current.type === AST_NODE_TYPES79.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === AST_NODE_TYPES79.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -19461,7 +19791,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap7(node);
-  if (current.type !== AST_NODE_TYPES78.CallExpression || current.callee.type !== AST_NODE_TYPES78.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES78.SpreadElement) return null;
+  if (current.type !== AST_NODE_TYPES79.CallExpression || current.callee.type !== AST_NODE_TYPES79.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES79.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -19506,37 +19836,37 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === AST_NODE_TYPES78.Identifier) return visible("paths", current);
-        if (current.type === AST_NODE_TYPES78.CallExpression || current.type === AST_NODE_TYPES78.NewExpression) {
+        if (current.type === AST_NODE_TYPES79.Identifier) return visible("paths", current);
+        if (current.type === AST_NODE_TYPES79.CallExpression || current.type === AST_NODE_TYPES79.NewExpression) {
           const callee = current.callee;
           const first = current.arguments[0];
-          if (first === void 0 || first.type === AST_NODE_TYPES78.SpreadElement) return false;
-          if (current.type === AST_NODE_TYPES78.NewExpression && callee.type === AST_NODE_TYPES78.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === AST_NODE_TYPES78.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES78.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES78.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES78.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === AST_NODE_TYPES79.SpreadElement) return false;
+          if (current.type === AST_NODE_TYPES79.NewExpression && callee.type === AST_NODE_TYPES79.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === AST_NODE_TYPES79.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES79.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES79.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES79.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 !== AST_NODE_TYPES78.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== AST_NODE_TYPES79.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap7(current.callee);
-        if (callee.type === AST_NODE_TYPES78.Identifier) {
+        if (callee.type === AST_NODE_TYPES79.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== AST_NODE_TYPES78.MemberExpression) return false;
+        if (callee.type !== AST_NODE_TYPES79.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap7(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES78.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES79.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap7(node);
-        if (current.type === AST_NODE_TYPES78.Identifier) return visibleRawOrigins(current);
+        if (current.type === AST_NODE_TYPES79.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === AST_NODE_TYPES78.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES78.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== AST_NODE_TYPES78.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES79.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES79.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== AST_NODE_TYPES79.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES78.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES79.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
@@ -19544,32 +19874,32 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === AST_NODE_TYPES78.BinaryExpression || current.type === AST_NODE_TYPES78.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES78.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== AST_NODE_TYPES78.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES79.BinaryExpression || current.type === AST_NODE_TYPES79.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES79.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== AST_NODE_TYPES79.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES78.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES79.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 === AST_NODE_TYPES78.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES79.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap7(node.callee);
-        if (callee.type === AST_NODE_TYPES78.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES78.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === AST_NODE_TYPES79.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES79.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== AST_NODE_TYPES78.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES79.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap7(callee.object);
-        while (receiver.type === AST_NODE_TYPES78.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
-        if (receiver.type === AST_NODE_TYPES78.CallExpression && receiver.callee.type === AST_NODE_TYPES78.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === AST_NODE_TYPES79.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
+        if (receiver.type === AST_NODE_TYPES79.CallExpression && receiver.callee.type === AST_NODE_TYPES79.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 === AST_NODE_TYPES78.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES79.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== AST_NODE_TYPES78.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES78.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== AST_NODE_TYPES79.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES79.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -19591,7 +19921,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap7(node);
-        return current.type === AST_NODE_TYPES78.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES78.SpreadElement && sourcePath(element));
+        return current.type === AST_NODE_TYPES79.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES79.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -19604,8 +19934,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 === AST_NODE_TYPES78.ImportSpecifier) {
-              const imported = specifier.imported.type === AST_NODE_TYPES78.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === AST_NODE_TYPES79.ImportSpecifier) {
+              const imported = specifier.imported.type === AST_NODE_TYPES79.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -19618,30 +19948,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 === AST_NODE_TYPES78.CallExpression && initializer.callee.type === AST_NODE_TYPES78.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES78.Identifier) {
+          if (required !== null && initializer.type === AST_NODE_TYPES79.CallExpression && initializer.callee.type === AST_NODE_TYPES79.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES79.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === AST_NODE_TYPES78.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === AST_NODE_TYPES79.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== AST_NODE_TYPES78.Property || property.value.type !== AST_NODE_TYPES78.Identifier) continue;
-              const key = property.key.type === AST_NODE_TYPES78.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES78.Literal ? String(property.key.value) : "";
+              if (property.type !== AST_NODE_TYPES79.Property || property.value.type !== AST_NODE_TYPES79.Identifier) continue;
+              const key = property.key.type === AST_NODE_TYPES79.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES79.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== AST_NODE_TYPES78.Identifier) return;
+          if (node.id.type !== AST_NODE_TYPES79.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === AST_NODE_TYPES78.Identifier) declare(node.left, {});
+          if (node.left.type === AST_NODE_TYPES79.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap7(node.right);
-          const collection = right.type === AST_NODE_TYPES78.Identifier && visible("collections", right);
-          const left = node.left.type === AST_NODE_TYPES78.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === AST_NODE_TYPES78.Identifier) declare(left, { path: true });
+          const collection = right.type === AST_NODE_TYPES79.Identifier && visible("collections", right);
+          const left = node.left.type === AST_NODE_TYPES79.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === AST_NODE_TYPES79.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -19660,7 +19990,7 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/sole-export-matches-filename.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES79 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES80 } from "@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.",
@@ -19704,10 +20034,10 @@ function kebabCase(name) {
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === AST_NODE_TYPES79.ClassDeclaration || declaration.type === AST_NODE_TYPES79.FunctionDeclaration || declaration.type === AST_NODE_TYPES79.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== AST_NODE_TYPES79.VariableDeclaration) return [];
+  if (declaration.type === AST_NODE_TYPES80.ClassDeclaration || declaration.type === AST_NODE_TYPES80.FunctionDeclaration || declaration.type === AST_NODE_TYPES80.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== AST_NODE_TYPES80.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === AST_NODE_TYPES79.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === AST_NODE_TYPES80.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -19731,32 +20061,32 @@ var sole_export_matches_filename_default = createRule({
         const exports = [];
         const publicExports = /* @__PURE__ */ new Set();
         for (const statement of program.body) {
-          if (statement.type === AST_NODE_TYPES79.ExportAllDeclaration || statement.type === AST_NODE_TYPES79.ExportNamedDeclaration && statement.source !== null) return;
-          if (statement.type === AST_NODE_TYPES79.ExportDefaultDeclaration) {
+          if (statement.type === AST_NODE_TYPES80.ExportAllDeclaration || statement.type === AST_NODE_TYPES80.ExportNamedDeclaration && statement.source !== null) return;
+          if (statement.type === AST_NODE_TYPES80.ExportDefaultDeclaration) {
             publicExports.add("default");
             const declaration2 = statement.declaration;
-            if ((declaration2.type === AST_NODE_TYPES79.ClassDeclaration || declaration2.type === AST_NODE_TYPES79.FunctionDeclaration) && declaration2.id !== null) exports.push({ name: declaration2.id.name, node: declaration2 });
+            if ((declaration2.type === AST_NODE_TYPES80.ClassDeclaration || declaration2.type === AST_NODE_TYPES80.FunctionDeclaration) && declaration2.id !== null) exports.push({ name: declaration2.id.name, node: declaration2 });
             else return;
           }
-          if (statement.type !== AST_NODE_TYPES79.ExportNamedDeclaration) continue;
+          if (statement.type !== AST_NODE_TYPES80.ExportNamedDeclaration) continue;
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES79.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES80.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === AST_NODE_TYPES79.VariableDeclaration) {
-            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES79.Identifier)) return;
+          if (declaration?.type === AST_NODE_TYPES80.VariableDeclaration) {
+            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES80.Identifier)) return;
             for (const item of declaration.declarations) {
-              if (item.id.type === AST_NODE_TYPES79.Identifier) publicExports.add(item.id.name);
+              if (item.id.type === AST_NODE_TYPES80.Identifier) publicExports.add(item.id.name);
             }
           }
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES79.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES80.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
           }
           if (statement.exportKind === "type") continue;
           exports.push(...declarationExport(statement));
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES79.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES80.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
             if (specifier.exportKind === "type") continue;
             if (exported === "default") exports.push({ name: specifier.local.name, node: specifier });
@@ -19768,7 +20098,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 === AST_NODE_TYPES79.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 === AST_NODE_TYPES80.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
@@ -19819,7 +20149,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 
 // src/rules/require-pascal-case-zod-schema-name.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES80,
+  AST_NODE_TYPES as AST_NODE_TYPES81,
   ASTUtils as ASTUtils46
 } from "@typescript-eslint/utils";
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
@@ -19953,18 +20283,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES80.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES81.Identifier ? callee.property.name : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES80.Identifier) {
+    if (current.type === AST_NODE_TYPES81.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES80.MemberExpression) {
+    if (current.type === AST_NODE_TYPES81.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES80.CallExpression) {
+    if (current.type === AST_NODE_TYPES81.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -19975,13 +20305,13 @@ var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES80.MemberExpression) {
-      if (current.computed || current.property.type !== AST_NODE_TYPES80.Identifier) return [];
+    if (current.type === AST_NODE_TYPES81.MemberExpression) {
+      if (current.computed || current.property.type !== AST_NODE_TYPES81.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES80.CallExpression) {
+    if (current.type === AST_NODE_TYPES81.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -19992,16 +20322,16 @@ var chainMemberNames2 = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === AST_NODE_TYPES80.TSAsExpression || current.type === AST_NODE_TYPES80.TSSatisfiesExpression || current.type === AST_NODE_TYPES80.TSNonNullExpression || current.type === AST_NODE_TYPES80.TSTypeAssertion) {
+  while (current.type === AST_NODE_TYPES81.TSAsExpression || current.type === AST_NODE_TYPES81.TSSatisfiesExpression || current.type === AST_NODE_TYPES81.TSNonNullExpression || current.type === AST_NODE_TYPES81.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES80.VariableDeclaration) return false;
+  if (declaration.type !== AST_NODE_TYPES81.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === AST_NODE_TYPES80.Program || owner.type === AST_NODE_TYPES80.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES80.Program;
+  return owner.type === AST_NODE_TYPES81.Program || owner.type === AST_NODE_TYPES81.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES81.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -20042,8 +20372,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === AST_NODE_TYPES80.Identifier) return isSchemaBinding(init);
-      if (init.type !== AST_NODE_TYPES80.CallExpression || init.callee.type !== AST_NODE_TYPES80.MemberExpression) {
+      if (init.type === AST_NODE_TYPES81.Identifier) return isSchemaBinding(init);
+      if (init.type !== AST_NODE_TYPES81.CallExpression || init.callee.type !== AST_NODE_TYPES81.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -20063,7 +20393,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 === AST_NODE_TYPES80.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES80.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES80.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES80.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES81.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES81.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES81.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES81.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -20072,7 +20402,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 !== AST_NODE_TYPES80.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES81.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -20251,6 +20581,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,
@@ -20266,7 +20597,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", {
@@ -20289,6 +20620,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"
@@ -20370,6 +20702,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",
@@ -20467,6 +20800,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",