@sarj/eslint-plugin 15.13.3 → 15.14.0

package/dist/index.cjs

@@ -12039,9 +12039,165 @@ var prefer_non_nullable_collection_default = createRule({
   }
 });
 
-// src/rules/prefer-await-in-async-return.ts
+// src/rules/prefer-nullish-filter-predicate.ts
 var import_utils68 = require("@typescript-eslint/utils");
-var ts3 = __toESM(require("typescript"), 1);
+var import_typescript = __toESM(require("typescript"), 1);
+var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
+  summary: "Prefer an explicit nullish predicate when `filter(Boolean)` removes only nullish values but does not narrow the result type.",
+  rationale: "An explicit nullish predicate preserves the same runtime elements while letting TypeScript remove `null` and `undefined` from the result.",
+  remediation: "Replace `filter(Boolean)` with `filter((value) => value !== null && value !== undefined)`.",
+  category: "correctness",
+  autofix: "suggestion",
+  limitations: [
+    "The receiver must resolve to the built-in Array or ReadonlyArray filter method.",
+    "Broad primitive types, falsy literals, any, unknown, generics, intersections, custom filters, and shadowed Boolean bindings are excluded."
+  ],
+  examples: [
+    {
+      id: "explicit-nullish-predicate",
+      title: "Nullish filtering narrows the result",
+      outcome: "no-match",
+      files: [
+        {
+          path: "src/users.ts",
+          source: "declare const users: readonly ({ id: string } | null)[];\nconst present = users.filter((user) => user !== null && user !== undefined);"
+        }
+      ],
+      focusPath: "src/users.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "boolean-nullish-filter",
+      title: "Boolean filtering loses nullish narrowing",
+      outcome: "match",
+      files: [
+        {
+          path: "src/users.ts",
+          source: "declare const users: readonly ({ id: string } | null)[];\nconst present = users.filter(Boolean);"
+        }
+      ],
+      focusPath: "src/users.ts",
+      expectedCount: 1,
+      public: true
+    }
+  ]
+};
+function isUnshadowedBoolean(node, context) {
+  const variable = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+  return variable === null || variable.defs.length === 0;
+}
+function isBuiltinArrayFilter(node, services) {
+  const checker = services.program.getTypeChecker();
+  const property = services.esTreeNodeToTSNodeMap.get(node.property);
+  const symbol = checker.getSymbolAtLocation(property);
+  return symbol?.declarations?.some((declaration) => {
+    const owner = declaration.parent;
+    return import_typescript.default.isInterfaceDeclaration(owner) && (owner.name.text === "Array" || owner.name.text === "ReadonlyArray") && services.program.isSourceFileDefaultLibrary(owner.getSourceFile());
+  }) ?? false;
+}
+function arrayElementType(node, services) {
+  const checker = services.program.getTypeChecker();
+  const receiver = services.esTreeNodeToTSNodeMap.get(node);
+  return checker.getIndexTypeOfType(checker.getTypeAtLocation(receiver), import_typescript.default.IndexKind.Number) ?? null;
+}
+var NULLISH_FLAGS = import_typescript.default.TypeFlags.Null | import_typescript.default.TypeFlags.Undefined;
+var UNKNOWN_FLAGS = import_typescript.default.TypeFlags.Any | import_typescript.default.TypeFlags.Unknown | import_typescript.default.TypeFlags.TypeParameter | import_typescript.default.TypeFlags.Intersection | import_typescript.default.TypeFlags.Enum | import_typescript.default.TypeFlags.EnumLiteral;
+function isNullishPlusTruthy(type, checker) {
+  const members = type.isUnion() ? type.types : [type];
+  let sawNullish = false;
+  for (const member of members) {
+    if ((member.flags & NULLISH_FLAGS) !== 0) {
+      sawNullish = true;
+    } else if ((member.flags & import_typescript.default.TypeFlags.Never) === 0 && !isProvablyTruthy(member, checker)) {
+      return false;
+    }
+  }
+  return sawNullish;
+}
+function isProvablyTruthy(type, checker) {
+  if ((type.flags & UNKNOWN_FLAGS) !== 0) return false;
+  if ((type.flags & import_typescript.default.TypeFlags.Object) !== 0) {
+    return ![
+      checker.getStringType(),
+      checker.getNumberType(),
+      checker.getBigIntType(),
+      checker.getBooleanType()
+    ].some((primitive) => checker.isTypeAssignableTo(primitive, type));
+  }
+  if ((type.flags & (import_typescript.default.TypeFlags.ESSymbol | import_typescript.default.TypeFlags.UniqueESSymbol)) !== 0) return true;
+  if ((type.flags & import_typescript.default.TypeFlags.BooleanLiteral) !== 0) {
+    return type.intrinsicName === "true";
+  }
+  if ((type.flags & import_typescript.default.TypeFlags.StringLiteral) !== 0) {
+    return type.value.length > 0;
+  }
+  if ((type.flags & import_typescript.default.TypeFlags.NumberLiteral) !== 0) {
+    const value = type.value;
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if ((type.flags & import_typescript.default.TypeFlags.BigIntLiteral) !== 0) {
+    return type.value.base10Value !== "0";
+  }
+  return false;
+}
+function availableParameterName(node, context) {
+  for (const name of ["value", "item", "element", "candidate"]) {
+    if (import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+  }
+  return null;
+}
+var prefer_nullish_filter_predicate_default = createRule({
+  name: "prefer-nullish-filter-predicate",
+  documentation: PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION.summary },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      preferNullishPredicate: "This built-in array contains only nullish or provably truthy values, so `filter(Boolean)` preserves runtime values but loses nullish narrowing. Use an explicit nullish predicate.",
+      replaceBoolean: "Replace `Boolean` with an explicit nullish predicate."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    let services;
+    try {
+      services = import_utils68.ESLintUtils.getParserServices(context);
+    } catch {
+      services = null;
+    }
+    if (services === null) return {};
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const callback = node.arguments[0];
+        if (node.arguments.length !== 1 || callback?.type !== import_utils68.AST_NODE_TYPES.Identifier || callback.name !== "Boolean" || callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils68.AST_NODE_TYPES.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
+        const elementType = arrayElementType(callee.object, services);
+        const checker = services.program.getTypeChecker();
+        if (elementType === null || !isNullishPlusTruthy(elementType, checker)) return;
+        const parameter = availableParameterName(node, context);
+        context.report({
+          node: callback,
+          messageId: "preferNullishPredicate",
+          suggest: parameter === null ? null : [{
+            messageId: "replaceBoolean",
+            fix: (fixer) => fixer.replaceText(
+              callback,
+              `(${parameter}) => ${parameter} !== null && ${parameter} !== undefined`
+            )
+          }]
+        });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-await-in-async-return.ts
+var import_utils69 = require("@typescript-eslint/utils");
+var ts4 = __toESM(require("typescript"), 1);
 var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
   summary: "Prefer explicit `await` when an async function directly returns one typed Promise `.then` transform.",
   rationale: "Mixing a directly returned Promise callback into otherwise async control flow makes sequencing and failures harder to read.",
@@ -12082,10 +12238,10 @@ var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
 };
 function directAsyncReturnOwner(node) {
   const parent = node.parent;
-  if (parent.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
+  if (parent.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
     return parent.async && !parent.generator ? parent : null;
   }
-  if (parent.type !== import_utils68.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
+  if (parent.type !== import_utils69.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
     return null;
   }
   let owner = parent.parent;
@@ -12095,15 +12251,15 @@ function directAsyncReturnOwner(node) {
   return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
-  return node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils68.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils69.AST_NODE_TYPES.FunctionExpression;
 }
 function promiseThenReceiver(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils68.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
+  if (callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils69.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
     return null;
   }
   const callback = node.arguments[0];
-  if (callback === void 0 || callback.type !== import_utils68.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils68.AST_NODE_TYPES.FunctionExpression) {
+  if (callback === void 0 || callback.type !== import_utils69.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils69.AST_NODE_TYPES.FunctionExpression) {
     return null;
   }
   return callee.object;
@@ -12112,14 +12268,14 @@ function isProvenPromiseLike(node, services) {
   const checker = services.program.getTypeChecker();
   const tsNode = services.esTreeNodeToTSNodeMap.get(node);
   const receiverType = checker.getTypeAtLocation(tsNode);
-  if ((receiverType.flags & (ts3.TypeFlags.Any | ts3.TypeFlags.Unknown | ts3.TypeFlags.Never)) !== 0) {
+  if ((receiverType.flags & (ts4.TypeFlags.Any | ts4.TypeFlags.Unknown | ts4.TypeFlags.Never)) !== 0) {
     return false;
   }
   const thenSymbol = checker.getPropertyOfType(receiverType, "then");
   const hasBuiltInPromiseDeclaration = thenSymbol?.declarations?.some(
     (declaration) => {
       let owner = declaration.parent;
-      while (owner !== void 0 && !ts3.isInterfaceDeclaration(owner)) {
+      while (owner !== void 0 && !ts4.isInterfaceDeclaration(owner)) {
         owner = owner.parent;
       }
       return owner !== void 0 && (owner.name.text === "Promise" || owner.name.text === "PromiseLike") && services.program.isSourceFileDefaultLibrary(owner.getSourceFile());
@@ -12144,32 +12300,32 @@ var prefer_await_in_async_return_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils68.ESLintUtils.getParserServices(context);
+      services = import_utils69.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = import_utils69.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
-      if (parent.type !== import_utils68.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils68.AST_NODE_TYPES.Identifier) return false;
-      const variable = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      if (parent.type !== import_utils69.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils69.AST_NODE_TYPES.Identifier) return false;
+      const variable = import_utils69.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
       return variable !== null && frameworkLoaders.has(variable);
     };
     return {
       ImportDeclaration(node) {
         if (node.source.value === "react") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils68.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils68.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
           }
         }
         if (node.source.value === "next/dynamic") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils68.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
           }
         }
       },
@@ -12187,7 +12343,7 @@ var prefer_await_in_async_return_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils69 = require("@typescript-eslint/utils");
+var import_utils70 = require("@typescript-eslint/utils");
 var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
   summary: "Require Zod (or similar) schema validation on `response.json()` / `JSON.parse()` results before property access.",
   rationale: "External JSON is untrusted at runtime even when its expected TypeScript shape is known statically.",
@@ -12202,9 +12358,9 @@ var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils69.AST_NODE_TYPES.TSAsExpression || current.type === import_utils69.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils69.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils69.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils70.AST_NODE_TYPES.TSAsExpression || current.type === import_utils70.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils70.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils70.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils69.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils70.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -12219,23 +12375,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === import_utils69.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils69.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === import_utils70.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils70.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node, isKnownLocalText) => {
   let current = unwrap4(node);
   if (current === null) return false;
-  if (current.type === import_utils69.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils70.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== import_utils69.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils70.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== import_utils69.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils70.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -12245,17 +12401,17 @@ var isRawPayloadSource = (node, isKnownLocalText) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils69.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
+  return property.name === "parse" && object !== null && object.type === import_utils70.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isDirectLocalFileRead = (node) => {
   let current = unwrap4(node);
-  if (current?.type === import_utils69.AST_NODE_TYPES.AwaitExpression) {
+  if (current?.type === import_utils70.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current?.type !== import_utils69.AST_NODE_TYPES.CallExpression) return false;
+  if (current?.type !== import_utils70.AST_NODE_TYPES.CallExpression) return false;
   const callee = unwrap4(current.callee);
-  const name = callee?.type === import_utils69.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils69.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils69.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+  const name = callee?.type === import_utils70.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils70.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils70.AST_NODE_TYPES.Identifier ? callee.property.name : null;
   return name !== null && FILE_READ_RE.test(name);
 };
 var isLocalFileRead = (node) => {
@@ -12282,15 +12438,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils69.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils70.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils69.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils70.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils69.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils70.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils69.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils70.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -12309,22 +12465,22 @@ var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
 var isValidationRead = (node) => {
   let current = node;
   let parent = current.parent;
-  while (parent !== null && parent !== void 0 && (parent.type === import_utils69.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils69.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils69.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils69.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils69.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils70.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils70.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils70.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils70.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils70.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils69.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils70.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils69.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils70.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils69.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils69.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils70.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "bigint",
@@ -12335,13 +12491,13 @@ var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "undefined"
 ]);
 var bindingValidationPolarity = (test, bindingName) => {
-  if (test.type === import_utils69.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils70.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = bindingValidationPolarity(test.argument, bindingName);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils69.AST_NODE_TYPES.BinaryExpression) {
-    const typeofName = (node) => node.type === import_utils69.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils69.AST_NODE_TYPES.Identifier ? node.argument.name : null;
-    const literalType = (node) => node.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+  if (test.type === import_utils70.AST_NODE_TYPES.BinaryExpression) {
+    const typeofName = (node) => node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils70.AST_NODE_TYPES.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
     const matches = typeofName(test.left) === bindingName && literalType(test.right) !== null || typeofName(test.right) === bindingName && literalType(test.left) !== null;
     if (!matches) return null;
     if (test.operator === "===" || test.operator === "==") {
@@ -12349,9 +12505,9 @@ var bindingValidationPolarity = (test, bindingName) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils69.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils69.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils69.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils70.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils70.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
-var plainMemberAccess = (node) => node.type === import_utils69.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils69.AST_NODE_TYPES.Identifier && node.property.type === import_utils69.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
+var plainMemberAccess = (node) => node.type === import_utils70.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.property.type === import_utils70.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
 var isSamePlainMember = (node, access) => {
   const candidate2 = plainMemberAccess(node);
   return candidate2 !== null && candidate2.object === access.object && candidate2.property === access.property;
@@ -12359,19 +12515,19 @@ var isSamePlainMember = (node, access) => {
 var nodeWithin2 = (node, container) => node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
 var isUseWithinValidatedBranch = (node, bindingName) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils69.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils69.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils69.AST_NODE_TYPES.FunctionExpression || current.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
@@ -12379,32 +12535,32 @@ var isUseWithinValidatedBranch = (node, bindingName) => {
 };
 var isMemberUseWithinValidatedBranch = (node, access) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils69.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils69.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils69.AST_NODE_TYPES.FunctionExpression || current.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
   return false;
 };
 var memberValidationPolarity = (test, access) => {
-  if (test.type === import_utils69.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils70.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = memberValidationPolarity(test.argument, access);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils69.AST_NODE_TYPES.BinaryExpression) {
-    const isMatchingTypeof = (node) => node.type === import_utils69.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+  if (test.type === import_utils70.AST_NODE_TYPES.BinaryExpression) {
+    const isMatchingTypeof = (node) => node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
+    const isPrimitiveType = (node) => node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
     if (!(isMatchingTypeof(test.left) && isPrimitiveType(test.right) || isMatchingTypeof(test.right) && isPrimitiveType(test.left))) {
       return null;
     }
@@ -12413,15 +12569,15 @@ var memberValidationPolarity = (test, access) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils69.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils69.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils69.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils70.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils70.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
 var isFullyValidatedExtractedBinding = (member, source, context) => {
   const isValidationReference = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if ((current.type === import_utils69.AST_NODE_TYPES.BinaryExpression || current.type === import_utils69.AST_NODE_TYPES.CallExpression || current.type === import_utils69.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+      if ((current.type === import_utils70.AST_NODE_TYPES.BinaryExpression || current.type === import_utils70.AST_NODE_TYPES.CallExpression || current.type === import_utils70.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
         return true;
       }
-      if (current.type !== import_utils69.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils69.AST_NODE_TYPES.MemberExpression && current.type !== import_utils69.AST_NODE_TYPES.CallExpression) {
+      if (current.type !== import_utils70.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils70.AST_NODE_TYPES.MemberExpression && current.type !== import_utils70.AST_NODE_TYPES.CallExpression) {
         return false;
       }
     }
@@ -12429,7 +12585,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   };
   const isGuardedUse = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if (current.type === import_utils69.AST_NODE_TYPES.ConditionalExpression) {
+      if (current.type === import_utils70.AST_NODE_TYPES.ConditionalExpression) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12438,7 +12594,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils69.AST_NODE_TYPES.IfStatement) {
+      if (current.type === import_utils70.AST_NODE_TYPES.IfStatement) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12447,14 +12603,14 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils69.AST_NODE_TYPES.FunctionExpression || current.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression || current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression) {
         return false;
       }
     }
     return false;
   };
   const declarator = member.parent;
-  if (declarator.type !== import_utils69.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils69.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils69.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
+  if (declarator.type !== import_utils70.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils70.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils70.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
     return false;
   }
   const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
@@ -12462,7 +12618,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   let hasValueUse = false;
   for (const reference of extracted.references) {
     const identifier = reference.identifier;
-    if (identifier.type !== import_utils69.AST_NODE_TYPES.Identifier) return false;
+    if (identifier.type !== import_utils70.AST_NODE_TYPES.Identifier) return false;
     if (nodeWithin2(identifier, declarator)) continue;
     if (isValidationReference(identifier)) continue;
     hasValueUse = true;
@@ -12475,17 +12631,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils69.AST_NODE_TYPES.UnaryExpression:
-      case import_utils69.AST_NODE_TYPES.LogicalExpression:
-      case import_utils69.AST_NODE_TYPES.ChainExpression:
+      case import_utils70.AST_NODE_TYPES.UnaryExpression:
+      case import_utils70.AST_NODE_TYPES.LogicalExpression:
+      case import_utils70.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils69.AST_NODE_TYPES.IfStatement:
-      case import_utils69.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils69.AST_NODE_TYPES.WhileStatement:
-      case import_utils69.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils69.AST_NODE_TYPES.ForStatement:
+      case import_utils70.AST_NODE_TYPES.IfStatement:
+      case import_utils70.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils70.AST_NODE_TYPES.WhileStatement:
+      case import_utils70.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils70.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -12495,7 +12651,7 @@ var isGuardTestPosition = (node) => {
 };
 var unvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== import_utils69.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils70.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -12524,7 +12680,7 @@ var prefer_schema_for_api_payload_default = createRule({
     const localFileTextVariables = /* @__PURE__ */ new Set();
     const localFileTextRef = (node, scope) => {
       const unwrapped = unwrap4(node);
-      if (unwrapped?.type !== import_utils69.AST_NODE_TYPES.Identifier) return null;
+      if (unwrapped?.type !== import_utils70.AST_NODE_TYPES.Identifier) return null;
       const variable = findVariable2(scope, unwrapped.name);
       return variable !== null && localFileTextVariables.has(variable) ? variable : null;
     };
@@ -12593,7 +12749,7 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils69.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils70.AST_NODE_TYPES.Identifier) {
           const variable = context.sourceCode.getDeclaredVariables(node)[0];
           if (variable !== void 0) {
             updateLocalFileText(variable, node.init, scope);
@@ -12601,7 +12757,7 @@ var prefer_schema_for_api_payload_default = createRule({
           trackInitializer(node, scope);
           return;
         }
-        if (node.id.type === import_utils69.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils69.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils70.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils70.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.init,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -12618,7 +12774,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils69.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils70.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           const isLocalText = (candidate2) => localFileTextRef(candidate2, scope) !== null;
@@ -12632,7 +12788,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils69.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils69.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils70.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils70.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.right,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -12652,15 +12808,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils69.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils70.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils69.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils70.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils69.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils70.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -12677,14 +12833,14 @@ var prefer_schema_for_api_payload_default = createRule({
           (candidate2) => localFileTextRef(candidate2, scope) !== null
         )) {
           const parent = node.parent;
-          if (parent.type === import_utils69.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils69.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils70.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        const variable = obj?.type === import_utils69.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
-        if (variable !== null && obj?.type === import_utils69.AST_NODE_TYPES.Identifier) {
+        const variable = obj?.type === import_utils70.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null && obj?.type === import_utils70.AST_NODE_TYPES.Identifier) {
           if (isUseWithinValidatedBranch(node, obj.name)) {
             return;
           }
@@ -12704,7 +12860,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils70 = require("@typescript-eslint/utils");
+var import_utils71 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -12816,7 +12972,7 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils70.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils71.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -12826,8 +12982,8 @@ var isInsideSvg = (node) => {
 };
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils70.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils70.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils70.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils71.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils71.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils71.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -12853,7 +13009,7 @@ function isSvgLikeElementName(name) {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils70.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils70.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils70.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils70.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils71.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils71.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils71.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils71.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -12987,12 +13143,12 @@ var expandWorkspaceGlob = (root, glob) => {
   return (0, import_fs.readdirSync)(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => (0, import_path.join)(parent, entry.name));
 };
 var propName = (key) => {
-  if (key.type === import_utils70.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils70.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils71.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils71.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== import_utils70.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils70.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils70.AST_NODE_TYPES.ExportAllDeclaration) {
+  if (statement.type !== import_utils71.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils71.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils71.AST_NODE_TYPES.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -13045,27 +13201,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils70.AST_NODE_TYPES.Literal:
+        case import_utils71.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils70.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils71.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils70.AST_NODE_TYPES.ArrayExpression:
+        case import_utils71.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils70.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils71.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils70.AST_NODE_TYPES.ObjectExpression:
+        case import_utils71.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils70.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils71.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils70.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils71.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils70.AST_NODE_TYPES.LogicalExpression:
+        case import_utils71.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -13073,32 +13229,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         report(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils70.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils70.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils70.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils71.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils71.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils71.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === import_utils70.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils70.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils71.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils70.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils71.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -13108,9 +13264,9 @@ var prefer_semantic_colors_default = createRule({
       },
       // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils70.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils71.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils70.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils71.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -13124,7 +13280,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -13137,7 +13293,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils71 = require("@typescript-eslint/utils");
+var import_utils72 = require("@typescript-eslint/utils");
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
   summary: "Prefer Next.js Server Actions over /api/* mutations.",
   rationale: "Server Actions preserve typed application calls and avoid an internal JSON request-response boundary.",
@@ -13326,7 +13482,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils72 = require("@typescript-eslint/utils");
+var import_utils73 = require("@typescript-eslint/utils");
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
@@ -13351,11 +13507,11 @@ var PREFER_WHOLE_OBJECT_ASSERTION_DOCUMENTATION = {
 };
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils72.AST_NODE_TYPES.Literal:
+    case import_utils73.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils72.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils73.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils72.AST_NODE_TYPES.UnaryExpression:
+    case import_utils73.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -13363,15 +13519,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils72.AST_NODE_TYPES.Identifier:
-    case import_utils72.AST_NODE_TYPES.ThisExpression:
+    case import_utils73.AST_NODE_TYPES.Identifier:
+    case import_utils73.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils72.AST_NODE_TYPES.MemberExpression:
+    case import_utils73.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils72.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils73.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -13379,7 +13535,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils72.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils73.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -13387,8 +13543,8 @@ function literalIndex(node) {
 function propertyAccess(node) {
   const path = [];
   let current = node;
-  while (current.type === import_utils72.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
-    if (current.property.type !== import_utils72.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+  while (current.type === import_utils73.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== import_utils73.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
     path.unshift(current.property.name);
     current = current.object;
   }
@@ -13416,24 +13572,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils72.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils73.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils72.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils72.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils72.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils73.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils72.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils72.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils73.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== import_utils72.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils73.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -13462,7 +13618,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils72.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils73.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -13603,7 +13759,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-var import_utils73 = require("@typescript-eslint/utils");
+var import_utils74 = require("@typescript-eslint/utils");
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -13624,67 +13780,67 @@ var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
 function staticMemberName5(node) {
-  if (!node.computed && node.property.type === import_utils73.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils73.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils74.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils74.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function importedName5(identifier, context, modules) {
-  const variable = import_utils73.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = import_utils74.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
-    if (definition.node.type !== import_utils73.AST_NODE_TYPES.ImportSpecifier) continue;
+    if (definition.node.type !== import_utils74.AST_NODE_TYPES.ImportSpecifier) continue;
     const declaration = definition.node.parent;
-    if (declaration.type !== import_utils73.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
+    if (declaration.type !== import_utils74.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     const imported = definition.node.imported;
-    return imported.type === import_utils73.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
+    return imported.type === import_utils74.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
   }
   return null;
 }
 function isDirectTestCallback2(node, context) {
-  if (node.type !== import_utils73.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils73.AST_NODE_TYPES.FunctionExpression) return false;
+  if (node.type !== import_utils74.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils74.AST_NODE_TYPES.FunctionExpression) return false;
   const call = node.parent;
-  if (call?.type !== import_utils73.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
+  if (call?.type !== import_utils74.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
   const root = testRoot2(call.callee);
   return root !== null && TEST_NAMES2.has(importedName5(root, context, TEST_MODULES4) ?? "");
 }
 function testRoot2(callee) {
-  if (callee.type === import_utils73.AST_NODE_TYPES.Identifier) return callee;
-  if (callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression) return null;
+  if (callee.type === import_utils74.AST_NODE_TYPES.Identifier) return callee;
+  if (callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression) return null;
   const modifier = staticMemberName5(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
-  if (node.type === import_utils73.AST_NODE_TYPES.TSAsExpression || node.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
+  if (node.type === import_utils74.AST_NODE_TYPES.TSAsExpression || node.type === import_utils74.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils74.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils74.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
   switch (node.type) {
-    case import_utils73.AST_NODE_TYPES.Literal:
+    case import_utils74.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils73.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils74.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils73.AST_NODE_TYPES.UnaryExpression:
+    case import_utils74.AST_NODE_TYPES.UnaryExpression:
       return (node.operator === "+" || node.operator === "-") && isStatic(node.argument);
-    case import_utils73.AST_NODE_TYPES.ArrayExpression:
-      return node.elements.every((item) => item !== null && item.type !== import_utils73.AST_NODE_TYPES.SpreadElement && isStatic(item));
-    case import_utils73.AST_NODE_TYPES.ObjectExpression:
-      return node.properties.every((property) => property.type === import_utils73.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils73.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
+    case import_utils74.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.every((item) => item !== null && item.type !== import_utils74.AST_NODE_TYPES.SpreadElement && isStatic(item));
+    case import_utils74.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.every((property) => property.type === import_utils74.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils74.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
     default:
       return false;
   }
 }
 function staticShape(node) {
-  if (node.type === import_utils73.AST_NODE_TYPES.TSAsExpression || node.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
+  if (node.type === import_utils74.AST_NODE_TYPES.TSAsExpression || node.type === import_utils74.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils74.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils74.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
   switch (node.type) {
-    case import_utils73.AST_NODE_TYPES.Literal:
+    case import_utils74.AST_NODE_TYPES.Literal:
       return `literal:${typeof node.value}`;
-    case import_utils73.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils74.AST_NODE_TYPES.TemplateLiteral:
       return "template";
-    case import_utils73.AST_NODE_TYPES.UnaryExpression:
+    case import_utils74.AST_NODE_TYPES.UnaryExpression:
       return `unary:${node.operator}:${staticShape(node.argument)}`;
-    case import_utils73.AST_NODE_TYPES.ArrayExpression:
-      return `array(${node.elements.map((item) => item === null || item.type === import_utils73.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
-    case import_utils73.AST_NODE_TYPES.ObjectExpression:
+    case import_utils74.AST_NODE_TYPES.ArrayExpression:
+      return `array(${node.elements.map((item) => item === null || item.type === import_utils74.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
+    case import_utils74.AST_NODE_TYPES.ObjectExpression:
       return `object(${node.properties.map((property) => {
-        if (property.type !== import_utils73.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils73.AST_NODE_TYPES.AssignmentPattern) return "invalid";
-        const key = property.key.type === import_utils73.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
+        if (property.type !== import_utils74.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils74.AST_NODE_TYPES.AssignmentPattern) return "invalid";
+        const key = property.key.type === import_utils74.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
         return `${key}:${staticShape(property.value)}`;
       }).join(",")})`;
     default:
@@ -13692,16 +13848,16 @@ function staticShape(node) {
   }
 }
 function assertionShape(statement, context) {
-  if (statement.type !== import_utils73.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils73.AST_NODE_TYPES.CallExpression) return null;
+  if (statement.type !== import_utils74.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils74.AST_NODE_TYPES.CallExpression) return null;
   const matcherCall = statement.expression;
-  if (matcherCall.callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils73.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
+  if (matcherCall.callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
   const matcher = matcherCall.callee.property.name;
   if (SNAPSHOT_MATCHERS.test(matcher)) return null;
   const chain = expectCallFromMatcher(matcherCall.callee);
-  if (chain === null || chain.call.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || importedName5(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
+  if (chain === null || chain.call.callee.type !== import_utils74.AST_NODE_TYPES.Identifier || importedName5(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
   const observed = chain.call.arguments[0];
   const expected = matcherCall.arguments[0];
-  if (observed?.type !== import_utils73.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils73.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils73.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
+  if (observed?.type !== import_utils74.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils74.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils74.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils74.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
   const skeleton = `${observed.callee.name}/${observed.arguments.map((item) => staticShape(item)).join(",")}/${chain.modifiers.join(".")}/${matcher}/${staticShape(expected)}`;
   const values = [...observed.arguments, expected].map((item) => context.sourceCode.getText(item)).join("\0");
   return { statement, skeleton, values };
@@ -13709,13 +13865,13 @@ function assertionShape(statement, context) {
 function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
-  while (receiver.type === import_utils73.AST_NODE_TYPES.MemberExpression) {
+  while (receiver.type === import_utils74.AST_NODE_TYPES.MemberExpression) {
     const modifier = staticMemberName5(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
   }
-  return receiver.type === import_utils73.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
+  return receiver.type === import_utils74.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
 }
 var repeated_static_call_cases_default = createRule({
   name: "repeated-static-call-cases",
@@ -13735,7 +13891,7 @@ var repeated_static_call_cases_default = createRule({
     return {
       "CallExpression > ArrowFunctionExpression, CallExpression > FunctionExpression"(node) {
         const call = node.parent;
-        if (call?.type === import_utils73.AST_NODE_TYPES.CallExpression) {
+        if (call?.type === import_utils74.AST_NODE_TYPES.CallExpression) {
           const duplicate = duplicateTestBodyCandidate(call, sourceCode);
           if (duplicate !== null && duplicate.body === node) {
             const groups = duplicateGroups.get(duplicate.container) ?? /* @__PURE__ */ new Map();
@@ -13745,7 +13901,7 @@ var repeated_static_call_cases_default = createRule({
             duplicateGroups.set(duplicate.container, groups);
           }
         }
-        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils73.AST_NODE_TYPES.BlockStatement) return;
+        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils74.AST_NODE_TYPES.BlockStatement) return;
         let run = [];
         const flush = () => {
           if (run.length >= MIN_CASES2 && new Set(run.map((item) => item.values)).size > 1) {
@@ -13786,7 +13942,7 @@ var repeated_static_call_cases_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils74 = require("@typescript-eslint/utils");
+var import_utils75 = require("@typescript-eslint/utils");
 var PREFER_ZOD_INFER_DOCUMENTATION = {
   summary: "Derive a type from its Zod schema with `z.infer` instead of hand-writing a twin declaration beside it.",
   rationale: "A derived type stays synchronized when the runtime schema changes.",
@@ -13839,47 +13995,47 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils74.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils74.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils74.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils74.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils74.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils74.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils74.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils74.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils74.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils74.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils74.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils74.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils74.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils74.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils74.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils74.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils74.AST_NODE_TYPES.TSArrayType, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils74.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils74.AST_NODE_TYPES.TSTypeLiteral, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils74.AST_NODE_TYPES.TSTypeLiteral, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils74.AST_NODE_TYPES.TSTypeLiteral, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils74.AST_NODE_TYPES.TSTypeReference, import_utils74.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils74.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils74.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils74.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils74.AST_NODE_TYPES.TSUnionType, import_utils74.AST_NODE_TYPES.TSTypeReference, import_utils74.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils74.AST_NODE_TYPES.TSUnionType, import_utils74.AST_NODE_TYPES.TSTypeReference, import_utils74.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils74.AST_NODE_TYPES.TSUnionType, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils74.AST_NODE_TYPES.TSUnionType, import_utils74.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils74.AST_NODE_TYPES.TSIntersectionType, import_utils74.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils75.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils75.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils75.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils75.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils75.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils75.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils75.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils75.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils75.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils75.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils75.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils75.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils75.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils75.AST_NODE_TYPES.TSArrayType, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils75.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils75.AST_NODE_TYPES.TSTypeLiteral, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils75.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils75.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils75.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference, import_utils75.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils75.AST_NODE_TYPES.TSUnionType, import_utils75.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils75.AST_NODE_TYPES.TSIntersectionType, import_utils75.AST_NODE_TYPES.TSTypeReference]
 };
 function primitiveLiteralKey(node) {
-  if (node.type !== import_utils74.AST_NODE_TYPES.Literal) {
+  if (node.type !== import_utils75.AST_NODE_TYPES.Literal) {
     return null;
   }
   if (node.value === null) {
@@ -13911,13 +14067,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "literal") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils74.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils74.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils75.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map(
-          (element) => element === null || element.type === import_utils74.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
+          (element) => element === null || element.type === import_utils75.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
         )
       );
     }
@@ -13925,13 +14081,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "enum") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils74.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils74.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils75.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map((element) => {
-          if (element === null || element.type === import_utils74.AST_NODE_TYPES.SpreadElement) {
+          if (element === null || element.type === import_utils75.AST_NODE_TYPES.SpreadElement) {
             return null;
           }
           const key = primitiveLiteralKey(element);
@@ -13939,10 +14095,10 @@ function staticZodDomain(leaf, call) {
         })
       );
     }
-    if (argument.type === import_utils74.AST_NODE_TYPES.ObjectExpression) {
+    if (argument.type === import_utils75.AST_NODE_TYPES.ObjectExpression) {
       return exactDomain(
         argument.properties.map((property) => {
-          if (property.type !== import_utils74.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
+          if (property.type !== import_utils75.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
             return null;
           }
           const key = primitiveLiteralKey(property.value);
@@ -13969,15 +14125,15 @@ function sameDomain(left, right) {
   return true;
 }
 function isExportedDeclaration(node) {
-  return node.parent?.type === import_utils74.AST_NODE_TYPES.ExportNamedDeclaration;
+  return node.parent?.type === import_utils75.AST_NODE_TYPES.ExportNamedDeclaration;
 }
 function isModuleLevelConst(node) {
   const declaration = node.parent;
-  if (declaration.type !== import_utils74.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== import_utils75.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === import_utils74.AST_NODE_TYPES.Program || container.type === import_utils74.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils74.AST_NODE_TYPES.Program;
+  return container.type === import_utils75.AST_NODE_TYPES.Program || container.type === import_utils75.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils75.AST_NODE_TYPES.Program;
 }
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -13986,20 +14142,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils74.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils74.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils75.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils74.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils75.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils74.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils75.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -14033,18 +14189,18 @@ function leafAgrees(field, annotation) {
     return null;
   }
   if (leaf === "date") {
-    return core.type === import_utils74.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils74.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
+    return core.type === import_utils75.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils75.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
   }
   return expected.includes(core.type);
 }
 function typeLiteralDomain(annotation) {
-  const members = annotation.type === import_utils74.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
+  const members = annotation.type === import_utils75.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
   const keys = [];
   for (const member of members) {
-    if (member.type === import_utils74.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils75.AST_NODE_TYPES.TSNullKeyword) {
       continue;
     }
-    if (member.type !== import_utils74.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils75.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     keys.push(primitiveLiteralKey(member.literal));
@@ -14052,11 +14208,11 @@ function typeLiteralDomain(annotation) {
   return exactDomain(keys);
 }
 function staticStringUnionDomain(node) {
-  if (node.type !== import_utils74.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
     return null;
   }
   const keys = node.types.map((member) => {
-    if (member.type !== import_utils74.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils75.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     const key = primitiveLiteralKey(member.literal);
@@ -14124,14 +14280,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils74.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils75.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils75.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils75.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils74.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils75.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -14140,14 +14296,14 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName2(call) {
       const callee = call.callee;
-      return callee.type === import_utils74.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils74.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils75.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils75.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
       }
       for (const specifier of node.specifiers) {
-        if (specifier.type === import_utils74.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils74.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+        if (specifier.type === import_utils75.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils75.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils75.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils75.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
           zodNamespaces.add(specifier.local.name);
         }
       }
@@ -14157,13 +14313,13 @@ var prefer_zod_infer_default = createRule({
       let current = node;
       let leaf = null;
       let leafCall = null;
-      while (current.type === import_utils74.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils75.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils75.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils75.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils74.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils75.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           leafCall = current;
           break;
@@ -14194,20 +14350,20 @@ var prefer_zod_infer_default = createRule({
       return domain instanceof Set && domain.size >= 2 ? domain : null;
     }
     function inferredSchemaName(node) {
-      if (node.type !== import_utils74.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils74.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils74.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
+      if (node.type !== import_utils75.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils75.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils75.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
         return null;
       }
       const arguments_ = node.typeArguments?.params ?? [];
       const [argument] = arguments_;
-      return arguments_.length === 1 && argument?.type === import_utils74.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils74.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
+      return arguments_.length === 1 && argument?.type === import_utils75.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils75.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
     }
     function recordLiteralUnions(members, owner, ownerName, exported) {
       for (const member of members) {
-        if (member.type !== import_utils74.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
+        if (member.type !== import_utils75.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
           continue;
         }
         const key = member.key;
-        const propertyName5 = key.type === import_utils74.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils74.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const propertyName5 = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (propertyName5 === null) {
           continue;
         }
@@ -14217,7 +14373,7 @@ var prefer_zod_infer_default = createRule({
         }
         const annotation = member.typeAnnotation.typeAnnotation;
         const domain = staticStringUnionDomain(annotation);
-        if (domain === null || annotation.type !== import_utils74.AST_NODE_TYPES.TSUnionType) {
+        if (domain === null || annotation.type !== import_utils75.AST_NODE_TYPES.TSUnionType) {
           continue;
         }
         literalUnionOccurrences.push({
@@ -14248,16 +14404,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils74.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils75.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils74.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils75.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils74.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils74.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14268,11 +14424,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils74.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils75.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils74.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils74.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils75.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils75.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14287,8 +14443,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils74.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils74.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils75.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils75.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -14296,11 +14452,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils74.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils75.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils74.AST_NODE_TYPES.TSUnionType || node.type === import_utils74.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils75.AST_NODE_TYPES.TSUnionType || node.type === import_utils75.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -14344,7 +14500,7 @@ var prefer_zod_infer_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          if (statement.type === import_utils74.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type === import_utils75.AST_NODE_TYPES.ImportDeclaration) {
             recordZodImport(statement);
           }
         }
@@ -14353,7 +14509,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils74.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils75.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -14370,14 +14526,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils74.AST_NODE_TYPES.Identifier && node.property.type === import_utils74.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils75.AST_NODE_TYPES.Identifier && node.property.type === import_utils75.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils74.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils74.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils74.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils75.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils75.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils75.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -14409,7 +14565,7 @@ var prefer_zod_infer_default = createRule({
             typeName: node.id.name
           });
         }
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils74.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils75.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -14508,8 +14664,8 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils75 = require("@typescript-eslint/utils");
-var import_typescript = __toESM(require("typescript"), 1);
+var import_utils76 = require("@typescript-eslint/utils");
+var import_typescript2 = __toESM(require("typescript"), 1);
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
   rationale: "An empty default silently accepts new union members instead of making the compiler identify the missing case.",
@@ -14521,14 +14677,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils75.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils75.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils76.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils76.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils75.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils75.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils76.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils76.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils75.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils76.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -14544,7 +14700,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils75.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils76.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -14556,7 +14712,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   const constituents = discriminantType.isUnion() ? discriminantType.types : [discriminantType];
   if (!discriminantType.isUnion() || constituents.length < 2) return false;
   if (constituents.every(
-    (constituent) => (constituent.flags & import_typescript.default.TypeFlags.BooleanLiteral) !== 0
+    (constituent) => (constituent.flags & import_typescript2.default.TypeFlags.BooleanLiteral) !== 0
   )) {
     return false;
   }
@@ -14580,7 +14736,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   return [...expected].every((key) => handled.has(key));
 }
 function finiteTypeKey(type, checker) {
-  const finiteFlags = import_typescript.default.TypeFlags.StringLiteral | import_typescript.default.TypeFlags.NumberLiteral | import_typescript.default.TypeFlags.BooleanLiteral | import_typescript.default.TypeFlags.EnumLiteral | import_typescript.default.TypeFlags.UniqueESSymbol | import_typescript.default.TypeFlags.Null | import_typescript.default.TypeFlags.Undefined;
+  const finiteFlags = import_typescript2.default.TypeFlags.StringLiteral | import_typescript2.default.TypeFlags.NumberLiteral | import_typescript2.default.TypeFlags.BooleanLiteral | import_typescript2.default.TypeFlags.EnumLiteral | import_typescript2.default.TypeFlags.UniqueESSymbol | import_typescript2.default.TypeFlags.Null | import_typescript2.default.TypeFlags.Undefined;
   return (type.flags & finiteFlags) !== 0 ? checker.typeToString(type) : null;
 }
 var require_assert_never_default = createRule({
@@ -14600,7 +14756,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils75.ESLintUtils.getParserServices(context);
+      services = import_utils76.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -14627,7 +14783,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils76 = require("@typescript-eslint/utils");
+var import_utils77 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -14653,14 +14809,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils76.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils77.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils76.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils77.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils76.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils76.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils77.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils77.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -14670,7 +14826,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils76.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils76.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils76.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils77.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils77.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils77.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils77.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -14708,30 +14864,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils76.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils77.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils76.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils77.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils76.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils76.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils76.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils77.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils77.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils77.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils76.ASTUtils.findVariable(
+      const variable = import_utils77.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils76.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils77.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
         return false;
       }
       for (const reference of variable.references) {
         const ref = reference.identifier;
         if (ref === identifier || ref === definition.name) continue;
         const member = ref.parent;
-        if (member.type !== import_utils76.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils76.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils76.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils77.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils77.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils77.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -14746,7 +14902,7 @@ var require_fetch_timeout_default = createRule({
         if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils76.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils77.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -14755,7 +14911,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-port-for-service.ts
-var import_utils77 = require("@typescript-eslint/utils");
+var import_utils78 = require("@typescript-eslint/utils");
 var REQUIRE_PORT_FOR_SERVICE_DOCUMENTATION = {
   summary: "Advise when an exported service with injected collaborators has public methods not covered by its declared ports.",
   rationale: "A declared port keeps consumers coupled to the service capability instead of its concrete implementation.",
@@ -14780,45 +14936,45 @@ var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
 var staticMemberName6 = (member) => {
-  if (member.property.type === import_utils77.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils77.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils77.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === import_utils78.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === import_utils78.AST_NODE_TYPES.Identifier) return member.property.name;
+  return member.computed && member.property.type === import_utils78.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
         if (specifier.exportKind !== "type") names.add(specifier.local.name);
       }
-    } else if (statement.type === import_utils77.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils77.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils78.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils77.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils77.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils78.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils78.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils77.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils77.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils78.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils77.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils77.AST_NODE_TYPES.TSNullKeyword
+      (member) => member.type !== import_utils78.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils78.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils77.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils78.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils77.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils77.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils78.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils78.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === import_utils77.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils77.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils78.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils78.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils77.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils77.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -14829,18 +14985,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils77.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils77.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils77.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils77.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils78.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils78.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils77.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils77.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils77.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils78.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -14869,10 +15025,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === import_utils77.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils77.AST_NODE_TYPES.FunctionExpression || current.type === import_utils77.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils77.AST_NODE_TYPES.ClassExpression || current.type === import_utils77.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils77.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils77.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils77.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils77.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils77.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils77.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils77.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (current.type === import_utils78.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils78.AST_NODE_TYPES.ClassExpression || current.type === import_utils78.AST_NODE_TYPES.ClassDeclaration) continue;
+      const expression = current.type === import_utils78.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === import_utils78.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils78.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils78.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== import_utils78.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils78.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils78.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -14885,14 +15041,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils77.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils77.AST_NODE_TYPES.TSAsExpression || source.type === import_utils77.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils77.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils77.AST_NODE_TYPES.NewExpression) {
+      while (source.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils78.AST_NODE_TYPES.TSAsExpression || source.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
+      if (source.type === import_utils78.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils77.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils78.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === import_utils77.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils77.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils78.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils78.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -14910,7 +15066,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared, storedMemberFieldsFrom)) {
-      const fields = parameter.type === import_utils77.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === import_utils78.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
       if (fields.length === 0) continue;
       if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
       if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -14925,8 +15081,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils77.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils77.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils78.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -14935,9 +15091,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils77.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils77.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils77.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils78.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils78.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -14953,9 +15109,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils77.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils77.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils77.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils78.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils78.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -14967,11 +15123,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils77.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils77.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils78.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils77.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils77.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils78.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -14981,21 +15137,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils77.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils78.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils77.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils77.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils78.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils78.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils77.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils78.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils77.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils77.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils77.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils78.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils78.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils78.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils77.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils77.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils78.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils78.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -15022,19 +15178,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils77.AST_NODE_TYPES.ChainExpression || callee.type === import_utils77.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils77.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils77.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils77.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils77.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === import_utils78.AST_NODE_TYPES.ChainExpression || callee.type === import_utils78.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
+  return callee.type === import_utils78.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === import_utils77.AST_NODE_TYPES.ChainExpression || node.type === import_utils77.AST_NODE_TYPES.TSAsExpression || node.type === import_utils77.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils77.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils77.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils77.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils77.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === import_utils78.AST_NODE_TYPES.ChainExpression || node.type === import_utils78.AST_NODE_TYPES.TSAsExpression || node.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+  return node.type === import_utils78.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils78.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils77.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils77.AST_NODE_TYPES.ClassExpression || current.type === import_utils77.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils77.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils77.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils78.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils78.AST_NODE_TYPES.ClassExpression || current.type === import_utils78.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils78.AST_NODE_TYPES.FunctionExpression) return;
+    if (current.type === import_utils78.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -15047,14 +15203,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils77.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils77.AST_NODE_TYPES.MethodDefinition) {
+    if (member.type === import_utils78.AST_NODE_TYPES.StaticBlock || member.static) continue;
+    if (member.type === import_utils78.AST_NODE_TYPES.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== import_utils77.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
+    if (member.type !== import_utils78.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === import_utils77.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === import_utils78.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -15074,25 +15230,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils77.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === import_utils77.AST_NODE_TYPES.PropertyDefinition) {
+    if (member.type === import_utils78.AST_NODE_TYPES.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.value?.type !== import_utils77.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils77.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils77.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils77.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils77.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
+      if (member.value?.type !== import_utils78.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils78.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils78.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === import_utils78.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
       continue;
     }
-    if (member.type !== import_utils77.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils78.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils77.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils77.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils78.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils78.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -15100,13 +15256,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils77.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === import_utils78.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
   );
   if (methods.length === 0) return false;
   return methods.every((member) => {
     const result = member.value.returnType?.typeAnnotation;
     if (result === void 0) return false;
-    const returnsOwnType = result.type === import_utils77.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils77.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils78.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -15114,10 +15270,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils77.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils77.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils78.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils78.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils77.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils78.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -15139,43 +15295,43 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils77.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils77.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils78.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils78.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === import_utils77.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils77.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils78.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils78.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== import_utils77.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils78.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== import_utils77.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils77.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils77.AST_NODE_TYPES.Identifier) continue;
-          if (member.type === import_utils77.AST_NODE_TYPES.TSMethodSignature) {
+          if (member.type !== import_utils78.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
+          if (member.type === import_utils78.AST_NODE_TYPES.TSMethodSignature) {
             callables2.add(member.key.name);
             continue;
           }
-          if (member.type !== import_utils77.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils77.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils77.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils77.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === import_utils78.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils78.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       continue;
     }
-    if (declaration?.type !== import_utils77.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== import_utils78.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== import_utils77.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils77.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils77.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils77.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils77.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils77.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      if (member.type !== import_utils78.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils78.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== import_utils78.AST_NODE_TYPES.Identifier) continue;
+      if (member.type === import_utils78.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils78.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils78.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -15183,7 +15339,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils77.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils78.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -15210,7 +15366,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils77.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils78.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -15222,7 +15378,7 @@ function hasServicePort(node, methods, classes, interfaces) {
   if (node.implements.length === 0) return false;
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== import_utils77.AST_NODE_TYPES.Identifier) return true;
+    if (implementation.expression.type !== import_utils78.AST_NODE_TYPES.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -15265,7 +15421,7 @@ var require_port_for_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils77.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === import_utils78.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -15300,7 +15456,7 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils78 = require("@typescript-eslint/utils");
+var import_utils79 = require("@typescript-eslint/utils");
 var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
   summary: "Require Next.js middleware and proxy matcher configuration to contain only build-time literals.",
   rationale: "Next.js must statically analyze matcher values at build time; computed values are ignored.",
@@ -15313,34 +15469,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === import_utils78.AST_NODE_TYPES.TSAsExpression || node.type === import_utils78.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils78.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils78.AST_NODE_TYPES.TSTypeAssertion) {
+  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === import_utils78.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils79.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils78.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils79.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils78.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils79.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils78.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils79.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils78.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils79.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils78.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils78.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils79.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils79.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName4(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils78.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils79.AST_NODE_TYPES.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -15363,19 +15519,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils78.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils79.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils78.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils79.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== import_utils78.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils79.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils78.AST_NODE_TYPES.Property || propertyName4(property) !== "matcher" || property.value.type === import_utils78.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils79.AST_NODE_TYPES.Property || propertyName4(property) !== "matcher" || property.value.type === import_utils79.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -15389,7 +15545,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils79 = require("@typescript-eslint/utils");
+var import_utils80 = require("@typescript-eslint/utils");
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "react-hook-form useForm call without defaultValues",
   rationale: "Without an explicit initial value, fields can change from uncontrolled to controlled as data arrives, reset behavior becomes ambiguous, and the form's initial shape no longer documents the values users can edit.",
@@ -15443,13 +15599,13 @@ var require_use_form_default_values_default = createRule({
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "useForm") continue;
-          const variable = import_utils79.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = import_utils80.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
           if (variable) importedHooks.add(variable);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== "Identifier") return;
-        const variable = import_utils79.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = import_utils80.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
         const options = node.arguments[0];
         if (!variable || !importedHooks.has(variable) || options !== void 0 && options.type !== "ObjectExpression" || hasDefaultValues(options)) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -15459,7 +15615,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils80 = require("@typescript-eslint/utils");
+var import_utils81 = require("@typescript-eslint/utils");
 var ACTION_MODULE_RE = /(?:^|\/)app\/.*\/(?:actions|[^/]+-actions)\.[cm]?[jt]s$/u;
 var REQUIRE_USE_SERVER_IN_ACTIONS_FILE_DOCUMENTATION = {
   summary: "route action module missing the use server directive",
@@ -15525,7 +15681,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils81 = require("@typescript-eslint/utils");
+var import_utils82 = require("@typescript-eslint/utils");
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
   rationale: "FormData values are untrusted strings or files and need runtime validation before use.",
@@ -15550,14 +15706,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils81.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils82.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils81.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils82.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils81.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils82.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -15566,12 +15722,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils81.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils82.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils81.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils82.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils81.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils81.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -15592,7 +15748,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils81.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils82.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -15602,16 +15758,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils81.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils82.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils81.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils81.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils81.AST_NODE_TYPES.Literal || init?.type === import_utils81.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils81.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils82.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils82.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils82.AST_NODE_TYPES.Literal || init?.type === import_utils82.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils82.AST_NODE_TYPES.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils81.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils82.AST_NODE_TYPES.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== import_utils81.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils81.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils82.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -15620,14 +15776,14 @@ var require_zod_form_validation_default = createRule({
       return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
     };
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils81.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils82.AST_NODE_TYPES.Identifier) return false;
       const conventionalName = /formdata/i.test(node.name);
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils81.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils82.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -15638,8 +15794,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils81.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils81.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils82.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -15655,16 +15811,16 @@ var require_zod_form_validation_default = createRule({
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils81.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils81.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils82.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === import_utils81.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils81.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils81.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils81.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils82.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils82.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils82.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils82.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils81.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils81.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils82.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils82.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -15673,7 +15829,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils81.AST_NODE_TYPES.BlockStatement || parent.type === import_utils81.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils82.AST_NODE_TYPES.BlockStatement || parent.type === import_utils82.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -15682,12 +15838,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === import_utils81.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils81.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils81.AST_NODE_TYPES.LogicalExpression || current.type === import_utils81.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils82.AST_NODE_TYPES.LogicalExpression || current.type === import_utils82.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -15697,7 +15853,7 @@ var require_zod_form_validation_default = createRule({
     const isAwaitedBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils81.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils82.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -15710,7 +15866,7 @@ var require_zod_form_validation_default = createRule({
       if (declarationStatement === null || validationStatement === null || declarationStatement.parent !== validationStatement.parent || validationStatement.range[0] <= declarationStatement.range[1] || hasConditionalAncestorBeforeStatement(parse2, validationStatement)) {
         return null;
       }
-      if (validationStatement.type !== import_utils81.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils81.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils82.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils82.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -15722,16 +15878,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils81.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils82.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils81.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils82.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils81.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils81.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils81.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils82.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils82.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -15742,23 +15898,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils81.AST_NODE_TYPES.ReturnStatement || node.type === import_utils81.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils82.AST_NODE_TYPES.ReturnStatement || node.type === import_utils82.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils81.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils82.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
       const last = node.body.at(-1);
       return last !== void 0 && blockTerminates(last);
     };
     const narrowingIf = (identifier) => {
       const comparison = identifier.parent;
-      if (comparison?.type !== import_utils81.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils81.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils82.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils82.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils81.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils82.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils81.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils82.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -15778,7 +15934,7 @@ var require_zod_form_validation_default = createRule({
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
       const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
-        (identifier) => identifier.type === import_utils81.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils82.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -15804,7 +15960,7 @@ var require_zod_form_validation_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils81.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils81.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils81.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils81.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils82.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils82.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils82.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils82.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -15825,7 +15981,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils82 = require("@typescript-eslint/utils");
+var import_utils83 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Require embedded inserts in explicitly replayable callables to carry conflict handling.",
   rationale: "A callable named as an enqueue, seed, migration, schedule, ensure, or upsert promises replay safety.",
@@ -15889,7 +16045,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils83 = require("@typescript-eslint/utils");
+var import_utils84 = require("@typescript-eslint/utils");
 var STEPDOWN_DOCUMENTATION = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -15909,7 +16065,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils83.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils83.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils84.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true, makeFix) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -16006,8 +16162,8 @@ function moduleScope(context, program) {
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
     program.body.flatMap((statement) => {
-      const node = statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils83.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils84.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -16031,7 +16187,7 @@ function moduleScope(context, program) {
       const nearestFunction2 = [...ancestors].reverse().find(isFunction);
       const parent = identifier.parent;
       const callerDefinition = nearestFunction2 === void 0 ? void 0 : byFunction.get(nearestFunction2);
-      if (callerDefinition === void 0 || parent.type !== import_utils83.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== import_utils84.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -16046,38 +16202,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils83.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils83.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils84.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils83.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils84.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils83.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils84.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils83.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils83.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils83.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils84.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils83.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === import_utils84.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -16090,21 +16246,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils83.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (node.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === import_utils84.AST_NODE_TYPES.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils83.AST_NODE_TYPES.Identifier ? import_utils83.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === import_utils84.AST_NODE_TYPES.Identifier ? import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils83.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils83.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils83.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== import_utils84.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
+  if (node.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils83.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils83.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk2(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -16120,7 +16276,7 @@ function walk2(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils83.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -16128,8 +16284,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== import_utils83.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils83.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils84.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils84.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -16138,7 +16294,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -16147,11 +16303,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = import_utils83.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === import_utils83.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils83.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils83.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils83.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils84.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils84.AST_NODE_TYPES.Identifier) {
+    const outer = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -16167,27 +16323,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils83.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils83.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils83.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils83.AST_NODE_TYPES.ThisExpression;
+      while (current?.type === import_utils84.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+      return current?.type === import_utils84.AST_NODE_TYPES.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils83.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils83.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils83.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils83.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils83.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils83.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== import_utils84.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils84.AST_NODE_TYPES.AssignmentPattern) return;
+      if (current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils84.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
+      const value = current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === import_utils83.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils84.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils83.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils84.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === import_utils83.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === import_utils84.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== import_utils83.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils83.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== import_utils84.AST_NODE_TYPES.Identifier) return;
+      const variable = import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -16200,16 +16356,16 @@ function classScope(context, node, computedReferenceNames) {
       walk2(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils83.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils83.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
+      if (current.type === import_utils84.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils84.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === import_utils83.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils84.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === import_utils83.AST_NODE_TYPES.Property && property.key.type === import_utils83.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === import_utils84.AST_NODE_TYPES.Property && property.key.type === import_utils84.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== import_utils83.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -16217,12 +16373,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils83.AST_NODE_TYPES.Identifier ? import_utils83.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === import_utils84.AST_NODE_TYPES.Identifier ? import_utils84.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils83.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils84.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -16242,9 +16398,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils83.AST_NODE_TYPES.MethodDefinition || member.type === import_utils83.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils84.AST_NODE_TYPES.MethodDefinition || member.type === import_utils84.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk2(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils83.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -16296,12 +16452,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils83.AST_NODE_TYPES.StaticBlock:
+    case import_utils84.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils83.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils83.AST_NODE_TYPES.AccessorProperty:
+    case import_utils84.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils84.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils83.AST_NODE_TYPES.MethodDefinition:
+    case import_utils84.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -16334,7 +16490,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk2(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils83.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils83.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils84.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -16343,7 +16499,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-var import_utils84 = require("@typescript-eslint/utils");
+var import_utils85 = require("@typescript-eslint/utils");
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
@@ -16412,20 +16568,20 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap5(node) {
-  if (node.type === import_utils84.AST_NODE_TYPES.AwaitExpression) return unwrap5(node.argument);
-  if (node.type === import_utils84.AST_NODE_TYPES.ChainExpression) return unwrap5(node.expression);
-  if (node.type === import_utils84.AST_NODE_TYPES.TSAsExpression || node.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) return unwrap5(node.expression);
+  if (node.type === import_utils85.AST_NODE_TYPES.AwaitExpression) return unwrap5(node.argument);
+  if (node.type === import_utils85.AST_NODE_TYPES.ChainExpression) return unwrap5(node.expression);
+  if (node.type === import_utils85.AST_NODE_TYPES.TSAsExpression || node.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) return unwrap5(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap5(node);
-  if (current.type === import_utils84.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils84.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === import_utils85.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils85.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
   return null;
 }
 function importSource(node) {
@@ -16433,7 +16589,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap5(node);
-  if (current.type !== import_utils84.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils84.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils84.AST_NODE_TYPES.SpreadElement) return null;
+  if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils85.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils85.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -16473,38 +16629,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap5(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils84.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
-        if (current.type === import_utils84.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
+        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
           return sourcePath(current.left) || sourcePath(current.right);
         }
-        if (current.type === import_utils84.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
-        if (current.type === import_utils84.AST_NODE_TYPES.CallExpression || current.type === import_utils84.AST_NODE_TYPES.NewExpression) {
-          return current.arguments.some((argument) => argument.type !== import_utils84.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
+        if (current.type === import_utils85.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
+        if (current.type === import_utils85.AST_NODE_TYPES.CallExpression || current.type === import_utils85.AST_NODE_TYPES.NewExpression) {
+          return current.arguments.some((argument) => argument.type !== import_utils85.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
         }
-        if (current.type === import_utils84.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
+        if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap5(node);
-        if (current.type !== import_utils84.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap5(current.callee);
-        if (callee.type === import_utils84.AST_NODE_TYPES.Identifier) {
+        if (callee.type === import_utils85.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee.name) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return false;
+        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap5(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils84.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils85.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap5(node);
-        if (current.type === import_utils84.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
+        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils84.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils84.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils84.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap5(current.callee);
-        if (callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
@@ -16512,38 +16668,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap5(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils84.AST_NODE_TYPES.BinaryExpression || current.type === import_utils84.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils84.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils84.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils85.AST_NODE_TYPES.BinaryExpression || current.type === import_utils85.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils85.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils85.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap5(current.callee);
-        if (callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(callee.object);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils84.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap5(node.callee);
-        if (callee.type === import_utils84.AST_NODE_TYPES.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils84.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === import_utils85.AST_NODE_TYPES.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap5(callee.object);
-        while (receiver.type === import_utils84.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap5(receiver.object);
-        if (receiver.type === import_utils84.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils84.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === import_utils85.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap5(receiver.object);
+        if (receiver.type === import_utils85.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils85.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils84.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils84.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils84.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils85.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils85.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const rawRegexExtractionOrigins = (node) => {
         const callee = unwrap5(node.callee);
-        if (callee.type !== import_utils84.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
         const argument = node.arguments[0];
-        if (argument?.type !== import_utils84.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
+        if (argument?.type !== import_utils85.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
         return rawOrigins(callee.object);
       };
       const declare = (name2, state) => {
@@ -16564,15 +16720,15 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap5(node);
-        return current.type === import_utils84.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils84.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        return current.type === import_utils85.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils85.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const declaredNames2 = (node) => {
         const current = unwrap5(node);
-        if (current.type === import_utils84.AST_NODE_TYPES.Identifier) return [current.name];
-        if (current.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
-        if (current.type === import_utils84.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
-        if (current.type === import_utils84.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
-        if (current.type === import_utils84.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils84.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
+        if (current.type === import_utils85.AST_NODE_TYPES.Identifier) return [current.name];
+        if (current.type === import_utils85.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
+        if (current.type === import_utils85.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
+        if (current.type === import_utils85.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
+        if (current.type === import_utils85.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils85.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
         return [];
       };
       const enterFunction = (node) => {
@@ -16587,8 +16743,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           const source = importSource(node);
           if (source === null || !FS_MODULES.has(source)) return;
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils84.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils84.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils85.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils85.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local.name, { fsReader: true });
             } else {
               declare(specifier.local.name, { fsObject: true });
@@ -16600,29 +16756,29 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         VariableDeclarator(node) {
           if (node.init === null) return;
           const required = requireSource(node.init);
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils84.AST_NODE_TYPES.Identifier) {
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils85.AST_NODE_TYPES.Identifier) {
             declare(node.id.name, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils84.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils85.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== import_utils84.AST_NODE_TYPES.Property || property.value.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
-              const key = property.key.type === import_utils84.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils84.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+              if (property.type !== import_utils85.AST_NODE_TYPES.Property || property.value.type !== import_utils85.AST_NODE_TYPES.Identifier) continue;
+              const key = property.key.type === import_utils85.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils85.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value.name, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== import_utils84.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier) return;
           declare(node.id.name, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils84.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
+          if (node.left.type === import_utils85.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
         },
         ForOfStatement(node) {
           const right = unwrap5(node.right);
-          const collection = right.type === import_utils84.AST_NODE_TYPES.Identifier && visible("collections", right.name);
-          const left = node.left.type === import_utils84.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils84.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
+          const collection = right.type === import_utils85.AST_NODE_TYPES.Identifier && visible("collections", right.name);
+          const left = node.left.type === import_utils85.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils85.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
         },
         CallExpression(node) {
           const origins = /* @__PURE__ */ new Set([
@@ -16682,7 +16838,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils85 = require("@typescript-eslint/utils");
+var import_utils86 = require("@typescript-eslint/utils");
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
   rationale: "A reusable Zod schema is a runtime type contract. PascalCase mirrors that role; SCREAMING_SNAKE_CASE should remain reserved for scalar values and lookup tables.",
@@ -16814,18 +16970,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils85.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils86.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils85.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils86.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils86.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils86.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -16836,13 +16992,13 @@ var chainMemberNames = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
-      if (current.computed || current.property.type !== import_utils85.AST_NODE_TYPES.Identifier) return [];
+    if (current.type === import_utils86.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils86.AST_NODE_TYPES.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils86.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -16853,16 +17009,16 @@ var chainMemberNames = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+  while (current.type === import_utils86.AST_NODE_TYPES.TSAsExpression || current.type === import_utils86.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils86.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils86.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils85.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils85.AST_NODE_TYPES.Program || owner.type === import_utils85.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils85.AST_NODE_TYPES.Program;
+  return owner.type === import_utils86.AST_NODE_TYPES.Program || owner.type === import_utils86.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils86.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -16882,7 +17038,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return import_utils85.ASTUtils.findVariable(
+      return import_utils86.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -16903,8 +17059,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === import_utils85.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils85.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) {
+      if (init.type === import_utils86.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils86.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils86.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -16924,7 +17080,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils85.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils85.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils85.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils85.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils86.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils86.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils86.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -16933,7 +17089,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
         if (!isModuleDeclarator(node)) return;
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils86.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -17093,6 +17249,7 @@ var RULES = {
   "prefer-module-level-schema": prefer_module_level_schema_default,
   "prefer-native-random-uuid": prefer_native_random_uuid_default,
   "prefer-non-nullable-collection": prefer_non_nullable_collection_default,
+  "prefer-nullish-filter-predicate": prefer_nullish_filter_predicate_default,
   "prefer-await-in-async-return": prefer_await_in_async_return_default,
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
   "prefer-semantic-colors": prefer_semantic_colors_default,
@@ -17112,7 +17269,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.13.3"
+  version: "15.14.0"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",
@@ -17174,6 +17331,7 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
   "@sarj/prefer-non-nullable-collection": "error",
+  "@sarj/prefer-nullish-filter-predicate": "error",
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
@@ -17252,6 +17410,7 @@ var STRICT_RULES = {
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
   "@sarj/prefer-non-nullable-collection": "error",
+  "@sarj/prefer-nullish-filter-predicate": "error",
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],