@sarj/eslint-plugin 18.0.3 → 18.0.5

package/dist/index.cjs

@@ -859,11 +859,11 @@ function sameShape(checker, input, output, location) {
 }
 
 // src/rules/prefer-server-data-preparation.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var import_typescript3 = __toESM(require("typescript"), 1);
+var import_utils10 = require("@typescript-eslint/utils");
+var import_typescript7 = __toESM(require("typescript"), 1);
 
 // src/rules/_react-prop-bindings.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils9 = require("@typescript-eslint/utils");
 
 // src/rules/_import-specifier-name.ts
 var import_utils6 = require("@typescript-eslint/utils");
@@ -871,6 +871,206 @@ function importSpecifierName(node) {
   return node.imported.type === import_utils6.AST_NODE_TYPES.Identifier ? node.imported.name : node.imported.value;
 }
 
+// src/rules/_private-scalar-consumer.ts
+var import_utils8 = require("@typescript-eslint/utils");
+var import_typescript6 = __toESM(require("typescript"), 1);
+
+// src/rules/_scalar-parameter-view.ts
+var import_typescript5 = __toESM(require("typescript"), 1);
+
+// src/rules/_checked-native-source.ts
+var import_typescript3 = __toESM(require("typescript"), 1);
+var CHECKED = /* @__PURE__ */ new WeakMap();
+var SINGLE_LINE_DIRECTIVE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/u;
+var MULTI_LINE_DIRECTIVE = /^[/*]*\s*@(?:ts-expect-error|ts-ignore)/u;
+var SINGLE_LINE_PRAGMA = /^\/\/\/?\s*@([^\s:]+)(?:(?:[^\S\r\n]|:).*)?$/mu;
+function currentNativeSource(sourceCode, services) {
+  const source = services.esTreeNodeToTSNodeMap.get(sourceCode.ast);
+  return import_typescript3.default.isSourceFile(source) && services.program.getSourceFile(source.fileName) === source && source.text === sourceCode.text ? source : null;
+}
+function checkedNativeSource(program, source) {
+  let files = CHECKED.get(program);
+  if (!files) {
+    files = /* @__PURE__ */ new WeakMap();
+    CHECKED.set(program, files);
+  }
+  const known2 = files.get(source);
+  if (known2 !== void 0) return known2;
+  const available = !program.getCompilerOptions().noCheck && !source.isDeclarationFile && (source.flags & (import_typescript3.default.NodeFlags.JavaScriptFile | import_typescript3.default.NodeFlags.JsonFile)) === 0 && !program.getProjectReferences()?.length && !program.getResolvedProjectReferences()?.length && program.getSourceFile(source.fileName) === source && !program.isSourceFileFromExternalLibrary(source) && !program.isSourceFileDefaultLibrary(source) && !program.getSyntacticDiagnostics(source).some((diagnostic) => diagnostic.category === import_typescript3.default.DiagnosticCategory.Error && diagnostic.file === source) && !checkingSuppressed(source) && !program.getSemanticDiagnostics(source).some((diagnostic) => diagnostic.category === import_typescript3.default.DiagnosticCategory.Error && diagnostic.file === source);
+  files.set(source, available);
+  return available;
+}
+function checkingSuppressed(source) {
+  if (!/@ts-/iu.test(source.text)) return false;
+  if (import_typescript3.default.getLeadingCommentRanges(source.text, 0)?.some((comment) => comment.kind === import_typescript3.default.SyntaxKind.SingleLineCommentTrivia && SINGLE_LINE_PRAGMA.exec(source.text.slice(comment.pos, comment.end))?.[1]?.toLowerCase() === "ts-nocheck")) return true;
+  const pending = [source];
+  while (pending.length) {
+    const node = pending.pop();
+    if (!node || import_typescript3.default.isJsxText(node) || import_typescript3.default.isJSDoc(node) || (node.flags & import_typescript3.default.NodeFlags.JSDoc) !== 0) continue;
+    if (!import_typescript3.default.isToken(node)) {
+      for (const child of node.getChildren(source)) pending.push(child);
+      continue;
+    }
+    if (tokenTriviaSuppressesChecking(node, source)) return true;
+  }
+  return false;
+}
+function tokenTriviaSuppressesChecking(node, source) {
+  const start = node.getStart(source);
+  for (const comment of [...import_typescript3.default.getLeadingCommentRanges(source.text, node.pos) ?? [], ...import_typescript3.default.getTrailingCommentRanges(source.text, node.pos) ?? []]) {
+    if (comment.pos < node.pos || comment.end > start) continue;
+    if (commentSuppressesChecking(source.text.slice(comment.pos, comment.end), comment.kind)) return true;
+  }
+  return false;
+}
+function commentSuppressesChecking(text, kind) {
+  if (kind === import_typescript3.default.SyntaxKind.SingleLineCommentTrivia) return SINGLE_LINE_DIRECTIVE.test(text);
+  let lastLine = text.length;
+  while (lastLine > 0 && !import_typescript3.default.isLineBreak(text.charCodeAt(lastLine - 1))) lastLine--;
+  return MULTI_LINE_DIRECTIVE.test(text.slice(lastLine).trimStart());
+}
+
+// src/rules/_native-const-value.ts
+var import_typescript4 = __toESM(require("typescript"), 1);
+function constInitializer(declaration) {
+  if (!declaration || !import_typescript4.default.isVariableDeclaration(declaration) || !import_typescript4.default.isVariableDeclarationList(declaration.parent) || (declaration.parent.flags & import_typescript4.default.NodeFlags.BlockScoped) !== import_typescript4.default.NodeFlags.Const) return void 0;
+  let initializer = declaration.initializer;
+  while (initializer && import_typescript4.default.isParenthesizedExpression(initializer)) initializer = initializer.expression;
+  return initializer;
+}
+function unassertedValue(node) {
+  let value = node;
+  while (import_typescript4.default.isParenthesizedExpression(value) || import_typescript4.default.isAsExpression(value) || import_typescript4.default.isTypeAssertionExpression(value) || import_typescript4.default.isNonNullExpression(value) || import_typescript4.default.isSatisfiesExpression(value)) value = value.expression;
+  return value;
+}
+
+// src/rules/_scalar-parameter-view.ts
+var SCALAR_OPERATORS = /* @__PURE__ */ new Set([
+  import_typescript5.default.SyntaxKind.PlusToken,
+  import_typescript5.default.SyntaxKind.MinusToken,
+  import_typescript5.default.SyntaxKind.AsteriskToken,
+  import_typescript5.default.SyntaxKind.SlashToken,
+  import_typescript5.default.SyntaxKind.PercentToken,
+  import_typescript5.default.SyntaxKind.AsteriskAsteriskToken,
+  import_typescript5.default.SyntaxKind.LessThanToken,
+  import_typescript5.default.SyntaxKind.LessThanEqualsToken,
+  import_typescript5.default.SyntaxKind.GreaterThanToken,
+  import_typescript5.default.SyntaxKind.GreaterThanEqualsToken,
+  import_typescript5.default.SyntaxKind.EqualsEqualsEqualsToken,
+  import_typescript5.default.SyntaxKind.ExclamationEqualsEqualsToken,
+  import_typescript5.default.SyntaxKind.EqualsEqualsToken,
+  import_typescript5.default.SyntaxKind.ExclamationEqualsToken,
+  import_typescript5.default.SyntaxKind.AmpersandAmpersandToken,
+  import_typescript5.default.SyntaxKind.BarBarToken,
+  import_typescript5.default.SyntaxKind.QuestionQuestionToken
+]);
+var SCALAR_PREFIXES = /* @__PURE__ */ new Set([import_typescript5.default.SyntaxKind.PlusToken, import_typescript5.default.SyntaxKind.MinusToken, import_typescript5.default.SyntaxKind.ExclamationToken, import_typescript5.default.SyntaxKind.TildeToken]);
+var RETURNED_OPERANDS = /* @__PURE__ */ new Set([import_typescript5.default.SyntaxKind.AmpersandAmpersandToken, import_typescript5.default.SyntaxKind.BarBarToken, import_typescript5.default.SyntaxKind.QuestionQuestionToken]);
+function scalarParameterView(parameter, body3, checker) {
+  return parameterReads(parameter, body3, checker, true);
+}
+function scalarParameterReads(parameter, body3, checker, callProgram, auxiliaries) {
+  return parameterReads(parameter, body3, checker, false, callProgram, auxiliaries);
+}
+function parameterReads(parameter, body3, checker, jsx, callProgram, auxiliaries) {
+  if (parameter.dotDotDotToken || parameter.initializer || import_typescript5.default.isArrayBindingPattern(parameter.name)) return null;
+  const root = import_typescript5.default.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
+  if (import_typescript5.default.isIdentifier(parameter.name) && !root) return null;
+  const reads = /* @__PURE__ */ new Set();
+  const aliases = parameterAliases(parameter.name, checker, reads);
+  if (!aliases) return null;
+  const expression = returnedExpression(body3);
+  const view = { checker, props: checker.getTypeAtLocation(parameter), root, aliases, reads, callProgram, auxiliaries };
+  return expression && scalarView(expression, view, jsx) ? reads : null;
+}
+function scalarType(type, allowUndefined = true) {
+  if (type.isUnion()) return type.types.every((part) => scalarType(part, allowUndefined));
+  const flags = import_typescript5.default.TypeFlags.StringLike | import_typescript5.default.TypeFlags.NumberLike | import_typescript5.default.TypeFlags.BooleanLike | import_typescript5.default.TypeFlags.BigIntLike | import_typescript5.default.TypeFlags.Null;
+  return (type.flags & (allowUndefined ? flags | import_typescript5.default.TypeFlags.Undefined : flags)) !== 0;
+}
+function parameterAliases(name, checker, reads) {
+  const aliases = /* @__PURE__ */ new Map();
+  if (import_typescript5.default.isIdentifier(name)) return aliases;
+  for (const element of name.elements) {
+    const key = element.propertyName ?? element.name;
+    if (element.dotDotDotToken || element.initializer || !import_typescript5.default.isIdentifier(element.name) || !import_typescript5.default.isIdentifier(key) && !import_typescript5.default.isStringLiteralLike(key) && !import_typescript5.default.isNumericLiteral(key)) return null;
+    const binding3 = checker.getSymbolAtLocation(element.name);
+    if (!binding3) return null;
+    reads.add(key.text);
+    aliases.set(binding3, key.text);
+  }
+  return aliases;
+}
+function returnedExpression(body3) {
+  if (!import_typescript5.default.isBlock(body3)) return body3;
+  const statement = body3.statements.length === 1 ? body3.statements[0] : void 0;
+  return statement && import_typescript5.default.isReturnStatement(statement) ? statement.expression : void 0;
+}
+function scalarView(node, view, jsx = false) {
+  if (scalarLiteral(node)) return true;
+  if (import_typescript5.default.isCallExpression(node)) return !jsx && scalarCall(node, view);
+  if (import_typescript5.default.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view, jsx));
+  if (import_typescript5.default.isIdentifier(node)) {
+    const binding3 = view.checker.getSymbolAtLocation(node);
+    if (binding3 && view.auxiliaries?.has(binding3)) return scalarType(view.checker.getTypeAtLocation(node));
+    const key = binding3 && view.aliases.get(binding3);
+    return key !== void 0 && readField(node, key, view);
+  }
+  if (import_typescript5.default.isPropertyAccessExpression(node) || import_typescript5.default.isElementAccessExpression(node)) return memberRead(node, view);
+  return scalarOperation(node, view, jsx);
+}
+function scalarOperation(node, view, jsx) {
+  if (import_typescript5.default.isParenthesizedExpression(node) || import_typescript5.default.isNonNullExpression(node)) return scalarView(node.expression, view, jsx);
+  if (import_typescript5.default.isTypeOfExpression(node)) return scalarView(node.expression, view);
+  if (import_typescript5.default.isConditionalExpression(node)) return scalarView(node.condition, view) && scalarView(node.whenTrue, view, jsx) && scalarView(node.whenFalse, view, jsx);
+  if (import_typescript5.default.isBinaryExpression(node)) return binaryView(node, view, jsx);
+  if (import_typescript5.default.isPrefixUnaryExpression(node)) return SCALAR_PREFIXES.has(node.operator) && scalarView(node.operand, view);
+  if (import_typescript5.default.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view));
+  return jsx && jsxView(node, view);
+}
+function scalarCall(node, view) {
+  if (!view.callProgram || node.questionDotToken || node.typeArguments?.length || !import_typescript5.default.isIdentifier(node.expression) || !node.arguments.length || node.arguments.some(import_typescript5.default.isSpreadElement)) return false;
+  const declarations = view.checker.getSymbolAtLocation(node.expression)?.declarations;
+  const declaration = declarations?.length === 1 ? declarations[0] : void 0;
+  const helper = declaration && localHelper(declaration);
+  if (!helper || helper.getSourceFile() !== node.getSourceFile() || helper.typeParameters?.length || !helper.type || !node.arguments.every((argument) => scalarView(argument, view))) return false;
+  if (!checkedNativeSource(view.callProgram, node.getSourceFile())) return false;
+  const signature = view.checker.getResolvedSignature(node);
+  return signature?.declaration === helper && !view.checker.getTypePredicateOfSignature(signature) && scalarType(view.checker.getTypeAtLocation(node));
+}
+function localHelper(node) {
+  if (import_typescript5.default.isFunctionDeclaration(node)) return node.body && import_typescript5.default.isSourceFile(node.parent) ? node : void 0;
+  if (!import_typescript5.default.isVariableDeclaration(node) || node.type || !node.initializer || constInitializer(node) !== node.initializer || !import_typescript5.default.isArrowFunction(node.initializer) || !import_typescript5.default.isVariableStatement(node.parent.parent) || !import_typescript5.default.isSourceFile(node.parent.parent.parent)) return void 0;
+  return node.initializer;
+}
+function binaryView(node, view, jsx) {
+  const returned2 = jsx && RETURNED_OPERANDS.has(node.operatorToken.kind);
+  return SCALAR_OPERATORS.has(node.operatorToken.kind) && scalarView(node.left, view, returned2) && scalarView(node.right, view, returned2);
+}
+function scalarLiteral(node) {
+  return import_typescript5.default.isStringLiteralLike(node) || import_typescript5.default.isNumericLiteral(node) || import_typescript5.default.isBigIntLiteral(node) || import_typescript5.default.isJsxText(node) || node.kind === import_typescript5.default.SyntaxKind.TrueKeyword || node.kind === import_typescript5.default.SyntaxKind.FalseKeyword || node.kind === import_typescript5.default.SyntaxKind.NullKeyword;
+}
+function memberRead(node, view) {
+  if (!view.root || !import_typescript5.default.isIdentifier(node.expression) || view.checker.getSymbolAtLocation(node.expression) !== view.root) return false;
+  const key = import_typescript5.default.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && (import_typescript5.default.isStringLiteralLike(node.argumentExpression) || import_typescript5.default.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
+  return key !== void 0 && readField(node, key, view);
+}
+function readField(node, key, view) {
+  if (!view.checker.getPropertyOfType(view.props, key) || !scalarType(view.checker.getTypeAtLocation(node))) return false;
+  view.reads.add(key);
+  return true;
+}
+function jsxView(node, view) {
+  if (import_typescript5.default.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view, true));
+  if (import_typescript5.default.isJsxElement(node)) return jsxView(node.openingElement, view) && node.children.every((child) => scalarView(child, view, true));
+  if (!import_typescript5.default.isJsxOpeningElement(node) && !import_typescript5.default.isJsxSelfClosingElement(node)) return false;
+  if (!import_typescript5.default.isIdentifier(node.tagName) || !/^[a-z][A-Za-z0-9]*$/u.test(node.tagName.text)) return false;
+  return node.attributes.properties.every((attribute) => intrinsicAttribute(attribute, view));
+}
+function intrinsicAttribute(attribute, view) {
+  return import_typescript5.default.isJsxAttribute(attribute) && import_typescript5.default.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view));
+}
+
 // src/rules/_stable-value-binding.ts
 var import_utils7 = require("@typescript-eslint/utils");
 function typeOnlyReference(reference) {
@@ -891,8 +1091,107 @@ function stableValueBinding(variable, acceptRead) {
   });
 }
 
+// src/rules/_private-scalar-consumer.ts
+function directEval(node) {
+  let callee = unwrapExpression(node.callee);
+  while (callee.type === import_utils8.AST_NODE_TYPES.TSInstantiationExpression) callee = unwrapExpression(callee.expression);
+  return callee.type === import_utils8.AST_NODE_TYPES.Identifier && callee.name === "eval";
+}
+function primitiveKeyword(node) {
+  return node !== void 0 && (node.kind === import_typescript6.default.SyntaxKind.StringKeyword || node.kind === import_typescript6.default.SyntaxKind.NumberKeyword || node.kind === import_typescript6.default.SyntaxKind.BooleanKeyword || node.kind === import_typescript6.default.SyntaxKind.BigIntKeyword);
+}
+function nullishPrimitiveUnion(node) {
+  return node !== void 0 && import_typescript6.default.isUnionTypeNode(node) && node.types.length === 2 && node.types.some(primitiveKeyword) && node.types.some((part) => part.kind === import_typescript6.default.SyntaxKind.UndefinedKeyword || import_typescript6.default.isLiteralTypeNode(part) && part.literal.kind === import_typescript6.default.SyntaxKind.NullKeyword);
+}
+function consumerAnnotation(node, auxiliaryScalars = false) {
+  if (node.params.length !== 1) {
+    if (!auxiliaryScalars) return void 0;
+    let annotation;
+    for (const parameter2 of node.params) {
+      if (parameter2.type !== import_utils8.AST_NODE_TYPES.Identifier && parameter2.type !== import_utils8.AST_NODE_TYPES.ObjectPattern) continue;
+      const current = parameter2.typeAnnotation?.typeAnnotation;
+      if (current?.type !== import_utils8.AST_NODE_TYPES.TSTypeLiteral) continue;
+      if (annotation) return void 0;
+      annotation = current;
+    }
+    return annotation;
+  }
+  const parameter = node.params[0];
+  return parameter?.type === import_utils8.AST_NODE_TYPES.Identifier || parameter?.type === import_utils8.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
+}
+function exportedSymbols(source, checker) {
+  const symbol = checker.getSymbolAtLocation(source);
+  return new Set(symbol ? checker.getExportsOfModule(symbol).map((entry) => (entry.flags & import_typescript6.default.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(entry) : entry) : []);
+}
+function privateScalarConsumer(node, sourceCode, services, exports2, options = {}) {
+  const native = services.esTreeNodeToTSNodeMap.get(node);
+  if (!import_typescript6.default.isFunctionDeclaration(native) && !import_typescript6.default.isArrowFunction(native) || !native.body) return null;
+  let parameter = native.parameters[0];
+  if (native.parameters.length !== 1) {
+    const annotation = consumerAnnotation(node, options.auxiliaryScalars);
+    const selected = annotation && services.esTreeNodeToTSNodeMap.get(annotation);
+    parameter = native.parameters.find((entry) => entry.type === selected);
+  }
+  if (!parameter || !independentSignature(native, parameter, options.auxiliaryScalars === true)) return null;
+  const checker = services.program.getTypeChecker();
+  if (!import_typescript6.default.isExternalModule(native.getSourceFile()) || !services.program.getCompilerOptions().strict) return null;
+  if (!privateDirectCallable(node, native, sourceCode, checker, exports2)) return null;
+  const signature = checker.getSignatureFromDeclaration(native);
+  if (!signature || signature.typeParameters?.length || checker.getTypePredicateOfSignature(signature)) return null;
+  const expression = returnedExpression(native.body);
+  if (!expression || !checker.isTypeAssignableTo(checker.getTypeAtLocation(expression), checker.getReturnTypeOfSignature(signature))) return null;
+  const auxiliaries = native.parameters.length > 1 ? auxiliaryBindings(native, parameter, checker) : void 0;
+  if (auxiliaries === null) return null;
+  const reads = scalarParameterReads(parameter, native.body, checker, options.scalarCalls ? services.program : void 0, auxiliaries);
+  return reads?.size ? { parameter, reads } : null;
+}
+function privateDirectCallable(node, native, sourceCode, checker, exports2) {
+  const binding3 = callableBinding(node, sourceCode);
+  if (!binding3 || binding3.defs.length !== 1) return false;
+  const name = import_typescript6.default.isFunctionDeclaration(native) ? native.name : import_typescript6.default.isVariableDeclaration(native.parent) ? native.parent.name : void 0;
+  const symbol = name && checker.getSymbolAtLocation(name);
+  return symbol !== void 0 && symbol.declarations?.length === 1 && !exports2.has(symbol) && directCalls(binding3, native.parameters.length);
+}
+function independentSignature(native, selected, auxiliaryScalars) {
+  if (!auxiliaryScalars && native.parameters.length !== 1 || native.typeParameters?.length || native.asteriskToken || native.modifiers?.length || !primitiveKeyword(native.type)) return false;
+  return native.parameters.every((parameter) => parameter.type !== void 0 && !parameter.modifiers?.length && !parameter.questionToken && !parameter.initializer && !parameter.dotDotDotToken && (!import_typescript6.default.isIdentifier(parameter.name) || parameter.name.text !== "this") && (parameter === selected || import_typescript6.default.isIdentifier(parameter.name) && primitiveKeyword(parameter.type)));
+}
+function auxiliaryBindings(native, selected, checker) {
+  const bindings = /* @__PURE__ */ new Set();
+  for (const parameter of native.parameters) {
+    if (parameter === selected) continue;
+    const symbol = import_typescript6.default.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
+    if (!symbol || symbol.declarations?.length !== 1 || symbol.declarations[0] !== parameter || bindings.has(symbol)) return null;
+    bindings.add(symbol);
+  }
+  return bindings;
+}
+function callableBinding(node, sourceCode) {
+  if (node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.parent.type !== import_utils8.AST_NODE_TYPES.Program) return void 0;
+    return sourceCode.getDeclaredVariables(node).find((variable) => variable.defs.some((definition) => definition.type === "FunctionName" && definition.node === node));
+  }
+  const declaration = node.parent;
+  if (declaration.type !== import_utils8.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils8.AST_NODE_TYPES.Identifier || declaration.id.typeAnnotation || declaration.parent.kind !== "const" || declaration.parent.parent.type !== import_utils8.AST_NODE_TYPES.Program) return void 0;
+  return sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
+}
+function directCalls(binding3, arity) {
+  let calls = 0;
+  const stable2 = stableValueBinding(binding3, (reference) => {
+    const identifier = reference.identifier;
+    const call = identifier.parent;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils8.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== arity || !call.arguments.every((argument) => argument.type === import_utils8.AST_NODE_TYPES.Identifier)) return false;
+    calls += 1;
+    return true;
+  });
+  return stable2 && calls > 0;
+}
+
 // src/rules/_react-prop-bindings.ts
 var VIEWS = /* @__PURE__ */ new WeakMap();
+var DIRECT_EVAL = /* @__PURE__ */ new WeakMap();
+var REACT_IMPORTS = /* @__PURE__ */ new WeakMap();
+var PARAMETER_BINDINGS = /* @__PURE__ */ new WeakMap();
 function renderFunction(node) {
   let parent = node.parent;
   while (parent !== void 0 && parent !== null) {
@@ -909,13 +1208,27 @@ function renderFunction(node) {
   return null;
 }
 function firstParameterBindings(source, node) {
+  let functions = PARAMETER_BINDINGS.get(source);
+  if (functions === void 0) {
+    functions = /* @__PURE__ */ new WeakMap();
+    PARAMETER_BINDINGS.set(source, functions);
+  }
+  let bindings = functions.get(node);
+  if (bindings === void 0) {
+    bindings = collectParameterBindings(source, node);
+    functions.set(node, bindings);
+  }
+  return bindings;
+}
+function collectParameterBindings(source, node) {
+  if (hasDirectEval(source)) return /* @__PURE__ */ new Set();
   const parameter = node.params[0];
   const identifiers = [];
-  if (parameter?.type === import_utils8.AST_NODE_TYPES.Identifier)
+  if (parameter?.type === import_utils9.AST_NODE_TYPES.Identifier)
     identifiers.push(parameter);
-  if (parameter?.type === import_utils8.AST_NODE_TYPES.ObjectPattern) {
+  if (parameter?.type === import_utils9.AST_NODE_TYPES.ObjectPattern) {
     for (const property of parameter.properties) {
-      if (property.type === import_utils8.AST_NODE_TYPES.Property && !property.computed && property.value.type === import_utils8.AST_NODE_TYPES.Identifier)
+      if (property.type === import_utils9.AST_NODE_TYPES.Property && !property.computed && property.value.type === import_utils9.AST_NODE_TYPES.Identifier)
         identifiers.push(property.value);
     }
   }
@@ -927,17 +1240,34 @@ function firstParameterBindings(source, node) {
     )
   );
 }
+function hasDirectEval(source) {
+  let found = DIRECT_EVAL.get(source);
+  if (found !== void 0) return found;
+  found = source.scopeManager?.scopes.some(
+    (scope) => scope.references.some(({ identifier }) => {
+      if (identifier.type !== import_utils9.AST_NODE_TYPES.Identifier || identifier.name !== "eval")
+        return false;
+      let callee = outerExpression(identifier);
+      while (callee.parent?.type === import_utils9.AST_NODE_TYPES.TSInstantiationExpression && callee.parent.expression === callee)
+        callee = outerExpression(callee.parent);
+      const call = callee.parent;
+      return call?.type === import_utils9.AST_NODE_TYPES.CallExpression && call.callee === callee && !call.optional && directEval(call);
+    })
+  ) ?? true;
+  DIRECT_EVAL.set(source, found);
+  return found;
+}
 function parameterPath(source, node, bindings) {
   let current = unwrapExpression(node);
   for (let depth = 0; depth < 64; depth += 1) {
-    if (current.type === import_utils8.AST_NODE_TYPES.Identifier) {
-      const variable = import_utils8.ASTUtils.findVariable(
+    if (current.type === import_utils9.AST_NODE_TYPES.Identifier) {
+      const variable = import_utils9.ASTUtils.findVariable(
         source.getScope(current),
         current.name
       );
       return variable !== null && bindings.has(variable);
     }
-    if (current.type !== import_utils8.AST_NODE_TYPES.MemberExpression || current.optional || current.computed && (current.property.type !== import_utils8.AST_NODE_TYPES.Literal || typeof current.property.value !== "string"))
+    if (current.type !== import_utils9.AST_NODE_TYPES.MemberExpression || current.optional || current.computed && (current.property.type !== import_utils9.AST_NODE_TYPES.Literal || typeof current.property.value !== "string"))
       return false;
     current = unwrapExpression(current.object);
   }
@@ -947,25 +1277,30 @@ function reactHook(source, callee, hook) {
   callee = unwrapExpression(callee);
   let identifier;
   let namespace = false;
-  if (callee.type === import_utils8.AST_NODE_TYPES.Identifier) identifier = callee;
-  else if (callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils8.ASTUtils.getPropertyName(callee) === hook && callee.object.type === import_utils8.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils9.AST_NODE_TYPES.Identifier) identifier = callee;
+  else if (callee.type === import_utils9.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils9.ASTUtils.getPropertyName(callee) === hook && callee.object.type === import_utils9.AST_NODE_TYPES.Identifier) {
     identifier = callee.object;
     namespace = true;
   } else return false;
-  const variable = import_utils8.ASTUtils.findVariable(
+  const variable = import_utils9.ASTUtils.findVariable(
     source.getScope(identifier),
     identifier.name
   );
-  if (variable === null || variable.defs.length !== 1 || !stableValueBinding(variable))
-    return false;
+  if (variable === null) return false;
+  const specifier = reactImportSpecifier(variable);
+  if (specifier === null) return false;
+  return namespace ? specifier.type === import_utils9.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils9.AST_NODE_TYPES.ImportNamespaceSpecifier : specifier.type === import_utils9.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type" && importSpecifierName(specifier) === hook;
+}
+function reactImportSpecifier(variable) {
+  let specifier = REACT_IMPORTS.get(variable);
+  if (specifier !== void 0) return specifier;
   const definition = variable.defs[0];
-  if (definition?.type !== "ImportBinding" || definition.parent.type !== import_utils8.AST_NODE_TYPES.ImportDeclaration || definition.parent.source.value !== "react" || definition.parent.importKind === "type")
-    return false;
-  const specifier = definition.node;
-  return namespace ? specifier.type === import_utils8.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils8.AST_NODE_TYPES.ImportNamespaceSpecifier : specifier.type === import_utils8.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type" && importSpecifierName(specifier) === hook;
+  specifier = variable.defs.length === 1 && definition?.type === "ImportBinding" && definition.parent.type === import_utils9.AST_NODE_TYPES.ImportDeclaration && definition.parent.source.value === "react" && definition.parent.importKind !== "type" && stableValueBinding(variable) ? definition.node : null;
+  REACT_IMPORTS.set(variable, specifier);
+  return specifier;
 }
 function containsView(node) {
-  if (node.type === import_utils8.AST_NODE_TYPES.JSXElement || node.type === import_utils8.AST_NODE_TYPES.JSXFragment)
+  if (node.type === import_utils9.AST_NODE_TYPES.JSXElement || node.type === import_utils9.AST_NODE_TYPES.JSXFragment)
     return true;
   if (isFunction(node)) return false;
   return forEachOwnAstChild(
@@ -975,7 +1310,7 @@ function containsView(node) {
   );
 }
 function isFunction(node) {
-  return node.type === import_utils8.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils8.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils9.AST_NODE_TYPES.FunctionExpression;
 }
 
 // src/rules/prefer-server-data-preparation.ts
@@ -1015,8 +1350,8 @@ var PREFER_SERVER_DATA_PREPARATION_DOCUMENTATION = {
   category: "architecture",
   limitations: [
     "Advisory only. Local syntax cannot establish whether a caller is a Server Component, whether props change interactively or whether server preparation reduces the total cost. This rule is a review lead, never proof that code can be moved to the server. No automatic fix is provided.",
-    "Requires an explicit use client directive and parser-owned TypeScript services resolving map/filter/flatMap to the standard Array or ReadonlyArray library signature. The containing view must have an independent React useState/useReducer call or an intrinsic DOM onClick/onChange/onInput/onSubmit handler. Noninteractive boundaries remain owned by no-unnecessary-use-client; custom hooks and other indirect client requirements are unsupported.",
-    "Every runtime reference to the source parameter binding must be a supported native data projection or a field-only JSX display loop. Inputs also needed for editing, whole-record forwarding, lookup, mutation, other fields or opaque helpers are excluded. Only direct first-parameter paths and synchronous single-expression callbacks are supported. Whole-row identity maps and constant maps are excluded; supported projections must read a fixed input field.",
+    "Requires an explicit use client directive and parser-owned TypeScript services resolving map/filter/flatMap to the standard Array or ReadonlyArray library signature. The receiver beneath erased wrappers must itself have an Array, ReadonlyArray or tuple type after nullish narrowing; casts from opaque or custom collections do not establish this. Subclass and structural collection types outside those native array types are excluded. The containing view must have an independent React useState/useReducer call or a native callable type on an intrinsic DOM onClick/onChange/onInput/onSubmit handler. Nullish, noncallable and opaque handler types do not establish interaction. Noninteractive boundaries remain owned by no-unnecessary-use-client; custom hooks and indirect client requirements are unsupported.",
+    "Every runtime reference to the source parameter binding must be a supported native data projection or a field-only JSX display loop. Inputs also needed for editing, whole-record forwarding, lookup, mutation, other fields or opaque helpers are excluded. Files containing direct eval are excluded because it can observe or change lexical bindings; indirect eval and properties named eval do not establish lexical access. Only direct first-parameter paths and synchronous single-expression callbacks are supported. Whole-row identity maps and constant maps are excluded; supported projections must read a fixed input field.",
     "JSX-rendering callbacks are never reported as preparation findings. Callback calls, captured values, destructuring defaults/rest/nesting, async callbacks, event handlers, effects, memo callbacks, opaque helpers, dynamic/optional paths, custom collection signatures, missing type services, generated source and tests are excluded. First-parameter provenance is syntactic; annotations cannot prove absence of runtime getters or patched array methods. Analysis does not claim callback purity or preserve semantics of a hypothetical move.",
     "Reports the direct source projection once; chained operations with a call receiver are not independently reported. A static subprojection may still be prepared by its producer while a union with pending local edits remains in the client."
   ],
@@ -1063,35 +1398,65 @@ var prefer_server_data_preparation_default = createRule({
     const services = getTypeServices(context);
     const checker = services.program.getTypeChecker();
     const interactions = /* @__PURE__ */ new WeakMap();
+    const projectedInputs = /* @__PURE__ */ new WeakMap();
+    const callable = (node) => {
+      const type = checker.getTypeAtLocation(
+        services.esTreeNodeToTSNodeMap.get(unwrapExpression(node))
+      );
+      const members = type.isUnion() ? type.types : [type];
+      return members.some((member3) => member3.getCallSignatures().length > 0);
+    };
     const nativeArray = (node) => {
+      const callee = unwrapExpression(node.callee);
+      if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression) return false;
+      const receiver = checker.getNonNullableType(
+        checker.getTypeAtLocation(
+          services.esTreeNodeToTSNodeMap.get(unwrapExpression(callee.object))
+        )
+      );
+      const members = receiver.isUnion() ? receiver.types : [receiver];
+      if (!members.every(
+        (type) => checker.isArrayType(type) || checker.isTupleType(type)
+      ))
+        return false;
       const declaration = checker.getResolvedSignature(
         services.esTreeNodeToTSNodeMap.get(node)
       )?.declaration;
       return declaration !== void 0 && services.program.isSourceFileDefaultLibrary(
         declaration.getSourceFile()
-      ) && import_typescript3.default.isInterfaceDeclaration(declaration.parent) && ["Array", "ReadonlyArray"].includes(declaration.parent.name.text);
+      ) && import_typescript7.default.isInterfaceDeclaration(declaration.parent) && ["Array", "ReadonlyArray"].includes(declaration.parent.name.text);
     };
     return {
       CallExpression(node) {
         const callee = unwrapExpression(node.callee);
-        if (node.optional || callee.type !== import_utils9.AST_NODE_TYPES.MemberExpression || callee.optional || node.arguments.length !== 1 || !METHODS.has(import_utils9.ASTUtils.getPropertyName(callee) ?? ""))
+        if (node.optional || callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression || callee.optional || node.arguments.length !== 1 || !METHODS.has(import_utils10.ASTUtils.getPropertyName(callee) ?? ""))
           return;
         const callback = node.arguments[0];
-        if (callback?.type !== import_utils9.AST_NODE_TYPES.ArrowFunctionExpression && callback?.type !== import_utils9.AST_NODE_TYPES.FunctionExpression)
+        if (callback?.type !== import_utils10.AST_NODE_TYPES.ArrowFunctionExpression && callback?.type !== import_utils10.AST_NODE_TYPES.FunctionExpression)
           return;
         const component = renderFunction(node);
         if (component === null || !parameterPath(
           context.sourceCode,
           callee.object,
           firstParameterBindings(context.sourceCode, component)
-        ) || !projection(context.sourceCode, callback) || !nativeArray(node) || !onlyProjectedInput(context.sourceCode, callee.object, nativeArray))
+        ) || !projection(context.sourceCode, callback))
           return;
         let interactive = interactions.get(component);
         if (interactive === void 0) {
-          interactive = clientInteraction(context.sourceCode, component.body);
+          interactive = clientInteraction(
+            context.sourceCode,
+            component.body,
+            callable
+          );
           interactions.set(component, interactive);
         }
-        if (!interactive) return;
+        if (!interactive || !onlyProjectedInput(
+          context.sourceCode,
+          callee.object,
+          nativeArray,
+          projectedInputs
+        ))
+          return;
         context.report({ node, messageId: "prepareData" });
       }
     };
@@ -1099,7 +1464,7 @@ var prefer_server_data_preparation_default = createRule({
 });
 function clientDirective(program) {
   for (const statement of program.body) {
-    if (statement.type !== import_utils9.AST_NODE_TYPES.ExpressionStatement || statement.directive === void 0)
+    if (statement.type !== import_utils10.AST_NODE_TYPES.ExpressionStatement || statement.directive === void 0)
       return false;
     if (statement.directive === "use client") return true;
   }
@@ -1109,16 +1474,16 @@ function projection(source, callback, mode = "data") {
   if (callback.async || callback.generator || callback.params.length !== 1)
     return false;
   const parameter = callback.params[0];
-  if (parameter?.type === import_utils9.AST_NODE_TYPES.ObjectPattern && parameter.properties.some(
-    (property) => property.type !== import_utils9.AST_NODE_TYPES.Property || property.computed || property.value.type !== import_utils9.AST_NODE_TYPES.Identifier
+  if (parameter?.type === import_utils10.AST_NODE_TYPES.ObjectPattern && parameter.properties.some(
+    (property) => property.type !== import_utils10.AST_NODE_TYPES.Property || property.computed || property.value.type !== import_utils10.AST_NODE_TYPES.Identifier
   ))
     return false;
   const parameters = firstParameterBindings(source, callback);
   if (parameters.size === 0) return false;
   let body3 = callback.body;
-  if (body3.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+  if (body3.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
     const [statement] = body3.body;
-    if (body3.body.length !== 1 || statement?.type !== import_utils9.AST_NODE_TYPES.ReturnStatement || statement.argument === null)
+    if (body3.body.length !== 1 || statement?.type !== import_utils10.AST_NODE_TYPES.ReturnStatement || statement.argument === null)
       return false;
     body3 = statement.argument;
   }
@@ -1127,242 +1492,96 @@ function projection(source, callback, mode = "data") {
     if (depth > 64) return false;
     node = unwrapExpression(node);
     if (parameterPath(source, node, parameters)) {
-      if (node.type !== import_utils9.AST_NODE_TYPES.MemberExpression && callback.params[0]?.type !== import_utils9.AST_NODE_TYPES.ObjectPattern)
+      if (node.type !== import_utils10.AST_NODE_TYPES.MemberExpression && callback.params[0]?.type !== import_utils10.AST_NODE_TYPES.ObjectPattern)
         return false;
       fieldRead = true;
-      return true;
-    }
-    if (node.type === import_utils9.AST_NODE_TYPES.Literal) return !("regex" in node);
-    if (node.type === import_utils9.AST_NODE_TYPES.UnaryExpression)
-      return ["!", "+", "-", "~", "typeof"].includes(node.operator) && inspect(node.argument, depth + 1);
-    if (node.type === import_utils9.AST_NODE_TYPES.BinaryExpression)
-      return BINARY.has(node.operator) && inspect(node.left, depth + 1) && inspect(node.right, depth + 1);
-    if (node.type === import_utils9.AST_NODE_TYPES.LogicalExpression)
-      return inspect(node.left, depth + 1) && inspect(node.right, depth + 1);
-    if (node.type === import_utils9.AST_NODE_TYPES.ConditionalExpression)
-      return inspect(node.test, depth + 1) && inspect(node.consequent, depth + 1) && inspect(node.alternate, depth + 1);
-    if (node.type === import_utils9.AST_NODE_TYPES.ObjectExpression)
-      return node.properties.every(
-        (property) => property.type === import_utils9.AST_NODE_TYPES.Property && property.kind === "init" && !property.method && !property.computed && inspect(property.value, depth + 1)
-      );
-    return mode === "view" && displayProjection(node, (child) => inspect(child, depth + 1));
-  };
-  return inspect(body3, 0) && fieldRead;
-}
-function displayProjection(node, inspectChild) {
-  if (node.type === import_utils9.AST_NODE_TYPES.JSXElement)
-    return node.openingElement.attributes.every(
-      (attribute) => attribute.type === import_utils9.AST_NODE_TYPES.JSXAttribute && (attribute.value === null || inspectChild(attribute.value))
-    ) && node.children.every(inspectChild);
-  if (node.type === import_utils9.AST_NODE_TYPES.JSXFragment)
-    return node.children.every(inspectChild);
-  if (node.type === import_utils9.AST_NODE_TYPES.JSXText) return true;
-  if (node.type === import_utils9.AST_NODE_TYPES.JSXExpressionContainer)
-    return node.expression.type === import_utils9.AST_NODE_TYPES.JSXEmptyExpression || inspectChild(node.expression);
-  return false;
-}
-function onlyProjectedInput(source, receiver, nativeArray) {
-  let root = unwrapExpression(receiver);
-  while (root.type === import_utils9.AST_NODE_TYPES.MemberExpression)
-    root = unwrapExpression(root.object);
-  if (root.type !== import_utils9.AST_NODE_TYPES.Identifier) return false;
-  const variable = import_utils9.ASTUtils.findVariable(source.getScope(root), root.name);
-  return variable !== null && variable.references.every((reference) => {
-    if (typeOnlyReference(reference)) return true;
-    if (!reference.isRead()) return false;
-    let access = outerExpression(reference.identifier);
-    let parent = access.parent;
-    while (parent?.type === import_utils9.AST_NODE_TYPES.MemberExpression && parent.object === access) {
-      access = outerExpression(parent);
-      parent = access.parent;
-    }
-    const member3 = unwrapExpression(access);
-    const call = parent;
-    if (call?.type !== import_utils9.AST_NODE_TYPES.CallExpression) return false;
-    if (member3.type !== import_utils9.AST_NODE_TYPES.MemberExpression || member3.optional || !METHODS.has(import_utils9.ASTUtils.getPropertyName(member3) ?? "") || call.optional || call.arguments.length !== 1 || !nativeArray(call))
-      return false;
-    const callback = call.arguments[0];
-    return (callback?.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression || callback?.type === import_utils9.AST_NODE_TYPES.FunctionExpression) && (projection(source, callback) || projection(source, callback, "view")) && call.callee === access;
-  });
-}
-function clientInteraction(source, node) {
-  if (node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration)
-    return false;
-  if (node.type === import_utils9.AST_NODE_TYPES.CallExpression && (reactHook(source, node.callee, "useState") || reactHook(source, node.callee, "useReducer")))
-    return true;
-  if (node.type === import_utils9.AST_NODE_TYPES.JSXOpeningElement && node.name.type === import_utils9.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.name.name) && node.attributes.some(
-    (attribute) => attribute.type === import_utils9.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils9.AST_NODE_TYPES.JSXIdentifier && DOM_EVENTS.has(attribute.name.name) && attribute.value !== null
-  ))
-    return true;
-  return forEachOwnAstChild(
-    node,
-    (child) => clientInteraction(source, child),
-    (key) => key !== "tokens" && key !== "comments"
-  );
-}
-
-// src/rules/no-readonly-prop-state.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var import_typescript4 = __toESM(require("typescript"), 1);
-
-// src/rules/_unused-private-binding.ts
-var import_utils11 = require("@typescript-eslint/utils");
-
-// src/rules/_type-binding.ts
-var import_utils10 = require("@typescript-eslint/utils");
-function typeBinding(source, identifier) {
-  let scope = source.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== void 0 && (variable.isTypeVariable || variable.defs.some((definition) => definition.isTypeDefinition))) {
-      return variable;
-    }
-    scope = scope.upper;
-  }
-  return null;
-}
-var REFERENCE_INDEXES = /* @__PURE__ */ new WeakMap();
-function retainsNamedTypeUses(source, removed) {
-  const manager = source.scopeManager;
-  if (manager === null) return false;
-  const index = referenceIndex(source, manager);
-  for (const reference of referencesWithin(index.references, removed)) {
-    if (!reference.isRead()) continue;
-    const binding3 = reference.resolved;
-    if (!binding3 || !reference.isTypeReference && !reference.isValueReference) return false;
-    if (binding3.defs.length === 0) continue;
-    const reads = publicReadExtents(index, binding3);
-    const extent = reference.isTypeReference ? reference.isValueReference ? reads.both : reads.type : reads.value;
-    if (extent === null || extent.minStart >= removed.range[0] && extent.maxEnd <= removed.range[1]) return false;
-  }
-  return true;
-}
-function referenceIndex(source, manager) {
-  const cached = REFERENCE_INDEXES.get(source);
-  if (cached?.manager === manager) return cached;
-  const references = manager.scopes.flatMap((scope) => scope.references);
-  references.sort((left, right) => left.identifier.range[0] - right.identifier.range[0]);
-  const index = { manager, references, publicReads: /* @__PURE__ */ new Map() };
-  REFERENCE_INDEXES.set(source, index);
-  return index;
-}
-function* referencesWithin(references, removed) {
-  let low = 0;
-  let high = references.length;
-  while (low < high) {
-    const middle = low + Math.floor((high - low) / 2);
-    const reference = references[middle];
-    if (reference === void 0 || reference.identifier.range[0] >= removed.range[0]) high = middle;
-    else low = middle + 1;
-  }
-  for (let index = low; index < references.length; index++) {
-    const reference = references[index];
-    if (reference === void 0) continue;
-    if (reference.identifier.range[0] > removed.range[1]) break;
-    if (insideTypeRange(reference.identifier, removed)) yield reference;
-  }
-}
-function publicReadExtents(index, binding3) {
-  const cached = index.publicReads.get(binding3);
-  if (cached !== void 0) return cached;
-  let type = null;
-  let value = null;
-  let both = null;
-  for (const retained of binding3.references) {
-    if (!retained.isRead() || !retained.isTypeReference && !retained.isValueReference || binding3.defs.some((definition) => insideTypeRange(retained.identifier, definition.node)) || !publicTypeUse(retained.identifier)) continue;
-    if (retained.isTypeReference) type = extendExtent(type, retained.identifier);
-    if (retained.isValueReference) value = extendExtent(value, retained.identifier);
-    if (retained.isTypeReference && retained.isValueReference) both = extendExtent(both, retained.identifier);
-  }
-  const result = { type, value, both };
-  index.publicReads.set(binding3, result);
-  return result;
-}
-function extendExtent(extent, identifier) {
-  return {
-    minStart: Math.min(extent?.minStart ?? identifier.range[0], identifier.range[0]),
-    maxEnd: Math.max(extent?.maxEnd ?? identifier.range[1], identifier.range[1])
-  };
-}
-function publicTypeUse(identifier) {
-  let node = identifier;
-  while (node.parent) {
-    if (node.type === import_utils10.AST_NODE_TYPES.TSTypeAnnotation || node.type === import_utils10.AST_NODE_TYPES.TSTypePredicate || node.type === import_utils10.AST_NODE_TYPES.TSAsExpression || node.type === import_utils10.AST_NODE_TYPES.TSTypeAssertion) return false;
-    if (node.type === import_utils10.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      return node.parent.type === import_utils10.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.declaration === node && node.parent.parent.type === import_utils10.AST_NODE_TYPES.Program;
-    }
-    if (node.type === import_utils10.AST_NODE_TYPES.ExportSpecifier) {
-      return node.parent.type === import_utils10.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.source === null && node.parent.parent.type === import_utils10.AST_NODE_TYPES.Program;
-    }
-    node = node.parent;
-  }
-  return false;
-}
-function insideTypeRange(node, range) {
-  return node.range[0] >= range.range[0] && node.range[1] <= range.range[1];
-}
-
-// src/rules/_unused-private-binding.ts
-function isUnusedPrivateBinding(sourceCode, declaration, identifier, filename, allowedDeclarations = [declaration]) {
-  if (/\.d\.[cm]?ts$/u.test(filename)) return false;
-  const bindings = sourceCode.getDeclaredVariables(declaration).filter((binding3) => binding3.name === identifier.name);
-  if (bindings.length === 0 || bindings.some((binding3) => binding3.defs.length !== allowedDeclarations.length || binding3.defs.some((definition) => !allowedDeclarations.includes(definition.node)) || binding3.eslintUsed || binding3.references.some((reference) => reference.isRead() || reference.init !== true))) return false;
-  if (hasIdentifierNamed(sourceCode.ast, "eval")) return false;
-  const statement = declaration.type === import_utils11.AST_NODE_TYPES.VariableDeclarator ? declaration.parent : declaration;
-  if (statement.parent.type === import_utils11.AST_NODE_TYPES.ExportNamedDeclaration || statement.parent.type === import_utils11.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
-  if (statement.parent.type !== import_utils11.AST_NODE_TYPES.Program) return statement.parent.type === import_utils11.AST_NODE_TYPES.BlockStatement;
-  return sourceCode.ast.body.some((node) => node.type === import_utils11.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils11.AST_NODE_TYPES.ExportNamedDeclaration || node.type === import_utils11.AST_NODE_TYPES.ExportDefaultDeclaration || node.type === import_utils11.AST_NODE_TYPES.ExportAllDeclaration);
+      return true;
+    }
+    if (node.type === import_utils10.AST_NODE_TYPES.Literal) return !("regex" in node);
+    if (node.type === import_utils10.AST_NODE_TYPES.UnaryExpression)
+      return ["!", "+", "-", "~", "typeof"].includes(node.operator) && inspect(node.argument, depth + 1);
+    if (node.type === import_utils10.AST_NODE_TYPES.BinaryExpression)
+      return BINARY.has(node.operator) && inspect(node.left, depth + 1) && inspect(node.right, depth + 1);
+    if (node.type === import_utils10.AST_NODE_TYPES.LogicalExpression)
+      return inspect(node.left, depth + 1) && inspect(node.right, depth + 1);
+    if (node.type === import_utils10.AST_NODE_TYPES.ConditionalExpression)
+      return inspect(node.test, depth + 1) && inspect(node.consequent, depth + 1) && inspect(node.alternate, depth + 1);
+    if (node.type === import_utils10.AST_NODE_TYPES.ObjectExpression)
+      return node.properties.every(
+        (property) => property.type === import_utils10.AST_NODE_TYPES.Property && property.kind === "init" && !property.method && !property.computed && inspect(property.value, depth + 1)
+      );
+    return mode === "view" && displayProjection(node, (child) => inspect(child, depth + 1));
+  };
+  return inspect(body3, 0) && fieldRead;
 }
-function hasOnlyDirectFactoryUses(variable) {
-  return variable.references.every((reference) => {
-    if (reference.isTypeReference && !reference.isValueReference) return true;
-    const identifier = reference.identifier;
-    const parent = identifier.parent;
-    if (parent.type === import_utils11.AST_NODE_TYPES.CallExpression && parent.callee === identifier) return true;
-    return parent.type === import_utils11.AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.parent.type === import_utils11.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
-  });
+function displayProjection(node, inspectChild) {
+  if (node.type === import_utils10.AST_NODE_TYPES.JSXElement)
+    return node.openingElement.attributes.every(
+      (attribute) => attribute.type === import_utils10.AST_NODE_TYPES.JSXAttribute && (attribute.value === null || inspectChild(attribute.value))
+    ) && node.children.every(inspectChild);
+  if (node.type === import_utils10.AST_NODE_TYPES.JSXFragment)
+    return node.children.every(inspectChild);
+  if (node.type === import_utils10.AST_NODE_TYPES.JSXText) return true;
+  if (node.type === import_utils10.AST_NODE_TYPES.JSXExpressionContainer)
+    return node.expression.type === import_utils10.AST_NODE_TYPES.JSXEmptyExpression || inspectChild(node.expression);
+  return false;
 }
-var IDENTIFIER_NAMES = /* @__PURE__ */ new WeakMap();
-function hasIdentifierNamed(node, name) {
-  let names = IDENTIFIER_NAMES.get(node);
-  if (names === void 0) {
-    const collected = /* @__PURE__ */ new Set();
-    const pending = [node];
-    const seen = /* @__PURE__ */ new WeakSet();
-    while (pending.length > 0) {
-      const current = pending.pop();
-      if (current === void 0 || seen.has(current)) continue;
-      seen.add(current);
-      if (current.type === import_utils11.AST_NODE_TYPES.Identifier || current.type === import_utils11.AST_NODE_TYPES.JSXIdentifier) collected.add(current.name);
-      forEachOwnAstChild(current, (child) => {
-        pending.push(child);
-      }, (key) => key !== "tokens" && key !== "comments");
+function onlyProjectedInput(source, receiver, nativeArray, cache) {
+  let root = unwrapExpression(receiver);
+  while (root.type === import_utils10.AST_NODE_TYPES.MemberExpression)
+    root = unwrapExpression(root.object);
+  if (root.type !== import_utils10.AST_NODE_TYPES.Identifier) return false;
+  const variable = import_utils10.ASTUtils.findVariable(source.getScope(root), root.name);
+  if (variable === null) return false;
+  const cached = cache.get(variable);
+  if (cached !== void 0) return cached;
+  const projected = variable.references.every((reference) => {
+    if (typeOnlyReference(reference)) return true;
+    if (!reference.isRead()) return false;
+    let access = outerExpression(reference.identifier);
+    let parent = access.parent;
+    while (parent?.type === import_utils10.AST_NODE_TYPES.MemberExpression && parent.object === access) {
+      access = outerExpression(parent);
+      parent = access.parent;
     }
-    names = collected;
-    IDENTIFIER_NAMES.set(node, names);
-  }
-  return names.has(name);
+    const member3 = unwrapExpression(access);
+    const call = parent;
+    if (call?.type !== import_utils10.AST_NODE_TYPES.CallExpression) return false;
+    if (member3.type !== import_utils10.AST_NODE_TYPES.MemberExpression || member3.optional || !METHODS.has(import_utils10.ASTUtils.getPropertyName(member3) ?? "") || call.optional || call.arguments.length !== 1 || !nativeArray(call))
+      return false;
+    const callback = call.arguments[0];
+    return (callback?.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression || callback?.type === import_utils10.AST_NODE_TYPES.FunctionExpression) && (projection(source, callback) || projection(source, callback, "view")) && call.callee === access;
+  });
+  cache.set(variable, projected);
+  return projected;
 }
-function privatePredicateBooleanFix(sourceCode, node, annotation, filename) {
-  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_utils11.AST_NODE_TYPES.FunctionDeclaration || node.id === null || !isUnusedPrivateBinding(sourceCode, node, node.id, filename) || sourceCode.getCommentsInside(annotation).length > 0) return null;
-  const text = `boolean${sourceCode.getText(annotation).replace(/[^\r\n\u2028\u2029]/gu, "")}`;
-  const neighbor = Math.max(0, annotation.range[0] - 1);
-  const before = sourceCode.text.slice(neighbor, annotation.range[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
-  const after = (sourceCode.text.slice(neighbor, annotation.range[0]) + text + sourceCode.text.slice(annotation.range[1], annotation.range[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
-  if (before.length !== after.length || before.some((ending, index) => ending !== after[index])) return null;
-  return (fixer) => fixer.replaceText(annotation, text);
+function clientInteraction(source, node, callable) {
+  if (node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration)
+    return false;
+  if (node.type === import_utils10.AST_NODE_TYPES.CallExpression && (reactHook(source, node.callee, "useState") || reactHook(source, node.callee, "useReducer")))
+    return true;
+  if (node.type === import_utils10.AST_NODE_TYPES.JSXOpeningElement && node.name.type === import_utils10.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.name.name) && node.attributes.some(
+    (attribute) => attribute.type === import_utils10.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils10.AST_NODE_TYPES.JSXIdentifier && DOM_EVENTS.has(attribute.name.name) && attribute.value?.type === import_utils10.AST_NODE_TYPES.JSXExpressionContainer && attribute.value.expression.type !== import_utils10.AST_NODE_TYPES.JSXEmptyExpression && callable(attribute.value.expression)
+  ))
+    return true;
+  return forEachOwnAstChild(
+    node,
+    (child) => clientInteraction(source, child, callable),
+    (key) => key !== "tokens" && key !== "comments"
+  );
 }
 
 // src/rules/no-readonly-prop-state.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var import_typescript8 = __toESM(require("typescript"), 1);
 var BEFORE2 = "import { useState } from 'react'; export function Status({ status }: { status: string }) { const [savedStatus] = useState(status); return <p>{savedStatus}</p>; }";
 var AFTER2 = "export function Status({ status }: { status: string }) { return <p>{status}</p>; }";
 var CONFIG2 = {
   path: "tsconfig.json",
   source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler","jsx":"preserve"},"include":["src/**/*"]}'
 };
-var OPAQUE_TYPES = import_typescript4.default.TypeFlags.Any | import_typescript4.default.TypeFlags.Unknown | import_typescript4.default.TypeFlags.Never | import_typescript4.default.TypeFlags.TypeParameter | import_typescript4.default.TypeFlags.Conditional | import_typescript4.default.TypeFlags.IndexedAccess | import_typescript4.default.TypeFlags.Substitution;
+var PRIMITIVE_TYPES = import_typescript8.default.TypeFlags.StringLike | import_typescript8.default.TypeFlags.NumberLike | import_typescript8.default.TypeFlags.BigIntLike | import_typescript8.default.TypeFlags.BooleanLike | import_typescript8.default.TypeFlags.ESSymbolLike | import_typescript8.default.TypeFlags.Null | import_typescript8.default.TypeFlags.Undefined;
 var MAX_TYPE_DEPTH = 16;
-var FUNCTION_MEMBERS = ["apply", "bind", "call"];
 var NO_READONLY_PROP_STATE_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Review props copied into state without a usable updater.",
@@ -1372,11 +1591,12 @@ var NO_READONLY_PROP_STATE_DOCUMENTATION = {
   limitations: [
     "Advisory only: initial snapshots can be intentional. There is no automatic fix because replacing state with current props changes how later updates behave.",
     "Recognizes direct React useState imports and default/namespace member calls, including renamed imports, through lexical binding identity. Checks a direct array destructure in a function containing its own JSX and a direct first-parameter property path, or a zero-argument synchronous lazy initializer returning that path.",
-    "Eager initializers require parser-owned TypeScript services and a non-callable type without Any, unknown or unresolved generics. Callable unions, constructors and legacy function-like types exposing apply/bind/call are excluded because React executes function arguments as lazy initializers. Explicit zero-argument lazy callbacks returning the prop directly do not require type information. Type annotations cannot prove runtime identity under opaque casts; lifecycle changes stay manual.",
-    "An updater read, escape, reassignment or nontrivial destructuring excludes the finding. Unused state values remain owned by unused-variable checks. Opaque initialization, property aliases, optional/dynamic paths, rest/default bindings, dynamic eval, non-JSX hooks, generated source and tests are outside scope. This does not ban interactive useState or replace the upstream set-state-in-effect rule."
+    "Eager initializers require parser-owned TypeScript services and primitive types, including unions composed entirely of primitives. Object and void types can hide callable values through structural assignment or ignored return values, so eager nonprimitive values, Any, unknown and unresolved generics are excluded. React executes function arguments as lazy initializers. Explicit zero-argument lazy callbacks returning a prop directly remain supported for all value types without type services. Opaque casts cannot prove runtime identity; lifecycle changes stay manual.",
+    "An updater read, escape, reassignment or nontrivial destructuring excludes the finding. Unused state values remain owned by unused-variable checks. Files containing direct eval are excluded because it can observe or change lexical bindings. Indirect eval and properties named eval do not establish lexical access. Opaque initialization, property aliases, optional/dynamic paths, rest/default bindings, non-JSX hooks, generated source and tests are outside scope. This does not ban interactive useState or replace the upstream set-state-in-effect rule."
   ],
   references: [
     "https://react.dev/learn/choosing-the-state-structure",
+    "https://react.dev/reference/react/useState",
     "https://react.dev/reference/eslint-plugin-react-hooks/lints/set-state-in-effect"
   ],
   examples: [
@@ -1414,19 +1634,19 @@ var no_readonly_prop_state_default = createRule({
   defaultOptions: [],
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text) || isTestFile(context) || !context.sourceCode.ast.body.some(
-      (statement) => statement.type === import_utils12.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "react" && statement.importKind !== "type"
-    ) || hasIdentifierNamed(context.sourceCode.ast, "eval"))
+      (statement) => statement.type === import_utils11.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "react" && statement.importKind !== "type"
+    ))
       return {};
     return {
       CallExpression(node) {
         if (node.optional || node.arguments.length !== 1 || !reactHook(context.sourceCode, node.callee, "useState"))
           return;
         const declaration = outerExpression(node).parent;
-        if (declaration.type !== import_utils12.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || !hasReadonlyStateBinding(context.sourceCode, declaration))
+        if (declaration.type !== import_utils11.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || !hasReadonlyStateBinding(context.sourceCode, declaration))
           return;
         const component = renderFunction(node);
         const argument = node.arguments[0];
-        if (component === null || argument === void 0 || argument.type === import_utils12.AST_NODE_TYPES.SpreadElement)
+        if (component === null || argument === void 0 || argument.type === import_utils11.AST_NODE_TYPES.SpreadElement)
           return;
         const initial = initializerValue(argument);
         if (initial === null || !parameterPath(
@@ -1436,12 +1656,12 @@ var no_readonly_prop_state_default = createRule({
         ))
           return;
         const lazy = unwrapExpression(argument);
-        if (lazy.type !== import_utils12.AST_NODE_TYPES.ArrowFunctionExpression && lazy.type !== import_utils12.AST_NODE_TYPES.FunctionExpression) {
+        if (lazy.type !== import_utils11.AST_NODE_TYPES.ArrowFunctionExpression && lazy.type !== import_utils11.AST_NODE_TYPES.FunctionExpression) {
           if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap)
             return;
           const services = getTypeServices(context);
           const type = services.program.getTypeChecker().getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(initial));
-          if (!isNonCallableType(type)) return;
+          if (!isPrimitiveType(type)) return;
         }
         context.report({ node, messageId: "readonlyPropState" });
       }
@@ -1449,9 +1669,9 @@ var no_readonly_prop_state_default = createRule({
   }
 });
 function hasReadonlyStateBinding(source, declaration) {
-  if (declaration.id.type !== import_utils12.AST_NODE_TYPES.ArrayPattern) return false;
+  if (declaration.id.type !== import_utils11.AST_NODE_TYPES.ArrayPattern) return false;
   const [value, setter] = declaration.id.elements;
-  if (value?.type !== import_utils12.AST_NODE_TYPES.Identifier || declaration.id.elements.length > 2 || setter !== void 0 && setter !== null && setter.type !== import_utils12.AST_NODE_TYPES.Identifier)
+  if (value?.type !== import_utils11.AST_NODE_TYPES.Identifier || declaration.id.elements.length > 2 || setter !== void 0 && setter !== null && setter.type !== import_utils11.AST_NODE_TYPES.Identifier)
     return false;
   const variables = source.getDeclaredVariables(declaration);
   const state = variables.find(
@@ -1461,7 +1681,7 @@ function hasReadonlyStateBinding(source, declaration) {
     (reference) => reference.isRead() && !typeOnlyReference(reference)
   ))
     return false;
-  if (setter?.type === import_utils12.AST_NODE_TYPES.Identifier) {
+  if (setter?.type === import_utils11.AST_NODE_TYPES.Identifier) {
     const updater = variables.find(
       (variable) => variable.identifiers.includes(setter)
     );
@@ -1474,21 +1694,22 @@ function hasReadonlyStateBinding(source, declaration) {
 }
 function initializerValue(node) {
   node = unwrapExpression(node);
-  if (node.type !== import_utils12.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils12.AST_NODE_TYPES.FunctionExpression)
+  if (node.type !== import_utils11.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils11.AST_NODE_TYPES.FunctionExpression)
     return node;
   if (node.async || node.generator || node.params.length !== 0) return null;
-  if (node.body.type !== import_utils12.AST_NODE_TYPES.BlockStatement) return node.body;
+  if (node.body.type !== import_utils11.AST_NODE_TYPES.BlockStatement) return node.body;
   const [statement] = node.body.body;
-  return node.body.body.length === 1 && statement?.type === import_utils12.AST_NODE_TYPES.ReturnStatement ? statement.argument : null;
+  return node.body.body.length === 1 && statement?.type === import_utils11.AST_NODE_TYPES.ReturnStatement ? statement.argument : null;
 }
-function isNonCallableType(type, depth = 0) {
-  if (depth >= MAX_TYPE_DEPTH || (type.flags & OPAQUE_TYPES) !== 0 || type.getCallSignatures().length !== 0 || type.getConstructSignatures().length !== 0 || FUNCTION_MEMBERS.every((member3) => type.getProperty(member3) !== void 0))
-    return false;
-  return !type.isUnionOrIntersection() || type.types.every((member3) => isNonCallableType(member3, depth + 1));
+function isPrimitiveType(type, depth = 0) {
+  if (depth >= MAX_TYPE_DEPTH) return false;
+  if (type.isIntersection())
+    return type.getCallSignatures().length === 0 && type.getConstructSignatures().length === 0 && type.types.some((member3) => isPrimitiveType(member3, depth + 1));
+  return type.isUnion() ? type.types.every((member3) => isPrimitiveType(member3, depth + 1)) : (type.flags & PRIMITIVE_TYPES) !== 0;
 }
 
 // src/rules/no-runtime-typeof.ts
-var import_utils13 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 var NO_RUNTIME_TYPEOF_DOCUMENTATION = {
   defaultLevel: "error",
   summary: "Prefer Zod boundary schemas or discriminated unions over runtime typeof checks.",
@@ -1606,9 +1827,9 @@ var no_runtime_typeof_default = createRule({
       UnaryExpression(node) {
         if (node.operator !== "typeof") return;
         const parent = node.parent;
-        if (node.argument.type === import_utils13.AST_NODE_TYPES.Identifier && parent.type === import_utils13.AST_NODE_TYPES.BinaryExpression && ["===", "!==", "==", "!="].includes(parent.operator)) {
+        if (node.argument.type === import_utils12.AST_NODE_TYPES.Identifier && parent.type === import_utils12.AST_NODE_TYPES.BinaryExpression && ["===", "!==", "==", "!="].includes(parent.operator)) {
           const other = parent.left === node ? parent.right : parent.left;
-          if (other.type === import_utils13.AST_NODE_TYPES.Literal && other.value === "undefined" && !import_utils13.ASTUtils.findVariable(context.sourceCode.getScope(node.argument), node.argument.name)?.defs.length) return;
+          if (other.type === import_utils12.AST_NODE_TYPES.Literal && other.value === "undefined" && !import_utils12.ASTUtils.findVariable(context.sourceCode.getScope(node.argument), node.argument.name)?.defs.length) return;
         }
         context.report({ node, messageId: "runtimeTypeof" });
       }
@@ -1619,7 +1840,7 @@ var no_runtime_typeof_default = createRule({
 // src/rules/_is-frontend-source.ts
 var import_node_fs = require("fs");
 var import_node_path2 = require("path");
-var import_utils14 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var FRONTEND_PACKAGES = /* @__PURE__ */ new Set(["react", "react-dom", "next", "preact", "vue", "svelte", "@angular/core", "solid-js", "@sveltejs/kit", "astro"]);
 var FRONTEND_IMPORT = /^(?:react(?:-dom)?|next|preact|vue|svelte|@angular\/core|solid-js|@sveltejs\/kit)(?:\/|$)/u;
 function isFrontendSource(context) {
@@ -1647,15 +1868,15 @@ function declaresFrontend(value) {
 }
 function frontendModule(program) {
   return program.body.some(
-    (statement) => statement.type === import_utils14.AST_NODE_TYPES.ExpressionStatement && (statement.directive === "use client" || statement.directive === "use server") || statement.type === import_utils14.AST_NODE_TYPES.ImportDeclaration && FRONTEND_IMPORT.test(statement.source.value)
+    (statement) => statement.type === import_utils13.AST_NODE_TYPES.ExpressionStatement && (statement.directive === "use client" || statement.directive === "use server") || statement.type === import_utils13.AST_NODE_TYPES.ImportDeclaration && FRONTEND_IMPORT.test(statement.source.value)
   );
 }
 
 // src/rules/no-test-comments.ts
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils16 = require("@typescript-eslint/utils");
 
 // src/rules/_comments.ts
-var import_utils15 = require("@typescript-eslint/utils");
+var import_utils14 = require("@typescript-eslint/utils");
 var REF_RE = /https?:\/\/|\bRFC[- ]?\d+|\bPEP[- ]?\d+|\bCVE-\d{4}|\b(?!UTF-|SHA-|ISO-|AES-|CRC-|MD-|PCM-|EOF-|API-|BASE-)[A-Z][A-Z0-9]{1,9}-\d[A-Z0-9]{0,5}\b|(?<![&\w])#\d{2,6}\b|@[a-z][\w.-]*\.(?:us|com|ai|io|net|org|dev)\b/;
 var VERSION_RE = /(?:>=|<=|==|<|>)\s*v?\d+\.\d+|\bv\d+\.\d+|\b(?:since|until|as of)\s+(?:v?\d+\.\d+|Python\s*\d)/i;
 var UNITS_RE = /[~<>]?\d+(?:\.\d+)?\s?(?:ms|s\b|sec\b|seconds?\b|min\b|minutes?\b|hours?\b|days?\b|KB|MB|MiB|GiB|kHz|Hz|bytes?\b|bit\b|-bit\b|%|px\b|rps\b|qps\b)|\b[1-5]xx\b|\b(?:301|302|304|307|308|400|401|403|404|405|409|410|412|422|425|429|500|501|502|503|504)\b/;
@@ -1741,10 +1962,10 @@ var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
 var TOKEN_PLURAL_MIN = 4;
 var RESTATABLE_STATEMENTS = /* @__PURE__ */ new Set([
-  import_utils15.AST_NODE_TYPES.ExpressionStatement,
-  import_utils15.AST_NODE_TYPES.ReturnStatement,
-  import_utils15.AST_NODE_TYPES.ThrowStatement,
-  import_utils15.AST_NODE_TYPES.VariableDeclaration
+  import_utils14.AST_NODE_TYPES.ExpressionStatement,
+  import_utils14.AST_NODE_TYPES.ReturnStatement,
+  import_utils14.AST_NODE_TYPES.ThrowStatement,
+  import_utils14.AST_NODE_TYPES.VariableDeclaration
 ]);
 var NARRATION_VERB_RE = /^(?:add|append|assign|build|calculate|call|check|clear|close|compute|convert|copy|count|create|declare|decrement|define|delete|extract|fetch|filter|find|format|generate|get|handle|increment|init|initialise|initialize|insert|iterate|join|load|log|loop|make|map|merge|open|parse|print|process|push|read|remove|render|reset|return|save|send|set|setup|sort|split|start|stop|store|update|validate|wrap|write)(?:s|es|d|ed|ing)?$/i;
 var NARRATION_STOPWORDS = /* @__PURE__ */ new Set([
@@ -1803,12 +2024,12 @@ function restatableStatementBelow(comment, sourceCode) {
 function restatableStatementNodeBelow(comment, sourceCode) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
   if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return null;
-  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils15.AST_NODE_TYPES.Program; node = node.parent) {
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils14.AST_NODE_TYPES.Program; node = node.parent) {
     if (!RESTATABLE_STATEMENTS.has(node.type)) continue;
     if (node.loc.start.line !== token.loc.start.line || node.loc.end.line !== node.loc.start.line) {
       return null;
     }
-    if (node.type === import_utils15.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
+    if (node.type === import_utils14.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
       return null;
     }
     return node;
@@ -1818,8 +2039,8 @@ function restatableStatementNodeBelow(comment, sourceCode) {
 function isTrivialInitializer(node) {
   return node.declarations.every((declarator) => {
     const init = declarator.init;
-    if (init == null || init.type === import_utils15.AST_NODE_TYPES.Literal) return true;
-    return init.type === import_utils15.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils15.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
+    if (init == null || init.type === import_utils14.AST_NODE_TYPES.Literal) return true;
+    return init.type === import_utils14.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils14.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
   });
 }
 function restatesStatementHead(body3, statement) {
@@ -1846,7 +2067,7 @@ function headTokens(source) {
 }
 
 // src/rules/_comment-edits.ts
-var import_utils16 = require("@typescript-eslint/utils");
+var import_utils15 = require("@typescript-eslint/utils");
 function physicalLineEnd(text, offset) {
   const newline = text.indexOf("\n", offset);
   return newline < 0 ? text.length : newline;
@@ -1969,7 +2190,7 @@ function ownsTestComments(context) {
   if (!isTestFile(context)) return false;
   const filename = scopedFilename(context);
   const unambiguous = /(?:^|\/)(?:tests?|__tests__|fixtures|__fixtures__|__mocks__)\//u.test(filename) || /\.(?:test|spec|e2e|integration)\.[cm]?[jt]sx?$/u.test(filename);
-  const framework = context.sourceCode.ast.body.some((statement) => statement.type === import_utils17.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils17.AST_NODE_TYPES.ImportSpecifier || specifier.importKind !== "type")) && ["vitest", "@jest/globals", "@playwright/test", "bun:test", "node:test"].includes(statement.source.value));
+  const framework = context.sourceCode.ast.body.some((statement) => statement.type === import_utils16.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils16.AST_NODE_TYPES.ImportSpecifier || specifier.importKind !== "type")) && ["vitest", "@jest/globals", "@playwright/test", "bun:test", "node:test"].includes(statement.source.value));
   return unambiguous || framework;
 }
 var no_test_comments_default = createRule({
@@ -2152,7 +2373,7 @@ function emptyCommentRange(text, comment) {
 }
 
 // src/rules/prefer-dependency-interface.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var PREFER_DEPENDENCY_INTERFACE_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Annotate retained collaborators with their existing interface when the consumer uses only that contract.",
@@ -2177,31 +2398,31 @@ var prefer_dependency_interface_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     function contract(node) {
       const concrete = definition(node);
-      if (concrete?.type !== import_utils18.AST_NODE_TYPES.ClassDeclaration || concrete.abstract || concrete.superClass !== null || concrete.decorators.length !== 0 || concrete.typeParameters !== void 0 || concrete.implements.length !== 1) return null;
+      if (concrete?.type !== import_utils17.AST_NODE_TYPES.ClassDeclaration || concrete.abstract || concrete.superClass !== null || concrete.decorators.length !== 0 || concrete.typeParameters !== void 0 || concrete.implements.length !== 1) return null;
       const heritage = concrete.implements[0];
-      if (heritage?.expression.type !== import_utils18.AST_NODE_TYPES.Identifier) return null;
+      if (heritage?.expression.type !== import_utils17.AST_NODE_TYPES.Identifier) return null;
       const port = definition(heritage.expression);
-      return port?.type === import_utils18.AST_NODE_TYPES.TSInterfaceDeclaration && port.extends.length === 0 && port.typeParameters === void 0 ? port : null;
+      return port?.type === import_utils17.AST_NODE_TYPES.TSInterfaceDeclaration && port.extends.length === 0 && port.typeParameters === void 0 ? port : null;
     }
     function definition(node) {
-      const variable = import_utils18.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      const variable = import_utils17.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
       return variable?.defs.length === 1 ? variable.defs[0]?.node ?? null : null;
     }
     function usesOnlyInterface(owner, name, port) {
       const members = /* @__PURE__ */ new Set();
       for (const member3 of port.body.body) {
-        if (member3.type !== import_utils18.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils18.AST_NODE_TYPES.TSPropertySignature || member3.computed || member3.key.type !== import_utils18.AST_NODE_TYPES.Identifier) return false;
+        if (member3.type !== import_utils17.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils17.AST_NODE_TYPES.TSPropertySignature || member3.computed || member3.key.type !== import_utils17.AST_NODE_TYPES.Identifier) return false;
         members.add(member3.key.name);
       }
       let uses = 0;
       let compatible = true;
       function visit(node) {
-        if (node.type === import_utils18.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils18.AST_NODE_TYPES.ThisExpression && import_utils18.ASTUtils.getPropertyName(node) === name) {
+        if (node.type === import_utils17.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils17.AST_NODE_TYPES.ThisExpression && import_utils17.ASTUtils.getPropertyName(node) === name) {
           uses += 1;
           const parent = node.parent;
-          if (parent.type !== import_utils18.AST_NODE_TYPES.MemberExpression || parent.object !== node || !members.has(import_utils18.ASTUtils.getPropertyName(parent) ?? "") || parent.parent.type === import_utils18.AST_NODE_TYPES.AssignmentExpression && parent.parent.left === parent || parent.parent.type === import_utils18.AST_NODE_TYPES.UpdateExpression) compatible = false;
+          if (parent.type !== import_utils17.AST_NODE_TYPES.MemberExpression || parent.object !== node || !members.has(import_utils17.ASTUtils.getPropertyName(parent) ?? "") || parent.parent.type === import_utils17.AST_NODE_TYPES.AssignmentExpression && parent.parent.left === parent || parent.parent.type === import_utils17.AST_NODE_TYPES.UpdateExpression) compatible = false;
         }
-        if (node !== owner && (node.type === import_utils18.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils18.AST_NODE_TYPES.ClassExpression)) return;
+        if (node !== owner && (node.type === import_utils17.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils17.AST_NODE_TYPES.ClassExpression)) return;
         forEachOwnAstChild(node, visit);
       }
       visit(owner);
@@ -2211,9 +2432,9 @@ var prefer_dependency_interface_default = createRule({
       TSParameterProperty(node) {
         const parameter = node.parameter;
         const constructor = node.parent.parent;
-        if (!node.readonly || node.accessibility !== "private" || node.decorators.length !== 0 || parameter.type !== import_utils18.AST_NODE_TYPES.Identifier || parameter.typeAnnotation?.typeAnnotation.type !== import_utils18.AST_NODE_TYPES.TSTypeReference || parameter.typeAnnotation.typeAnnotation.typeName.type !== import_utils18.AST_NODE_TYPES.Identifier || constructor.type !== import_utils18.AST_NODE_TYPES.MethodDefinition || constructor.kind !== "constructor" || constructor.value.body?.body.length !== 0 || constructor.parent.type !== import_utils18.AST_NODE_TYPES.ClassBody) return;
+        if (!node.readonly || node.accessibility !== "private" || node.decorators.length !== 0 || parameter.type !== import_utils17.AST_NODE_TYPES.Identifier || parameter.typeAnnotation?.typeAnnotation.type !== import_utils17.AST_NODE_TYPES.TSTypeReference || parameter.typeAnnotation.typeAnnotation.typeName.type !== import_utils17.AST_NODE_TYPES.Identifier || constructor.type !== import_utils17.AST_NODE_TYPES.MethodDefinition || constructor.kind !== "constructor" || constructor.value.body?.body.length !== 0 || constructor.parent.type !== import_utils17.AST_NODE_TYPES.ClassBody) return;
         const owner = constructor.parent.parent;
-        if (owner.type !== import_utils18.AST_NODE_TYPES.ClassDeclaration && owner.type !== import_utils18.AST_NODE_TYPES.ClassExpression) return;
+        if (owner.type !== import_utils17.AST_NODE_TYPES.ClassDeclaration && owner.type !== import_utils17.AST_NODE_TYPES.ClassExpression) return;
         if (owner.decorators.length !== 0 || owner.typeParameters !== void 0) return;
         const port = contract(parameter.typeAnnotation.typeAnnotation.typeName);
         if (port !== null && usesOnlyInterface(owner, parameter.name, port)) context.report({ node: parameter.typeAnnotation, messageId: "interface", data: { contract: port.id.name } });
@@ -2223,7 +2444,7 @@ var prefer_dependency_interface_default = createRule({
 });
 
 // src/rules/no-mutating-input-with-result.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var NO_MUTATING_INPUT_WITH_RESULT_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Return replacement object values instead of writing input fields in result-returning functions.",
@@ -2241,8 +2462,8 @@ var NO_MUTATING_INPUT_WITH_RESULT_DOCUMENTATION = {
   ]
 };
 function command(annotation) {
-  if (annotation.type === import_utils19.AST_NODE_TYPES.TSVoidKeyword || annotation.type === import_utils19.AST_NODE_TYPES.TSUndefinedKeyword || annotation.type === import_utils19.AST_NODE_TYPES.TSNeverKeyword) return true;
-  if (annotation.type === import_utils19.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils19.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && annotation.typeArguments?.params.length === 1) {
+  if (annotation.type === import_utils18.AST_NODE_TYPES.TSVoidKeyword || annotation.type === import_utils18.AST_NODE_TYPES.TSUndefinedKeyword || annotation.type === import_utils18.AST_NODE_TYPES.TSNeverKeyword) return true;
+  if (annotation.type === import_utils18.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils18.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && annotation.typeArguments?.params.length === 1) {
     const result = annotation.typeArguments.params[0];
     return result !== void 0 && command(result);
   }
@@ -2257,35 +2478,35 @@ function fields(annotation, sourceCode) {
   return names;
 }
 function membersOf(annotation, sourceCode) {
-  if (annotation.type === import_utils19.AST_NODE_TYPES.TSTypeLiteral) return annotation.members;
-  if (annotation.type !== import_utils19.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils19.AST_NODE_TYPES.Identifier || annotation.typeArguments !== void 0) return [];
-  const variable = import_utils19.ASTUtils.findVariable(sourceCode.getScope(annotation.typeName), annotation.typeName.name);
+  if (annotation.type === import_utils18.AST_NODE_TYPES.TSTypeLiteral) return annotation.members;
+  if (annotation.type !== import_utils18.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils18.AST_NODE_TYPES.Identifier || annotation.typeArguments !== void 0) return [];
+  const variable = import_utils18.ASTUtils.findVariable(sourceCode.getScope(annotation.typeName), annotation.typeName.name);
   if (variable?.defs.length !== 1) return [];
   const definition = variable.defs[0]?.node;
   switch (definition?.type) {
-    case import_utils19.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils18.AST_NODE_TYPES.TSInterfaceDeclaration:
       return definition.extends.length === 0 && definition.typeParameters === void 0 ? definition.body.body : [];
-    case import_utils19.AST_NODE_TYPES.TSTypeAliasDeclaration:
-      return definition.typeParameters === void 0 && definition.typeAnnotation.type === import_utils19.AST_NODE_TYPES.TSTypeLiteral ? definition.typeAnnotation.members : [];
-    case import_utils19.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils18.AST_NODE_TYPES.TSTypeAliasDeclaration:
+      return definition.typeParameters === void 0 && definition.typeAnnotation.type === import_utils18.AST_NODE_TYPES.TSTypeLiteral ? definition.typeAnnotation.members : [];
+    case import_utils18.AST_NODE_TYPES.ClassDeclaration:
       return definition.superClass === null && definition.typeParameters === void 0 && definition.decorators.length === 0 ? definition.body.body : [];
     default:
       return [];
   }
 }
 function mutableField(member3) {
-  if (member3.type !== import_utils19.AST_NODE_TYPES.TSPropertySignature && member3.type !== import_utils19.AST_NODE_TYPES.PropertyDefinition || member3.readonly || member3.computed) return null;
-  if (member3.type === import_utils19.AST_NODE_TYPES.PropertyDefinition && (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")) return null;
-  if (member3.key.type === import_utils19.AST_NODE_TYPES.Identifier) return member3.key.name;
-  return member3.key.type === import_utils19.AST_NODE_TYPES.Literal && (typeof member3.key.value === "string" || typeof member3.key.value === "number") ? String(member3.key.value) : null;
+  if (member3.type !== import_utils18.AST_NODE_TYPES.TSPropertySignature && member3.type !== import_utils18.AST_NODE_TYPES.PropertyDefinition || member3.readonly || member3.computed) return null;
+  if (member3.type === import_utils18.AST_NODE_TYPES.PropertyDefinition && (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")) return null;
+  if (member3.key.type === import_utils18.AST_NODE_TYPES.Identifier) return member3.key.name;
+  return member3.key.type === import_utils18.AST_NODE_TYPES.Literal && (typeof member3.key.value === "string" || typeof member3.key.value === "number") ? String(member3.key.value) : null;
 }
 function walkBody(node, visit) {
-  if (node.type === import_utils19.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils19.AST_NODE_TYPES.FunctionExpression || node.type === import_utils19.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils19.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils19.AST_NODE_TYPES.ClassExpression) return;
+  if (node.type === import_utils18.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils18.AST_NODE_TYPES.FunctionExpression || node.type === import_utils18.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils18.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils18.AST_NODE_TYPES.ClassExpression) return;
   visit(node);
-  if (node.type === import_utils19.AST_NODE_TYPES.BlockStatement) {
+  if (node.type === import_utils18.AST_NODE_TYPES.BlockStatement) {
     for (const statement of node.body) {
       walkBody(statement, visit);
-      if (statement.type === import_utils19.AST_NODE_TYPES.ReturnStatement || statement.type === import_utils19.AST_NODE_TYPES.ThrowStatement) break;
+      if (statement.type === import_utils18.AST_NODE_TYPES.ReturnStatement || statement.type === import_utils18.AST_NODE_TYPES.ThrowStatement) break;
     }
     return;
   }
@@ -2297,15 +2518,15 @@ function walkBody(node, visit) {
   forEachOwnAstChild(node, (child) => walkBody(child, visit), (key) => key !== "typeAnnotation" && key !== "returnType");
 }
 function selectedChildren(node) {
-  if (node.type === import_utils19.AST_NODE_TYPES.IfStatement && node.test.type === import_utils19.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils18.AST_NODE_TYPES.IfStatement && node.test.type === import_utils18.AST_NODE_TYPES.Literal) {
     const branch = node.test.value ? node.consequent : node.alternate;
     return branch === null ? [node.test] : [node.test, branch];
   }
-  if (node.type === import_utils19.AST_NODE_TYPES.LogicalExpression && node.left.type === import_utils19.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils18.AST_NODE_TYPES.LogicalExpression && node.left.type === import_utils18.AST_NODE_TYPES.Literal) {
     const skips = node.operator === "&&" && !node.left.value || node.operator === "||" && !!node.left.value || node.operator === "??" && node.left.value !== null;
     return skips ? [node.left] : [node.left, node.right];
   }
-  if (node.type === import_utils19.AST_NODE_TYPES.ConditionalExpression && node.test.type === import_utils19.AST_NODE_TYPES.Literal) return [node.test, node.test.value ? node.consequent : node.alternate];
+  if (node.type === import_utils18.AST_NODE_TYPES.ConditionalExpression && node.test.type === import_utils18.AST_NODE_TYPES.Literal) return [node.test, node.test.value ? node.consequent : node.alternate];
   return null;
 }
 var no_mutating_input_with_result_default = createRule({
@@ -2326,23 +2547,23 @@ var no_mutating_input_with_result_default = createRule({
       if (annotation === void 0 || command(annotation) || node.body === void 0) return;
       const inputs = /* @__PURE__ */ new Map();
       for (const parameter of node.params) {
-        if (parameter.type !== import_utils19.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
-        const variable = import_utils19.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name);
+        if (parameter.type !== import_utils18.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
+        const variable = import_utils18.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name);
         if (variable === null || variable.references.some((reference) => reference.isWrite())) continue;
         const names = fields(parameter.typeAnnotation.typeAnnotation, sourceCode);
         if (names.size > 0) inputs.set(variable, names);
       }
       if (inputs.size === 0) return;
-      let returned2 = node.body.type !== import_utils19.AST_NODE_TYPES.BlockStatement;
+      let returned2 = node.body.type !== import_utils18.AST_NODE_TYPES.BlockStatement;
       const writes = [];
       walkBody(node.body, (current) => {
-        if (current.type === import_utils19.AST_NODE_TYPES.ReturnStatement && current.argument !== null) returned2 = true;
-        const candidate2 = current.type === import_utils19.AST_NODE_TYPES.AssignmentExpression ? current.left : current.type === import_utils19.AST_NODE_TYPES.UpdateExpression || current.type === import_utils19.AST_NODE_TYPES.UnaryExpression && current.operator === "delete" ? current.argument : null;
+        if (current.type === import_utils18.AST_NODE_TYPES.ReturnStatement && current.argument !== null) returned2 = true;
+        const candidate2 = current.type === import_utils18.AST_NODE_TYPES.AssignmentExpression ? current.left : current.type === import_utils18.AST_NODE_TYPES.UpdateExpression || current.type === import_utils18.AST_NODE_TYPES.UnaryExpression && current.operator === "delete" ? current.argument : null;
         if (candidate2 === null) return;
         const target = unwrapExpression(candidate2);
-        if (target.type !== import_utils19.AST_NODE_TYPES.MemberExpression || target.object.type !== import_utils19.AST_NODE_TYPES.Identifier) return;
-        const variable = import_utils19.ASTUtils.findVariable(sourceCode.getScope(target.object), target.object.name);
-        const property = import_utils19.ASTUtils.getPropertyName(target);
+        if (target.type !== import_utils18.AST_NODE_TYPES.MemberExpression || target.object.type !== import_utils18.AST_NODE_TYPES.Identifier) return;
+        const variable = import_utils18.ASTUtils.findVariable(sourceCode.getScope(target.object), target.object.name);
+        const property = import_utils18.ASTUtils.getPropertyName(target);
         if (variable !== null && property !== null && inputs.get(variable)?.has(property)) writes.push({ node: target, name: target.object.name });
       });
       const first = writes[0];
@@ -2353,26 +2574,26 @@ var no_mutating_input_with_result_default = createRule({
 });
 
 // src/rules/no-negative-only-http-status-assertion.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 
 // src/rules/_native-fetch-reference.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 
 // src/rules/_native-runtime-unchanged.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 
 // src/rules/_static-string.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 function staticString(node) {
   if (node === void 0) return null;
   const value = unwrapExpression(node);
-  if (value.type === import_utils20.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
-  return value.type === import_utils20.AST_NODE_TYPES.TemplateLiteral && value.expressions.length === 0 ? value.quasis[0]?.value.cooked ?? null : null;
+  if (value.type === import_utils19.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
+  return value.type === import_utils19.AST_NODE_TYPES.TemplateLiteral && value.expressions.length === 0 ? value.quasis[0]?.value.cooked ?? null : null;
 }
 var SCOPED_STRING_VALUES = /* @__PURE__ */ new WeakMap();
 function scopedStaticString(node, sourceCode) {
   let value = unwrapExpression(node);
-  if (value.type !== import_utils20.AST_NODE_TYPES.Identifier) return staticString(value);
+  if (value.type !== import_utils19.AST_NODE_TYPES.Identifier) return staticString(value);
   let values = SCOPED_STRING_VALUES.get(sourceCode);
   if (values === void 0) {
     values = /* @__PURE__ */ new WeakMap();
@@ -2381,8 +2602,8 @@ function scopedStaticString(node, sourceCode) {
   const seen = /* @__PURE__ */ new Set();
   const pending = [];
   let result = null;
-  while (value.type === import_utils20.AST_NODE_TYPES.Identifier) {
-    const binding3 = import_utils20.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+  while (value.type === import_utils19.AST_NODE_TYPES.Identifier) {
+    const binding3 = import_utils19.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
     if (binding3 === null || seen.has(binding3)) break;
     if (values.has(binding3)) {
       result = values.get(binding3) ?? null;
@@ -2391,17 +2612,17 @@ function scopedStaticString(node, sourceCode) {
     seen.add(binding3);
     pending.push(binding3);
     const definition = binding3.defs.length === 1 ? binding3.defs[0] : void 0;
-    if (definition?.type !== "Variable" || definition.node.id.type !== import_utils20.AST_NODE_TYPES.Identifier || definition.node.init === null || binding3.references.some((reference) => reference.isWrite() && reference.init !== true)) break;
+    if (definition?.type !== "Variable" || definition.node.id.type !== import_utils19.AST_NODE_TYPES.Identifier || definition.node.init === null || binding3.references.some((reference) => reference.isWrite() && reference.init !== true)) break;
     value = unwrapExpression(definition.node.init);
-    if (value.type !== import_utils20.AST_NODE_TYPES.Identifier) result = staticString(value);
+    if (value.type !== import_utils19.AST_NODE_TYPES.Identifier) result = staticString(value);
   }
   for (const binding3 of pending) values.set(binding3, result);
   return result;
 }
 function staticPropertyName(node, sourceCode) {
-  const direct = import_utils20.ASTUtils.getPropertyName(node);
+  const direct = import_utils19.ASTUtils.getPropertyName(node);
   if (direct !== null || !node.computed) return direct;
-  const key = node.type === import_utils20.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
+  const key = node.type === import_utils19.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
   return scopedStaticString(key, sourceCode);
 }
 
@@ -2412,7 +2633,7 @@ function nativeRuntimeUnchanged(sourceCode, name) {
   const index = runtimeIndex(sourceCode);
   const cached = index.results.get(name);
   if (cached !== void 0) return cached;
-  const changed = index.nodes.some((node) => node.type === import_utils21.AST_NODE_TYPES.MemberExpression && staticPropertyName(node, sourceCode) === "constructor" || name === "fetch" && node.type === import_utils21.AST_NODE_TYPES.Property && node.parent.type === import_utils21.AST_NODE_TYPES.ObjectPattern && staticPropertyName(node, sourceCode) === "constructor" || name === "RegExp" && node.type === import_utils21.AST_NODE_TYPES.Literal && "regex" in node) || index.references.some((reference) => (name !== "fetch" || !typeOnlyReference(reference)) && unsafeReference(reference.identifier, sourceCode, name, index));
+  const changed = index.nodes.some((node) => node.type === import_utils20.AST_NODE_TYPES.MemberExpression && staticPropertyName(node, sourceCode) === "constructor" || name === "fetch" && node.type === import_utils20.AST_NODE_TYPES.Property && node.parent.type === import_utils20.AST_NODE_TYPES.ObjectPattern && staticPropertyName(node, sourceCode) === "constructor" || name === "RegExp" && node.type === import_utils20.AST_NODE_TYPES.Literal && "regex" in node) || index.references.some((reference) => (name !== "fetch" || !typeOnlyReference(reference)) && unsafeReference(reference.identifier, sourceCode, name, index));
   index.results.set(name, !changed);
   return !changed;
 }
@@ -2441,8 +2662,8 @@ function unsafeReference(node, sourceCode, name, index) {
   if (!GLOBAL_OBJECTS.has(node.name)) return false;
   const value = outerExpression(node);
   const property = value.parent;
-  if (name === "fetch" && property?.type === import_utils21.AST_NODE_TYPES.UnaryExpression && property.operator === "typeof") return false;
-  if (property?.type !== import_utils21.AST_NODE_TYPES.MemberExpression || property.object !== value) {
+  if (name === "fetch" && property?.type === import_utils20.AST_NODE_TYPES.UnaryExpression && property.operator === "typeof") return false;
+  if (property?.type !== import_utils20.AST_NODE_TYPES.MemberExpression || property.object !== value) {
     return name !== "fetch" || !fetchProjection(value, sourceCode, index);
   }
   const key = staticPropertyName(property, sourceCode);
@@ -2451,21 +2672,21 @@ function unsafeReference(node, sourceCode, name, index) {
   return key === name && !(name === "fetch" ? fetchRead(property, sourceCode, index) : nativeRead(property, name));
 }
 function ambient(node, sourceCode) {
-  const variable = import_utils21.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  const variable = import_utils20.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function fetchUse(node, sourceCode) {
   const value = outerExpression(node);
   const parent = value.parent;
-  if (parent?.type === import_utils21.AST_NODE_TYPES.CallExpression && parent.callee === value || parent?.type === import_utils21.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
-  if (parent?.type !== import_utils21.AST_NODE_TYPES.VariableDeclarator || parent.init !== value || parent.id.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+  if (parent?.type === import_utils20.AST_NODE_TYPES.CallExpression && parent.callee === value || parent?.type === import_utils20.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
+  if (parent?.type !== import_utils20.AST_NODE_TYPES.VariableDeclarator || parent.init !== value || parent.id.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
   return stableConstBinding(parent.id, sourceCode) ?? false;
 }
 function stableConstBinding(node, sourceCode) {
-  const binding3 = import_utils21.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  const binding3 = import_utils20.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
   if (binding3 === null || binding3.defs.length !== 1) return null;
   const [definition] = binding3.defs;
-  return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init !== null && definition.parent.parent.type !== import_utils21.AST_NODE_TYPES.ExportNamedDeclaration && !binding3.references.some((reference) => reference.isWrite() && reference.init !== true) ? binding3 : null;
+  return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init !== null && definition.parent.parent.type !== import_utils20.AST_NODE_TYPES.ExportNamedDeclaration && !binding3.references.some((reference) => reference.isWrite() && reference.init !== true) ? binding3 : null;
 }
 function fetchRead(node, sourceCode, index) {
   const use = fetchUse(node, sourceCode);
@@ -2508,18 +2729,18 @@ function fetchAliasCaptures(binding3, sourceCode) {
 }
 function fetchProjection(node, sourceCode, index) {
   const declaration = node.parent;
-  if (declaration?.type !== import_utils21.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils21.AST_NODE_TYPES.ObjectPattern || declaration.id.properties.length !== 1) return false;
+  if (declaration?.type !== import_utils20.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils20.AST_NODE_TYPES.ObjectPattern || declaration.id.properties.length !== 1) return false;
   const [property] = declaration.id.properties;
-  if (property?.type !== import_utils21.AST_NODE_TYPES.Property || staticPropertyName(property, sourceCode) !== "fetch" || property.value.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+  if (property?.type !== import_utils20.AST_NODE_TYPES.Property || staticPropertyName(property, sourceCode) !== "fetch" || property.value.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
   const binding3 = stableConstBinding(property.value, sourceCode);
   return binding3 !== null && fetchAliasRead(binding3, sourceCode, index);
 }
 function nativeRead(node, name) {
   const value = outerExpression(node);
   const parent = value.parent;
-  if (parent?.type === import_utils21.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
+  if (parent?.type === import_utils20.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
   if (name !== "Error") return false;
-  return parent?.type === import_utils21.AST_NODE_TYPES.NewExpression && parent.callee === value || parent?.type === import_utils21.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.right === value;
+  return parent?.type === import_utils20.AST_NODE_TYPES.NewExpression && parent.callee === value || parent?.type === import_utils20.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.right === value;
 }
 
 // src/rules/_native-fetch-reference.ts
@@ -2529,34 +2750,34 @@ function nativeFetchReference(node, sourceCode) {
 }
 function lexicalFetchReference(node, sourceCode, seen = /* @__PURE__ */ new Set()) {
   const expression = unwrapExpression(node);
-  if (expression.type === import_utils22.AST_NODE_TYPES.MemberExpression) {
+  if (expression.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
     return staticPropertyName(expression, sourceCode) === "fetch" && globalReceiver(expression.object, sourceCode);
   }
-  if (expression.type !== import_utils22.AST_NODE_TYPES.Identifier) return false;
-  const binding3 = import_utils22.ASTUtils.findVariable(sourceCode.getScope(expression), expression.name);
+  if (expression.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+  const binding3 = import_utils21.ASTUtils.findVariable(sourceCode.getScope(expression), expression.name);
   if (binding3 === null || binding3.defs.length === 0) return expression.name === "fetch";
   if (seen.has(binding3) || seen.size >= 8 || binding3.defs.length !== 1 || binding3.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
   seen.add(binding3);
   const [definition] = binding3.defs;
   if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null) return false;
-  if (definition.node.id.type === import_utils22.AST_NODE_TYPES.Identifier) {
+  if (definition.node.id.type === import_utils21.AST_NODE_TYPES.Identifier) {
     return lexicalFetchReference(definition.node.init, sourceCode, seen);
   }
-  return definition.node.id.type === import_utils22.AST_NODE_TYPES.ObjectPattern && globalReceiver(definition.node.init, sourceCode) && definition.node.id.properties.some((property) => property.type === import_utils22.AST_NODE_TYPES.Property && staticPropertyName(property, sourceCode) === "fetch" && property.value.type === import_utils22.AST_NODE_TYPES.Identifier && import_utils22.ASTUtils.findVariable(sourceCode.getScope(property.value), property.value.name) === binding3);
+  return definition.node.id.type === import_utils21.AST_NODE_TYPES.ObjectPattern && globalReceiver(definition.node.init, sourceCode) && definition.node.id.properties.some((property) => property.type === import_utils21.AST_NODE_TYPES.Property && staticPropertyName(property, sourceCode) === "fetch" && property.value.type === import_utils21.AST_NODE_TYPES.Identifier && import_utils21.ASTUtils.findVariable(sourceCode.getScope(property.value), property.value.name) === binding3);
 }
 function globalReceiver(node, sourceCode) {
   const receiver = unwrapExpression(node);
-  return receiver.type === import_utils22.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS2.has(receiver.name) && !import_utils22.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
+  return receiver.type === import_utils21.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS2.has(receiver.name) && !import_utils21.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
 }
 
 // src/rules/_test-mock-provenance.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 function importedTestMockNamespace(source, identifier) {
-  const binding3 = import_utils23.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils22.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   const importedBinding = runtimeImportBinding(binding3);
-  if (importedBinding === null || importedBinding.specifier.type !== import_utils23.AST_NODE_TYPES.ImportSpecifier) return null;
+  if (importedBinding === null || importedBinding.specifier.type !== import_utils22.AST_NODE_TYPES.ImportSpecifier) return null;
   const specifier = importedBinding.specifier;
-  const imported = specifier.imported.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+  const imported = specifier.imported.type === import_utils22.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
   const module2 = importedBinding.module;
   if (module2 === "vitest" && (imported === "vi" || imported === "vitest")) return "vitest";
   if (module2 === "@jest/globals" && imported === "jest") return "jest";
@@ -2564,12 +2785,12 @@ function importedTestMockNamespace(source, identifier) {
 }
 function isUnshadowedTestMockGlobal(source, identifier) {
   if (identifier.name !== "vi" && identifier.name !== "jest") return false;
-  const binding3 = import_utils23.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils22.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   return binding3 === null || binding3.defs.length === 0 && !binding3.references.some((reference) => reference.isWrite());
 }
 var TEST_FRAMEWORK_MODULES = /* @__PURE__ */ new Set(["@jest/globals", "@playwright/test", "bun:test", "node:test", "vitest"]);
 function runtimeTestFrameworkName(source, identifier, kind) {
-  const binding3 = import_utils23.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils22.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   if (binding3 === null || binding3.defs.length === 0) {
     return binding3?.references.some((reference) => reference.isWrite()) ? null : identifier.name;
   }
@@ -2577,22 +2798,22 @@ function runtimeTestFrameworkName(source, identifier, kind) {
   if (importedBinding === null) return null;
   const { specifier, module: module2 } = importedBinding;
   const isNodeAssertion = kind === "assertion" && (module2 === "node:assert" || module2 === "node:assert/strict");
-  if (specifier.type === import_utils23.AST_NODE_TYPES.ImportSpecifier) {
+  if (specifier.type === import_utils22.AST_NODE_TYPES.ImportSpecifier) {
     if (isNodeAssertion) return "assert";
     if (!TEST_FRAMEWORK_MODULES.has(module2)) return null;
-    const imported = specifier.imported.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+    const imported = specifier.imported.type === import_utils22.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
     return imported;
   }
   if (isNodeAssertion) return "assert";
-  return kind === "test" && module2 === "node:test" && specifier.type === import_utils23.AST_NODE_TYPES.ImportDefaultSpecifier ? "test" : null;
+  return kind === "test" && module2 === "node:test" && specifier.type === import_utils22.AST_NODE_TYPES.ImportDefaultSpecifier ? "test" : null;
 }
 function runtimeImportBinding(binding3) {
   if (binding3?.defs.length !== 1) return null;
   const definition = binding3.defs[0];
-  if (definition?.type !== "ImportBinding" || definition.parent.type !== import_utils23.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type") return null;
+  if (definition?.type !== "ImportBinding" || definition.parent.type !== import_utils22.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type") return null;
   const specifier = definition.node;
-  if (specifier.type !== import_utils23.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils23.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils23.AST_NODE_TYPES.ImportNamespaceSpecifier) return null;
-  if (specifier.type === import_utils23.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") return null;
+  if (specifier.type !== import_utils22.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils22.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils22.AST_NODE_TYPES.ImportNamespaceSpecifier) return null;
+  if (specifier.type === import_utils22.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") return null;
   return { module: definition.parent.source.value, specifier };
 }
 function vitestFixtureTestName(source, identifier) {
@@ -2600,24 +2821,24 @@ function vitestFixtureTestName(source, identifier) {
 }
 function fixtureTestName(node, source, seen) {
   node = unwrapExpression(node);
-  if (node.type === import_utils23.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils22.AST_NODE_TYPES.CallExpression) {
     const callee = unwrapExpression(node.callee);
-    return !node.optional && callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils23.ASTUtils.getPropertyName(callee) === "extend" && node.arguments.length > 0 && !node.arguments.some((argument) => argument.type === import_utils23.AST_NODE_TYPES.SpreadElement) ? fixtureTestName(callee.object, source, seen) : null;
+    return !node.optional && callee.type === import_utils22.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils22.ASTUtils.getPropertyName(callee) === "extend" && node.arguments.length > 0 && !node.arguments.some((argument) => argument.type === import_utils22.AST_NODE_TYPES.SpreadElement) ? fixtureTestName(callee.object, source, seen) : null;
   }
-  if (node.type !== import_utils23.AST_NODE_TYPES.Identifier) return null;
-  const binding3 = import_utils23.ASTUtils.findVariable(source.getScope(node), node.name);
+  if (node.type !== import_utils22.AST_NODE_TYPES.Identifier) return null;
+  const binding3 = import_utils22.ASTUtils.findVariable(source.getScope(node), node.name);
   if (binding3 === null || seen.has(binding3) || !unchangedFixtureApi(binding3)) return null;
   seen.add(binding3);
   const imported = runtimeImportBinding(binding3);
-  if (imported?.module === "vitest" && imported.specifier.type === import_utils23.AST_NODE_TYPES.ImportSpecifier) {
+  if (imported?.module === "vitest" && imported.specifier.type === import_utils22.AST_NODE_TYPES.ImportSpecifier) {
     const name = imported.specifier.imported;
-    const value = name.type === import_utils23.AST_NODE_TYPES.Identifier ? name.name : name.value;
+    const value = name.type === import_utils22.AST_NODE_TYPES.Identifier ? name.name : name.value;
     return value === "test" || value === "it" ? value : null;
   }
   const definition = binding3.defs[0];
-  if (binding3.defs.length !== 1 || definition?.node.type !== import_utils23.AST_NODE_TYPES.VariableDeclarator || definition.node.id.type !== import_utils23.AST_NODE_TYPES.Identifier || definition.node.parent.kind !== "const" || definition.node.init === null || definition.node.init.range[1] > node.range[0]) return null;
+  if (binding3.defs.length !== 1 || definition?.node.type !== import_utils22.AST_NODE_TYPES.VariableDeclarator || definition.node.id.type !== import_utils22.AST_NODE_TYPES.Identifier || definition.node.parent.kind !== "const" || definition.node.init === null || definition.node.init.range[1] > node.range[0]) return null;
   const initializer = unwrapExpression(definition.node.init);
-  return initializer.type === import_utils23.AST_NODE_TYPES.CallExpression ? fixtureTestName(initializer, source, seen) : null;
+  return initializer.type === import_utils22.AST_NODE_TYPES.CallExpression ? fixtureTestName(initializer, source, seen) : null;
 }
 var FIXTURE_API_STABILITY = /* @__PURE__ */ new WeakMap();
 function unchangedFixtureApi(binding3) {
@@ -2627,9 +2848,9 @@ function unchangedFixtureApi(binding3) {
     if (reference.isWrite()) return reference.init === true;
     if (reference.isTypeReference && !reference.isValueReference) return true;
     let use = outerExpression(reference.identifier);
-    while (use.parent?.type === import_utils23.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = outerExpression(use.parent);
+    while (use.parent?.type === import_utils22.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = outerExpression(use.parent);
     const parent = use.parent;
-    return parent?.type === import_utils23.AST_NODE_TYPES.CallExpression && parent.callee === use || parent?.type === import_utils23.AST_NODE_TYPES.ExportSpecifier || parent?.type === import_utils23.AST_NODE_TYPES.ExportDefaultDeclaration || parent?.type === import_utils23.AST_NODE_TYPES.TSTypeQuery || parent?.type === import_utils23.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof";
+    return parent?.type === import_utils22.AST_NODE_TYPES.CallExpression && parent.callee === use || parent?.type === import_utils22.AST_NODE_TYPES.ExportSpecifier || parent?.type === import_utils22.AST_NODE_TYPES.ExportDefaultDeclaration || parent?.type === import_utils22.AST_NODE_TYPES.TSTypeQuery || parent?.type === import_utils22.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof";
   });
   FIXTURE_API_STABILITY.set(binding3, unchanged);
   return unchanged;
@@ -2659,72 +2880,72 @@ var NO_NEGATIVE_ONLY_HTTP_STATUS_ASSERTION_DOCUMENTATION = {
   ]
 };
 function statusAssertion(source, call) {
-  if (call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils24.AST_NODE_TYPES.Literal || typeof call.arguments[0].value !== "number" || call.callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression) return null;
-  const matcher = import_utils24.ASTUtils.getPropertyName(call.callee);
+  if (call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils23.AST_NODE_TYPES.Literal || typeof call.arguments[0].value !== "number" || call.callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) return null;
+  const matcher = import_utils23.ASTUtils.getPropertyName(call.callee);
   if (matcher === null) return null;
   let object = unwrapExpression(call.callee.object);
-  const negative = object.type === import_utils24.AST_NODE_TYPES.MemberExpression && import_utils24.ASTUtils.getPropertyName(object) === "not";
-  if (negative && object.type === import_utils24.AST_NODE_TYPES.MemberExpression) object = unwrapExpression(object.object);
-  if (object.type !== import_utils24.AST_NODE_TYPES.CallExpression || object.arguments.length !== 1 || object.callee.type !== import_utils24.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(source, object.callee, "assertion") !== "expect") return null;
+  const negative = object.type === import_utils23.AST_NODE_TYPES.MemberExpression && import_utils23.ASTUtils.getPropertyName(object) === "not";
+  if (negative && object.type === import_utils23.AST_NODE_TYPES.MemberExpression) object = unwrapExpression(object.object);
+  if (object.type !== import_utils23.AST_NODE_TYPES.CallExpression || object.arguments.length !== 1 || object.callee.type !== import_utils23.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(source, object.callee, "assertion") !== "expect") return null;
   const argument = object.arguments[0];
-  const response = argument === void 0 || argument.type === import_utils24.AST_NODE_TYPES.SpreadElement ? null : fetchResponse(source, argument);
+  const response = argument === void 0 || argument.type === import_utils23.AST_NODE_TYPES.SpreadElement ? null : fetchResponse(source, argument);
   return response === null ? null : { response, expected: call.arguments[0].value, matcher, negative };
 }
 function fetchResponse(source, value) {
   const node = unwrapExpression(value);
-  if (node.type !== import_utils24.AST_NODE_TYPES.MemberExpression || import_utils24.ASTUtils.getPropertyName(node) !== "status" || node.object.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
+  if (node.type !== import_utils23.AST_NODE_TYPES.MemberExpression || import_utils23.ASTUtils.getPropertyName(node) !== "status" || node.object.type !== import_utils23.AST_NODE_TYPES.Identifier) return null;
   return responseBinding(source, node.object);
 }
 function responseBinding(source, node, seen = /* @__PURE__ */ new Set()) {
-  const variable = import_utils24.ASTUtils.findVariable(source.getScope(node), node.name);
+  const variable = import_utils23.ASTUtils.findVariable(source.getScope(node), node.name);
   const definition = variable?.defs[0]?.node;
   if (variable?.defs.length !== 1 || seen.has(variable) || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
   seen.add(variable);
   const parameter = variable.defs[0];
-  if (parameter?.type === "Parameter" && parameter.name.type === import_utils24.AST_NODE_TYPES.Identifier) {
+  if (parameter?.type === "Parameter" && parameter.name.type === import_utils23.AST_NODE_TYPES.Identifier) {
     const annotation = parameter.name.typeAnnotation?.typeAnnotation;
-    return annotation?.type === import_utils24.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Response" && (import_utils24.ASTUtils.findVariable(source.getScope(annotation.typeName), "Response")?.defs.length ?? 0) === 0 ? variable : null;
+    return annotation?.type === import_utils23.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils23.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Response" && (import_utils23.ASTUtils.findVariable(source.getScope(annotation.typeName), "Response")?.defs.length ?? 0) === 0 ? variable : null;
   }
-  if (definition?.type !== import_utils24.AST_NODE_TYPES.VariableDeclarator || definition.parent.kind !== "const" || definition.init === null) return null;
+  if (definition?.type !== import_utils23.AST_NODE_TYPES.VariableDeclarator || definition.parent.kind !== "const" || definition.init === null) return null;
   let initial = unwrapExpression(definition.init);
-  if (initial.type === import_utils24.AST_NODE_TYPES.AwaitExpression) initial = unwrapExpression(initial.argument);
-  if (initial.type === import_utils24.AST_NODE_TYPES.Identifier) return responseBinding(source, initial, seen);
+  if (initial.type === import_utils23.AST_NODE_TYPES.AwaitExpression) initial = unwrapExpression(initial.argument);
+  if (initial.type === import_utils23.AST_NODE_TYPES.Identifier) return responseBinding(source, initial, seen);
   return nativeResponse(initial, source) ? variable : null;
 }
 function nativeResponse(initial, source) {
-  if (initial.type === import_utils24.AST_NODE_TYPES.NewExpression && initial.callee.type === import_utils24.AST_NODE_TYPES.Identifier && initial.callee.name === "Response" && (import_utils24.ASTUtils.findVariable(source.getScope(initial.callee), "Response")?.defs.length ?? 0) === 0) return true;
-  if (initial.type === import_utils24.AST_NODE_TYPES.CallExpression && nativeFetchReference(initial.callee, source)) return true;
-  if (initial.type !== import_utils24.AST_NODE_TYPES.CallExpression || initial.callee.type !== import_utils24.AST_NODE_TYPES.Identifier) return false;
+  if (initial.type === import_utils23.AST_NODE_TYPES.NewExpression && initial.callee.type === import_utils23.AST_NODE_TYPES.Identifier && initial.callee.name === "Response" && (import_utils23.ASTUtils.findVariable(source.getScope(initial.callee), "Response")?.defs.length ?? 0) === 0) return true;
+  if (initial.type === import_utils23.AST_NODE_TYPES.CallExpression && nativeFetchReference(initial.callee, source)) return true;
+  if (initial.type !== import_utils23.AST_NODE_TYPES.CallExpression || initial.callee.type !== import_utils23.AST_NODE_TYPES.Identifier) return false;
   const callee = initial.callee;
-  const binding3 = import_utils24.ASTUtils.findVariable(source.getScope(callee), callee.name);
+  const binding3 = import_utils23.ASTUtils.findVariable(source.getScope(callee), callee.name);
   if ((binding3?.defs.length ?? 0) === 0) return callee.name === "fetch";
   const imported = binding3?.defs[0];
-  if (binding3?.defs.length !== 1 || imported?.type !== "ImportBinding" || imported.parent.type !== import_utils24.AST_NODE_TYPES.ImportDeclaration || imported.parent.importKind === "type" || !FETCH_MODULES.has(imported.parent.source.value)) return false;
+  if (binding3?.defs.length !== 1 || imported?.type !== "ImportBinding" || imported.parent.type !== import_utils23.AST_NODE_TYPES.ImportDeclaration || imported.parent.importKind === "type" || !FETCH_MODULES.has(imported.parent.source.value)) return false;
   const specifier = imported.node;
-  if (specifier.type === import_utils24.AST_NODE_TYPES.ImportDefaultSpecifier) return imported.parent.source.value === "node-fetch";
-  if (specifier.type !== import_utils24.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type") return false;
-  const importedName7 = specifier.imported.type === import_utils24.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+  if (specifier.type === import_utils23.AST_NODE_TYPES.ImportDefaultSpecifier) return imported.parent.source.value === "node-fetch";
+  if (specifier.type !== import_utils23.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type") return false;
+  const importedName7 = specifier.imported.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
   return importedName7 === "fetch";
 }
 function enclosingTest(source, node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (current.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration) return null;
-    if (current.type !== import_utils24.AST_NODE_TYPES.ArrowFunctionExpression && current.type !== import_utils24.AST_NODE_TYPES.FunctionExpression) continue;
+    if (current.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration) return null;
+    if (current.type !== import_utils23.AST_NODE_TYPES.ArrowFunctionExpression && current.type !== import_utils23.AST_NODE_TYPES.FunctionExpression) continue;
     const registration2 = directArgumentCall(current);
     const callee = registration2?.callee;
-    if (callee?.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
+    if (callee?.type !== import_utils23.AST_NODE_TYPES.Identifier) return null;
     const name = runtimeTestFrameworkName(source, callee, "test") ?? vitestFixtureTestName(source, callee);
     return name === "test" || name === "it" ? current : null;
   }
   return null;
 }
 function hasExactStatus(source, test, response) {
-  if (test.body.type !== import_utils24.AST_NODE_TYPES.BlockStatement) return false;
+  if (test.body.type !== import_utils23.AST_NODE_TYPES.BlockStatement) return false;
   return test.body.body.some((statement) => {
-    if (statement.type !== import_utils24.AST_NODE_TYPES.ExpressionStatement) return false;
+    if (statement.type !== import_utils23.AST_NODE_TYPES.ExpressionStatement) return false;
     let expression = unwrapExpression(statement.expression);
-    if (expression.type === import_utils24.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
-    if (expression.type !== import_utils24.AST_NODE_TYPES.CallExpression) return false;
+    if (expression.type === import_utils23.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
+    if (expression.type !== import_utils23.AST_NODE_TYPES.CallExpression) return false;
     const assertion = statusAssertion(source, expression);
     return assertion !== null && assertion.response === response && !assertion.negative && EXACT_MATCHERS.has(assertion.matcher) && Number.isInteger(assertion.expected) && assertion.expected >= HTTP_STATUS_MIN && assertion.expected <= SERVER_ERROR_MAX;
   });
@@ -2755,7 +2976,7 @@ var no_negative_only_http_status_assertion_default = createRule({
 });
 
 // src/rules/prefer-test-fixture-reuse.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var MAX_DEPTH = 8;
 var FRAMEWORKS = /* @__PURE__ */ new Set(["vitest", "@playwright/test"]);
 var TEST_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "concurrent", "sequential"]);
@@ -2777,24 +2998,24 @@ var PREFER_TEST_FIXTURE_REUSE_DOCUMENTATION = {
   ]
 };
 function stableBinding(source, identifier) {
-  const variable = import_utils25.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const variable = import_utils24.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   if (variable?.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
   return variable;
 }
 function constructorBinding(source, node, depth = 0) {
   node = unwrapExpression(node);
-  if (node.type !== import_utils25.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
+  if (node.type !== import_utils24.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
   const variable = stableBinding(source, node);
   const definition = variable?.defs[0];
   if (variable === null || definition === void 0) return null;
   if (definition.type === "ClassName") return variable;
-  if (definition.type === "ImportBinding" && definition.parent.type === import_utils25.AST_NODE_TYPES.ImportDeclaration && definition.parent.importKind !== "type" && (definition.node.type !== import_utils25.AST_NODE_TYPES.ImportSpecifier || definition.node.importKind !== "type")) return variable;
-  if (definition.node.type === import_utils25.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < node.range[0]) return constructorBinding(source, definition.node.init, depth + 1);
+  if (definition.type === "ImportBinding" && definition.parent.type === import_utils24.AST_NODE_TYPES.ImportDeclaration && definition.parent.importKind !== "type" && (definition.node.type !== import_utils24.AST_NODE_TYPES.ImportSpecifier || definition.node.importKind !== "type")) return variable;
+  if (definition.node.type === import_utils24.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < node.range[0]) return constructorBinding(source, definition.node.init, depth + 1);
   return null;
 }
 function fixtureApi(source, expression, depth = 0) {
   const node = unwrapExpression(expression);
-  if (node.type !== import_utils25.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
+  if (node.type !== import_utils24.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
   const variable = stableBinding(source, node);
   const definition = variable?.defs[0];
   if (variable === null || definition === void 0) return null;
@@ -2806,35 +3027,35 @@ function fixtureApi(source, expression, depth = 0) {
 }
 function importedFixtureApi(variable) {
   const definition = variable.defs[0];
-  if (definition?.type === "ImportBinding" && definition.parent.type === import_utils25.AST_NODE_TYPES.ImportDeclaration && FRAMEWORKS.has(definition.parent.source.value) && definition.parent.importKind !== "type" && definition.node.type === import_utils25.AST_NODE_TYPES.ImportSpecifier && definition.node.importKind !== "type") {
+  if (definition?.type === "ImportBinding" && definition.parent.type === import_utils24.AST_NODE_TYPES.ImportDeclaration && FRAMEWORKS.has(definition.parent.source.value) && definition.parent.importKind !== "type" && definition.node.type === import_utils24.AST_NODE_TYPES.ImportSpecifier && definition.node.importKind !== "type") {
     const imported = definition.node.imported;
-    const name = imported.type === import_utils25.AST_NODE_TYPES.Identifier ? imported.name : imported.value;
+    const name = imported.type === import_utils24.AST_NODE_TYPES.Identifier ? imported.name : imported.value;
     return name === "test" || name === "it";
   }
   return false;
 }
 function fixtureExtension(declaration, before) {
-  if (declaration.type !== import_utils25.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= before) return null;
+  if (declaration.type !== import_utils24.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= before) return null;
   const initial = unwrapExpression(declaration.init);
-  if (initial.type !== import_utils25.AST_NODE_TYPES.CallExpression || initial.optional || initial.arguments.length !== 1 || initial.callee.type !== import_utils25.AST_NODE_TYPES.MemberExpression || initial.callee.optional || import_utils25.ASTUtils.getPropertyName(initial.callee) !== "extend") return null;
+  if (initial.type !== import_utils24.AST_NODE_TYPES.CallExpression || initial.optional || initial.arguments.length !== 1 || initial.callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression || initial.callee.optional || import_utils24.ASTUtils.getPropertyName(initial.callee) !== "extend") return null;
   const declarations = initial.arguments[0];
-  if (declarations?.type !== import_utils25.AST_NODE_TYPES.ObjectExpression || declarations.properties.some((property) => property.type !== import_utils25.AST_NODE_TYPES.Property || property.computed || property.kind !== "init")) return null;
+  if (declarations?.type !== import_utils24.AST_NODE_TYPES.ObjectExpression || declarations.properties.some((property) => property.type !== import_utils24.AST_NODE_TYPES.Property || property.computed || property.kind !== "init")) return null;
   return { receiver: initial.callee.object, declarations };
 }
 function fixtureApiStable(variable) {
   return !variable.references.some((reference) => {
     if (reference.isWrite() || reference.isTypeReference && !reference.isValueReference) return false;
     let use = reference.identifier;
-    while (use.parent?.type === import_utils25.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = use.parent;
-    return use.parent?.type !== import_utils25.AST_NODE_TYPES.CallExpression || use.parent.callee !== use;
+    while (use.parent?.type === import_utils24.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = use.parent;
+    return use.parent?.type !== import_utils24.AST_NODE_TYPES.CallExpression || use.parent.callee !== use;
   });
 }
 function fixtureConstructors(source, declarations, inherited) {
   const result = new Map(inherited);
   for (const property of declarations.properties) {
-    if (property.type !== import_utils25.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils25.AST_NODE_TYPES.AssignmentPattern) continue;
-    const name = import_utils25.ASTUtils.getPropertyName(property);
-    if (name === null || property.value.type === import_utils25.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) continue;
+    if (property.type !== import_utils24.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils24.AST_NODE_TYPES.AssignmentPattern) continue;
+    const name = import_utils24.ASTUtils.getPropertyName(property);
+    if (name === null || property.value.type === import_utils24.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) continue;
     const constructor = fixtureConstructor(source, property.value);
     if (constructor === null) result.delete(name);
     else result.set(name, constructor);
@@ -2843,24 +3064,24 @@ function fixtureConstructors(source, declarations, inherited) {
 }
 function fixtureConstructor(source, value) {
   value = unwrapExpression(value);
-  if (value.type !== import_utils25.AST_NODE_TYPES.ArrowFunctionExpression && value.type !== import_utils25.AST_NODE_TYPES.FunctionExpression) return newConstructor(source, value);
+  if (value.type !== import_utils24.AST_NODE_TYPES.ArrowFunctionExpression && value.type !== import_utils24.AST_NODE_TYPES.FunctionExpression) return newConstructor(source, value);
   const use = value.params[1];
-  if (use?.type !== import_utils25.AST_NODE_TYPES.Identifier) return null;
+  if (use?.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
   const binding3 = stableBinding(source, use);
-  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils25.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 1 && node.callee.type === import_utils25.AST_NODE_TYPES.Identifier && stableBinding(source, node.callee) === binding3);
+  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils24.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 1 && node.callee.type === import_utils24.AST_NODE_TYPES.Identifier && stableBinding(source, node.callee) === binding3);
   if (calls.length !== 1 || binding3 === null) return null;
   const argument = calls[0]?.arguments[0];
-  return argument === void 0 || argument.type === import_utils25.AST_NODE_TYPES.SpreadElement ? null : newConstructor(source, argument);
+  return argument === void 0 || argument.type === import_utils24.AST_NODE_TYPES.SpreadElement ? null : newConstructor(source, argument);
 }
 function newConstructor(source, expression) {
   const value = unwrapExpression(expression);
-  if (value.type === import_utils25.AST_NODE_TYPES.NewExpression) return constructorBinding(source, value.callee);
-  if (value.type !== import_utils25.AST_NODE_TYPES.Identifier) return null;
+  if (value.type === import_utils24.AST_NODE_TYPES.NewExpression) return constructorBinding(source, value.callee);
+  if (value.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
   const variable = stableBinding(source, value);
   const declaration = variable?.defs[0]?.node;
-  if (declaration?.type !== import_utils25.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= value.range[0]) return null;
+  if (declaration?.type !== import_utils24.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= value.range[0]) return null;
   const initial = unwrapExpression(declaration.init);
-  return initial.type === import_utils25.AST_NODE_TYPES.NewExpression ? constructorBinding(source, initial.callee) : null;
+  return initial.type === import_utils24.AST_NODE_TYPES.NewExpression ? constructorBinding(source, initial.callee) : null;
 }
 function scopeNodes(root, source) {
   const result = [];
@@ -2869,7 +3090,7 @@ function scopeNodes(root, source) {
     const node = pending.pop();
     if (node === void 0) continue;
     result.push(node);
-    if (node !== root && (node.type === import_utils25.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils25.AST_NODE_TYPES.FunctionExpression || node.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils25.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils25.AST_NODE_TYPES.ClassExpression)) continue;
+    if (node !== root && (node.type === import_utils24.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils24.AST_NODE_TYPES.FunctionExpression || node.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils24.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils24.AST_NODE_TYPES.ClassExpression)) continue;
     for (const key of source.visitorKeys[node.type] ?? []) {
       const value = Reflect.get(node, key);
       if (Array.isArray(value)) pending.push(...value.filter(isNode2));
@@ -2883,13 +3104,13 @@ function isNode2(value) {
 }
 function testApiCallee(expression) {
   let node = unwrapExpression(expression);
-  while (node.type === import_utils25.AST_NODE_TYPES.MemberExpression && !node.optional && TEST_MODIFIERS.has(import_utils25.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
+  while (node.type === import_utils24.AST_NODE_TYPES.MemberExpression && !node.optional && TEST_MODIFIERS.has(import_utils24.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
   return node;
 }
 function requestingFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (current.type === import_utils25.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils25.AST_NODE_TYPES.FunctionExpression) return current;
-    if (current.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration) return null;
+    if (current.type === import_utils24.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils24.AST_NODE_TYPES.FunctionExpression) return current;
+    if (current.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration) return null;
   }
   return null;
 }
@@ -2911,13 +3132,13 @@ var prefer_test_fixture_reuse_default = createRule({
         const call = functionNode === null ? null : directArgumentCall(functionNode);
         if (functionNode === null || call === null) return;
         const parameter = functionNode.params[0];
-        if (parameter?.type !== import_utils25.AST_NODE_TYPES.ObjectPattern) return;
+        if (parameter?.type !== import_utils24.AST_NODE_TYPES.ObjectPattern) return;
         const entries = fixtureApi(context.sourceCode, testApiCallee(call.callee));
         const constructor = constructorBinding(context.sourceCode, node.callee);
         if (entries === null || constructor === null) return;
         for (const property of parameter.properties) {
-          if (property.type !== import_utils25.AST_NODE_TYPES.Property || property.computed) continue;
-          const name = import_utils25.ASTUtils.getPropertyName(property);
+          if (property.type !== import_utils24.AST_NODE_TYPES.Property || property.computed) continue;
+          const name = import_utils24.ASTUtils.getPropertyName(property);
           if (name !== null && entries.get(name) === constructor) {
             context.report({ node, messageId: "reuseFixture", data: { fixture: name } });
             return;
@@ -2929,7 +3150,7 @@ var prefer_test_fixture_reuse_default = createRule({
 });
 
 // src/rules/no-return-disposed-resource.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var NO_RETURN_DISPOSED_RESOURCE_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Do not return a resource whose using declaration disposes it before the caller receives it.",
@@ -2949,16 +3170,16 @@ var NO_RETURN_DISPOSED_RESOURCE_DOCUMENTATION = {
 };
 function owningFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (current.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils26.AST_NODE_TYPES.FunctionExpression || current.type === import_utils26.AST_NODE_TYPES.ArrowFunctionExpression) return current;
+    if (current.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils25.AST_NODE_TYPES.FunctionExpression || current.type === import_utils25.AST_NODE_TYPES.ArrowFunctionExpression) return current;
   }
   return null;
 }
 function resourceOwner(source, value, seen = /* @__PURE__ */ new Set()) {
   const node = unwrapExpression(value);
-  if (node.type !== import_utils26.AST_NODE_TYPES.Identifier) return null;
-  const variable = import_utils26.ASTUtils.findVariable(source.getScope(node), node.name);
+  if (node.type !== import_utils25.AST_NODE_TYPES.Identifier) return null;
+  const variable = import_utils25.ASTUtils.findVariable(source.getScope(node), node.name);
   const definition = variable?.defs[0];
-  if (variable === null || variable?.defs.length !== 1 || definition === void 0 || seen.has(variable) || variable.references.some((reference) => reference.isWrite() && !reference.init) || definition.node.type !== import_utils26.AST_NODE_TYPES.VariableDeclarator) return null;
+  if (variable === null || variable?.defs.length !== 1 || definition === void 0 || seen.has(variable) || variable.references.some((reference) => reference.isWrite() && !reference.init) || definition.node.type !== import_utils25.AST_NODE_TYPES.VariableDeclarator) return null;
   const declaration = definition.node;
   if (declaration.parent.kind === "using" || declaration.parent.kind === "await using") return declaration;
   if (declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= node.range[0]) return null;
@@ -2987,7 +3208,7 @@ var no_return_disposed_resource_default = createRule({
 });
 
 // src/rules/require-jwt-lifetime.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var REQUIRE_JWT_LIFETIME_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Require an expiration claim or a maximum token age when returning a verified JWT.",
@@ -3015,36 +3236,36 @@ var require_jwt_lifetime_default = createRule({
     function inspect(input) {
       if (input === null) return;
       let node = unwrapExpression(input);
-      if (node.type === import_utils27.AST_NODE_TYPES.AwaitExpression) node = unwrapExpression(node.argument);
-      if (node.type !== import_utils27.AST_NODE_TYPES.CallExpression || !isVerifier(node.callee)) return;
+      if (node.type === import_utils26.AST_NODE_TYPES.AwaitExpression) node = unwrapExpression(node.argument);
+      if (node.type !== import_utils26.AST_NODE_TYPES.CallExpression || !isVerifier(node.callee)) return;
       if (!missingLifetime(node.arguments[2])) return;
       context.report({ node, messageId: "lifetime" });
     }
     function isVerifier(node) {
       node = unwrapExpression(node);
-      if (node.type === import_utils27.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils27.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type === import_utils26.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils26.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
         const declaration = variable?.defs[0]?.node;
-        return variable?.defs.length === 1 && declaration?.type === import_utils27.AST_NODE_TYPES.ImportSpecifier && declaration.parent.type === import_utils27.AST_NODE_TYPES.ImportDeclaration && declaration.importKind !== "type" && declaration.parent.importKind !== "type" && declaration.parent.source.value === "jose" && declaration.imported.type === import_utils27.AST_NODE_TYPES.Identifier && declaration.imported.name === "jwtVerify";
+        return variable?.defs.length === 1 && declaration?.type === import_utils26.AST_NODE_TYPES.ImportSpecifier && declaration.parent.type === import_utils26.AST_NODE_TYPES.ImportDeclaration && declaration.importKind !== "type" && declaration.parent.importKind !== "type" && declaration.parent.source.value === "jose" && declaration.imported.type === import_utils26.AST_NODE_TYPES.Identifier && declaration.imported.name === "jwtVerify";
       }
-      if (node.type !== import_utils27.AST_NODE_TYPES.MemberExpression || import_utils27.ASTUtils.getPropertyName(node) !== "jwtVerify" || node.object.type !== import_utils27.AST_NODE_TYPES.Identifier) return false;
-      const definition = import_utils27.ASTUtils.findVariable(sourceCode.getScope(node.object), node.object.name)?.defs[0]?.node;
-      return definition?.type === import_utils27.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && definition.parent.source.value === "jose";
+      if (node.type !== import_utils26.AST_NODE_TYPES.MemberExpression || import_utils26.ASTUtils.getPropertyName(node) !== "jwtVerify" || node.object.type !== import_utils26.AST_NODE_TYPES.Identifier) return false;
+      const definition = import_utils26.ASTUtils.findVariable(sourceCode.getScope(node.object), node.object.name)?.defs[0]?.node;
+      return definition?.type === import_utils26.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && definition.parent.source.value === "jose";
     }
     function missingLifetime(options) {
       if (options === void 0) return true;
-      if (options.type !== import_utils27.AST_NODE_TYPES.ObjectExpression || options.properties.some((property) => property.type !== import_utils27.AST_NODE_TYPES.Property || property.computed)) return false;
-      return !options.properties.some((property) => property.type === import_utils27.AST_NODE_TYPES.Property && lifetimeProperty(property));
+      if (options.type !== import_utils26.AST_NODE_TYPES.ObjectExpression || options.properties.some((property) => property.type !== import_utils26.AST_NODE_TYPES.Property || property.computed)) return false;
+      return !options.properties.some((property) => property.type === import_utils26.AST_NODE_TYPES.Property && lifetimeProperty(property));
     }
     function lifetimeProperty(property) {
-      const name = property.key.type === import_utils27.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils27.AST_NODE_TYPES.Literal ? property.key.value : null;
+      const name = property.key.type === import_utils26.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils26.AST_NODE_TYPES.Literal ? property.key.value : null;
       if (name === "maxTokenAge") {
-        if (property.value.type !== import_utils27.AST_NODE_TYPES.Literal) return true;
+        if (property.value.type !== import_utils26.AST_NODE_TYPES.Literal) return true;
         return typeof property.value.value === "number" && Number.isFinite(property.value.value) || typeof property.value.value === "string" && property.value.value.trim() !== "";
       }
       if (name !== "requiredClaims") return false;
-      if (property.value.type !== import_utils27.AST_NODE_TYPES.ArrayExpression || property.value.elements.some((element) => element?.type !== import_utils27.AST_NODE_TYPES.Literal)) return true;
-      return property.value.elements.some((element) => element?.type === import_utils27.AST_NODE_TYPES.Literal && element.value === "exp");
+      if (property.value.type !== import_utils26.AST_NODE_TYPES.ArrayExpression || property.value.elements.some((element) => element?.type !== import_utils26.AST_NODE_TYPES.Literal)) return true;
+      return property.value.elements.some((element) => element?.type === import_utils26.AST_NODE_TYPES.Literal && element.value === "exp");
     }
     return {
       ReturnStatement(node) {
@@ -3058,7 +3279,7 @@ var require_jwt_lifetime_default = createRule({
 });
 
 // src/rules/no-discarded-validation-result.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
@@ -3094,52 +3315,52 @@ var no_discarded_validation_result_default = createRule({
     function schema(node, depth = 0) {
       if (depth > 24) return null;
       node = unwrapExpression(node);
-      if (node.type === import_utils28.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils28.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type === import_utils27.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils27.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
         const definition = variable?.defs[0]?.node;
         if (variable?.defs.length !== 1) return null;
-        if (definition?.type === import_utils28.AST_NODE_TYPES.ImportSpecifier && definition.parent.type === import_utils28.AST_NODE_TYPES.ImportDeclaration && definition.importKind !== "type" && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
-        if (definition?.type === import_utils28.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
-        if (definition?.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && definition.parent.kind === "const" && definition.init !== null && definition.range[1] < node.range[0] && !variable.references.some((reference) => reference.isWrite() && !reference.init)) return schema(definition.init, depth + 1);
+        if (definition?.type === import_utils27.AST_NODE_TYPES.ImportSpecifier && definition.parent.type === import_utils27.AST_NODE_TYPES.ImportDeclaration && definition.importKind !== "type" && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
+        if (definition?.type === import_utils27.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
+        if (definition?.type === import_utils27.AST_NODE_TYPES.VariableDeclarator && definition.parent.kind === "const" && definition.init !== null && definition.range[1] < node.range[0] && !variable.references.some((reference) => reference.isWrite() && !reference.init)) return schema(definition.init, depth + 1);
         return null;
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.MemberExpression) {
+      if (node.type === import_utils27.AST_NODE_TYPES.MemberExpression) {
         const owner2 = schema(node.object, depth + 1);
         return owner2;
       }
-      if (node.type !== import_utils28.AST_NODE_TYPES.CallExpression) return null;
+      if (node.type !== import_utils27.AST_NODE_TYPES.CallExpression) return null;
       const owner = schema(node.callee, depth + 1);
       if (owner === null) return null;
-      const invokedChange = node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && CHANGING.has(import_utils28.ASTUtils.getPropertyName(node.callee) ?? "");
-      const coerced = node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && coercionNamespace(node.callee.object);
+      const invokedChange = node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && CHANGING.has(import_utils27.ASTUtils.getPropertyName(node.callee) ?? "");
+      const coerced = node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && coercionNamespace(node.callee.object);
       const changedArgument = node.arguments.some((argument) => {
-        if (argument.type === import_utils28.AST_NODE_TYPES.ArrayExpression) return argument.elements.some((element) => element !== null && schema(element, depth + 1)?.changed === true);
-        if (argument.type === import_utils28.AST_NODE_TYPES.ObjectExpression) return argument.properties.some((property) => property.type === import_utils28.AST_NODE_TYPES.Property && schema(property.value, depth + 1)?.changed === true);
+        if (argument.type === import_utils27.AST_NODE_TYPES.ArrayExpression) return argument.elements.some((element) => element !== null && schema(element, depth + 1)?.changed === true);
+        if (argument.type === import_utils27.AST_NODE_TYPES.ObjectExpression) return argument.properties.some((property) => property.type === import_utils27.AST_NODE_TYPES.Property && schema(property.value, depth + 1)?.changed === true);
         return schema(argument, depth + 1)?.changed === true;
       });
       return { changed: owner.changed || invokedChange || coerced || changedArgument };
     }
     function coercionNamespace(node) {
       let namespace = false;
-      if (node.type === import_utils28.AST_NODE_TYPES.MemberExpression && import_utils28.ASTUtils.getPropertyName(node) === "coerce") {
+      if (node.type === import_utils27.AST_NODE_TYPES.MemberExpression && import_utils27.ASTUtils.getPropertyName(node) === "coerce") {
         namespace = true;
         node = node.object;
       }
-      if (node.type !== import_utils28.AST_NODE_TYPES.Identifier) return false;
-      const variable = import_utils28.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type !== import_utils27.AST_NODE_TYPES.Identifier) return false;
+      const variable = import_utils27.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
       const definition = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || definition === void 0 || definition.parent.type !== import_utils28.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return false;
-      if (definition.type === import_utils28.AST_NODE_TYPES.ImportNamespaceSpecifier) return namespace;
-      if (definition.type !== import_utils28.AST_NODE_TYPES.ImportSpecifier || definition.importKind === "type") return false;
-      const name = definition.imported.type === import_utils28.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value;
+      if (variable?.defs.length !== 1 || definition === void 0 || definition.parent.type !== import_utils27.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return false;
+      if (definition.type === import_utils27.AST_NODE_TYPES.ImportNamespaceSpecifier) return namespace;
+      if (definition.type !== import_utils27.AST_NODE_TYPES.ImportSpecifier || definition.importKind === "type") return false;
+      const name = definition.imported.type === import_utils27.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value;
       return namespace ? name === "z" : name === "coerce";
     }
     return {
       ExpressionStatement(statement) {
         let expression = unwrapExpression(statement.expression);
-        if (expression.type === import_utils28.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
-        if (expression.type !== import_utils28.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils28.AST_NODE_TYPES.MemberExpression) return;
-        const method = import_utils28.ASTUtils.getPropertyName(expression.callee);
+        if (expression.type === import_utils27.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
+        if (expression.type !== import_utils27.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils27.AST_NODE_TYPES.MemberExpression) return;
+        const method = import_utils27.ASTUtils.getPropertyName(expression.callee);
         if (!(/* @__PURE__ */ new Set(["parse", "parseAsync", "safeParse", "safeParseAsync"])).has(method ?? "")) return;
         const owner = schema(expression.callee.object);
         if (owner !== null && (owner.changed || method?.startsWith("safe") === true)) context.report({ node: expression, messageId: "discarded" });
@@ -3149,7 +3370,7 @@ var no_discarded_validation_result_default = createRule({
 });
 
 // src/rules/production-derived-test-cases.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 var MEMBERSHIP = /(?:^|_)(?:ALLOWED|ELIGIBLE|REQUIRED|SUPPORTED)(?:_|$)/u;
 var SUPPORT_PATH = /(?:^|[/_.-])(?:tests?|fixtures?|fakes?|mocks?|stubs?|__tests__)(?:[/_.-]|$)/u;
 var PRODUCTION_DERIVED_TEST_CASES_DOCUMENTATION = {
@@ -3184,52 +3405,52 @@ var production_derived_test_cases_default = createRule({
     const tables = [];
     const asserted = /* @__PURE__ */ new Set();
     function binding3(node) {
-      return import_utils29.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      return import_utils28.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
     }
     function importedName7(node, module2) {
       const variable = binding3(node);
       const specifier = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || specifier?.type !== import_utils29.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils29.AST_NODE_TYPES.ImportDeclaration || specifier.parent.importKind === "type" || specifier.parent.source.value !== module2 || variable.references.some((reference) => reference.isWrite())) return null;
-      return specifier.imported.type === import_utils29.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      if (variable?.defs.length !== 1 || specifier?.type !== import_utils28.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils28.AST_NODE_TYPES.ImportDeclaration || specifier.parent.importKind === "type" || specifier.parent.source.value !== module2 || variable.references.some((reference) => reference.isWrite())) return null;
+      return specifier.imported.type === import_utils28.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
     }
     function production(node) {
       node = unwrapExpression(node);
-      if (node.type !== import_utils29.AST_NODE_TYPES.Identifier) return null;
+      if (node.type !== import_utils28.AST_NODE_TYPES.Identifier) return null;
       const variable = binding3(node);
       const specifier = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || specifier?.type !== import_utils29.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils29.AST_NODE_TYPES.ImportDeclaration || specifier.parent.importKind === "type" || !specifier.parent.source.value.startsWith(".") || SUPPORT_PATH.test(specifier.parent.source.value) || variable.references.some((reference) => reference.isWrite())) return null;
-      const name = specifier.imported.type === import_utils29.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      if (variable?.defs.length !== 1 || specifier?.type !== import_utils28.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils28.AST_NODE_TYPES.ImportDeclaration || specifier.parent.importKind === "type" || !specifier.parent.source.value.startsWith(".") || SUPPORT_PATH.test(specifier.parent.source.value) || variable.references.some((reference) => reference.isWrite())) return null;
+      const name = specifier.imported.type === import_utils28.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
       return MEMBERSHIP.test(name) && !name.endsWith("REGISTRY") ? variable : null;
     }
     function runner(node) {
       node = unwrapExpression(node);
-      while (node.type === import_utils29.AST_NODE_TYPES.MemberExpression && ["only", "skip", "concurrent", "sequential"].includes(import_utils29.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
-      if (node.type !== import_utils29.AST_NODE_TYPES.Identifier) return false;
+      while (node.type === import_utils28.AST_NODE_TYPES.MemberExpression && ["only", "skip", "concurrent", "sequential"].includes(import_utils28.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
+      if (node.type !== import_utils28.AST_NODE_TYPES.Identifier) return false;
       const name = importedName7(node, "vitest");
       return name === "test" || name === "it" || vitestFixtureTestName(sourceCode, node) !== null;
     }
     function caseTable(node) {
-      return node.type === import_utils29.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && ["each", "for"].includes(import_utils29.ASTUtils.getPropertyName(node.callee) ?? "") && runner(node.callee.object);
+      return node.type === import_utils28.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && ["each", "for"].includes(import_utils28.ASTUtils.getPropertyName(node.callee) ?? "") && runner(node.callee.object);
     }
     function literalTable(node, seen = /* @__PURE__ */ new Set()) {
       node = unwrapExpression(node);
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === import_utils29.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils28.AST_NODE_TYPES.Identifier) {
         const variable = binding3(node);
         const definition = variable?.defs[0]?.node;
-        return variable?.defs.length === 1 && definition?.type === import_utils29.AST_NODE_TYPES.VariableDeclarator && definition.parent.kind === "const" && definition.init !== null && definition.range[1] < node.range[0] && variable.references.every((reference) => reference.init || !reference.isWrite() && reference.identifier.parent.type === import_utils29.AST_NODE_TYPES.CallExpression && (caseTable(reference.identifier.parent) || reference.identifier.parent.callee.type === import_utils29.AST_NODE_TYPES.Identifier && importedName7(reference.identifier.parent.callee, "vitest") === "expect" || reference.identifier.parent.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && ["toEqual", "toStrictEqual"].includes(import_utils29.ASTUtils.getPropertyName(reference.identifier.parent.callee) ?? ""))) && literalTable(definition.init, seen);
+        return variable?.defs.length === 1 && definition?.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && definition.parent.kind === "const" && definition.init !== null && definition.range[1] < node.range[0] && variable.references.every((reference) => reference.init || !reference.isWrite() && reference.identifier.parent.type === import_utils28.AST_NODE_TYPES.CallExpression && (caseTable(reference.identifier.parent) || reference.identifier.parent.callee.type === import_utils28.AST_NODE_TYPES.Identifier && importedName7(reference.identifier.parent.callee, "vitest") === "expect" || reference.identifier.parent.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && ["toEqual", "toStrictEqual"].includes(import_utils28.ASTUtils.getPropertyName(reference.identifier.parent.callee) ?? ""))) && literalTable(definition.init, seen);
       }
-      return node.type === import_utils29.AST_NODE_TYPES.ArrayExpression && node.elements.every((element) => element?.type === import_utils29.AST_NODE_TYPES.Literal && !("regex" in element));
+      return node.type === import_utils28.AST_NODE_TYPES.ArrayExpression && node.elements.every((element) => element?.type === import_utils28.AST_NODE_TYPES.Literal && !("regex" in element));
     }
     function unconditional(node) {
       const statement = node.parent;
-      if (statement.type !== import_utils29.AST_NODE_TYPES.ExpressionStatement) return false;
-      if (statement.parent.type === import_utils29.AST_NODE_TYPES.Program) return true;
+      if (statement.type !== import_utils28.AST_NODE_TYPES.ExpressionStatement) return false;
+      if (statement.parent.type === import_utils28.AST_NODE_TYPES.Program) return true;
       const block = statement.parent;
-      if (block.type !== import_utils29.AST_NODE_TYPES.BlockStatement || block.parent.type !== import_utils29.AST_NODE_TYPES.ArrowFunctionExpression && block.parent.type !== import_utils29.AST_NODE_TYPES.FunctionExpression) return false;
+      if (block.type !== import_utils28.AST_NODE_TYPES.BlockStatement || block.parent.type !== import_utils28.AST_NODE_TYPES.ArrowFunctionExpression && block.parent.type !== import_utils28.AST_NODE_TYPES.FunctionExpression) return false;
       const call = block.parent.parent;
-      return call.type === import_utils29.AST_NODE_TYPES.CallExpression && runner(call.callee);
+      return call.type === import_utils28.AST_NODE_TYPES.CallExpression && runner(call.callee);
     }
     return {
       CallExpression(node) {
@@ -3237,9 +3458,9 @@ var production_derived_test_cases_default = createRule({
           const variable2 = production(node.arguments[0]);
           if (variable2 !== null) tables.push({ node, variable: variable2 });
         }
-        if (node.callee.type !== import_utils29.AST_NODE_TYPES.MemberExpression || !["toEqual", "toStrictEqual"].includes(import_utils29.ASTUtils.getPropertyName(node.callee) ?? "") || node.arguments.length !== 1 || node.arguments[0] === void 0 || !literalTable(node.arguments[0]) || !unconditional(node)) return;
+        if (node.callee.type !== import_utils28.AST_NODE_TYPES.MemberExpression || !["toEqual", "toStrictEqual"].includes(import_utils28.ASTUtils.getPropertyName(node.callee) ?? "") || node.arguments.length !== 1 || node.arguments[0] === void 0 || !literalTable(node.arguments[0]) || !unconditional(node)) return;
         const expect = node.callee.object;
-        if (expect.type !== import_utils29.AST_NODE_TYPES.CallExpression || expect.callee.type !== import_utils29.AST_NODE_TYPES.Identifier || importedName7(expect.callee, "vitest") !== "expect" || expect.arguments.length !== 1 || expect.arguments[0] === void 0) return;
+        if (expect.type !== import_utils28.AST_NODE_TYPES.CallExpression || expect.callee.type !== import_utils28.AST_NODE_TYPES.Identifier || importedName7(expect.callee, "vitest") !== "expect" || expect.arguments.length !== 1 || expect.arguments[0] === void 0) return;
         const variable = production(expect.arguments[0]);
         if (variable !== null) asserted.add(variable);
       },
@@ -3251,14 +3472,14 @@ var production_derived_test_cases_default = createRule({
 });
 
 // src/rules/require-constrained-schema-integer.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 var FIELD_MINIMUMS = /* @__PURE__ */ new Map([["limit", 1], ["version", 0]]);
 var NUMBER_FACTORIES = /* @__PURE__ */ new Set(["number", "int", "int32", "uint32"]);
 var PRESERVING = /* @__PURE__ */ new Set(["optional", "nullable", "nullish", "default", "catch", "readonly", "brand", "describe", "meta", "max", "lte", "lt", "finite", "safe", "multipleOf"]);
 function numericLiteral(node) {
   node = unwrapExpression(node);
-  if (node.type === import_utils30.AST_NODE_TYPES.Literal && typeof node.value === "number") return node.value;
-  if (node.type === import_utils30.AST_NODE_TYPES.UnaryExpression && (node.operator === "-" || node.operator === "+")) {
+  if (node.type === import_utils29.AST_NODE_TYPES.Literal && typeof node.value === "number") return node.value;
+  if (node.type === import_utils29.AST_NODE_TYPES.UnaryExpression && (node.operator === "-" || node.operator === "+")) {
     const value = numericLiteral(node.argument);
     return value === null ? null : node.operator === "-" ? -value : value;
   }
@@ -3295,35 +3516,35 @@ var require_constrained_schema_integer_default = createRule({
     const sourceCode = context.sourceCode;
     function factory(node) {
       node = unwrapExpression(node);
-      if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils29.AST_NODE_TYPES.Identifier) {
         const definition2 = imported(node);
-        return definition2?.type === import_utils30.AST_NODE_TYPES.ImportSpecifier ? definition2.imported.type === import_utils30.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value : null;
+        return definition2?.type === import_utils29.AST_NODE_TYPES.ImportSpecifier ? definition2.imported.type === import_utils29.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value : null;
       }
-      if (node.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return null;
+      if (node.type !== import_utils29.AST_NODE_TYPES.MemberExpression) return null;
       let receiver = unwrapExpression(node.object);
-      if (receiver.type === import_utils30.AST_NODE_TYPES.MemberExpression && import_utils30.ASTUtils.getPropertyName(receiver) === "coerce") receiver = unwrapExpression(receiver.object);
-      if (receiver.type !== import_utils30.AST_NODE_TYPES.Identifier) return null;
+      if (receiver.type === import_utils29.AST_NODE_TYPES.MemberExpression && import_utils29.ASTUtils.getPropertyName(receiver) === "coerce") receiver = unwrapExpression(receiver.object);
+      if (receiver.type !== import_utils29.AST_NODE_TYPES.Identifier) return null;
       const definition = imported(receiver);
-      if (definition === null || definition.type === import_utils30.AST_NODE_TYPES.ImportSpecifier && (definition.imported.type === import_utils30.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z") return null;
-      return import_utils30.ASTUtils.getPropertyName(node);
+      if (definition === null || definition.type === import_utils29.AST_NODE_TYPES.ImportSpecifier && (definition.imported.type === import_utils29.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z") return null;
+      return import_utils29.ASTUtils.getPropertyName(node);
     }
     function imported(identifier) {
-      const variable = import_utils30.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = import_utils29.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
       const definition = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || definition?.type !== import_utils30.AST_NODE_TYPES.ImportSpecifier && definition?.type !== import_utils30.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils30.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
-      return definition.type === import_utils30.AST_NODE_TYPES.ImportSpecifier && definition.importKind === "type" ? null : definition;
+      if (variable?.defs.length !== 1 || definition?.type !== import_utils29.AST_NODE_TYPES.ImportSpecifier && definition?.type !== import_utils29.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils29.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
+      return definition.type === import_utils29.AST_NODE_TYPES.ImportSpecifier && definition.importKind === "type" ? null : definition;
     }
     function constrained(value, minimum) {
       const calls = [];
       value = unwrapExpression(value);
-      while (value.type === import_utils30.AST_NODE_TYPES.CallExpression) {
+      while (value.type === import_utils29.AST_NODE_TYPES.CallExpression) {
         const name = factory(value.callee);
         if (name !== null) {
           return chainContract(name, calls, minimum);
         }
         const callee = unwrapExpression(value.callee);
-        if (callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return null;
-        const method = import_utils30.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils29.AST_NODE_TYPES.MemberExpression) return null;
+        const method = import_utils29.ASTUtils.getPropertyName(callee);
         if (method === null) return null;
         calls.push({ method, call: value });
         value = unwrapExpression(callee.object);
@@ -3348,7 +3569,7 @@ var require_constrained_schema_integer_default = createRule({
     }
     function lowerBound(call, minimum, exclusive) {
       const argument = call.arguments[0];
-      if (argument === void 0 || argument.type === import_utils30.AST_NODE_TYPES.SpreadElement) return null;
+      if (argument === void 0 || argument.type === import_utils29.AST_NODE_TYPES.SpreadElement) return null;
       const bound = numericLiteral(argument);
       return bound === null || bound >= minimum - (exclusive ? 1 : 0);
     }
@@ -3357,10 +3578,10 @@ var require_constrained_schema_integer_default = createRule({
         const name = factory(node.callee);
         if (name === null || !["object", "strictObject", "looseObject"].includes(name) || node.arguments.length !== 1) return;
         const shape = node.arguments[0];
-        if (shape?.type !== import_utils30.AST_NODE_TYPES.ObjectExpression) return;
+        if (shape?.type !== import_utils29.AST_NODE_TYPES.ObjectExpression) return;
         for (const property of shape.properties) {
-          if (property.type !== import_utils30.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method) continue;
-          const field = import_utils30.ASTUtils.getPropertyName(property);
+          if (property.type !== import_utils29.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method) continue;
+          const field = import_utils29.ASTUtils.getPropertyName(property);
           const minimum = field === null ? void 0 : FIELD_MINIMUMS.get(field);
           if (minimum === void 0 || field === null || constrained(property.value, minimum) !== false) continue;
           context.report({ node: property, messageId: "constrainInteger", data: { field, minimum } });
@@ -3371,7 +3592,7 @@ var require_constrained_schema_integer_default = createRule({
 });
 
 // src/rules/no-generic-json-parser.ts
-var import_utils31 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 var OPEN_FACTORIES = /* @__PURE__ */ new Set(["any", "unknown", "json", "record", "partialRecord"]);
 var WRAPPERS = /* @__PURE__ */ new Set(["optional", "nullable", "nullish", "default", "catch", "readonly", "brand", "describe", "meta"]);
 var NO_GENERIC_JSON_PARSER_DOCUMENTATION = {
@@ -3404,60 +3625,60 @@ var no_generic_json_parser_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     const sourceCode = context.sourceCode;
     function binding3(node) {
-      return import_utils31.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      return import_utils30.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
     }
     function initializer(node) {
       const variable = binding3(node);
       const definition = variable?.defs[0];
-      if (variable?.defs.length !== 1 || definition?.node.type !== import_utils31.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.kind !== "const" || definition.node.init === null || definition.node.range[1] >= node.range[0] || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
+      if (variable?.defs.length !== 1 || definition?.node.type !== import_utils30.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.kind !== "const" || definition.node.init === null || definition.node.range[1] >= node.range[0] || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
       return definition.node.init;
     }
     function parser(node, seen = /* @__PURE__ */ new Set(), awaited = false) {
       node = unwrapExpression(node);
       if (seen.has(node)) return null;
       seen.add(node);
-      if (node.type === import_utils31.AST_NODE_TYPES.AwaitExpression) return parser(node.argument, seen, true);
-      if (node.type === import_utils31.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils30.AST_NODE_TYPES.AwaitExpression) return parser(node.argument, seen, true);
+      if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
         const value = initializer(node);
         return value === null ? null : parser(value, seen, awaited);
       }
-      if (node.type !== import_utils31.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || !["parse", "parseAsync"].includes(import_utils31.ASTUtils.getPropertyName(node.callee) ?? "")) return null;
-      if (import_utils31.ASTUtils.getPropertyName(node.callee) === "parseAsync" && !awaited) return null;
+      if (node.type !== import_utils30.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || !["parse", "parseAsync"].includes(import_utils30.ASTUtils.getPropertyName(node.callee) ?? "")) return null;
+      if (import_utils30.ASTUtils.getPropertyName(node.callee) === "parseAsync" && !awaited) return null;
       return openSchema(node.callee.object) ? node : null;
     }
     function openSchema(node, seen = /* @__PURE__ */ new Set()) {
       node = unwrapExpression(node);
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === import_utils31.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
         const value = initializer(node);
         return value !== null && openSchema(value, seen);
       }
-      if (node.type !== import_utils31.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils30.AST_NODE_TYPES.CallExpression) return false;
       const name = factory(node.callee);
       if (name !== null) return OPEN_FACTORIES.has(name);
       const callee = unwrapExpression(node.callee);
-      return callee.type === import_utils31.AST_NODE_TYPES.MemberExpression && WRAPPERS.has(import_utils31.ASTUtils.getPropertyName(callee) ?? "") && openSchema(callee.object, seen);
+      return callee.type === import_utils30.AST_NODE_TYPES.MemberExpression && WRAPPERS.has(import_utils30.ASTUtils.getPropertyName(callee) ?? "") && openSchema(callee.object, seen);
     }
     function factory(node) {
       node = unwrapExpression(node);
-      if (node.type === import_utils31.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
         const definition2 = binding3(node)?.defs[0]?.node;
-        if (definition2?.type !== import_utils31.AST_NODE_TYPES.ImportSpecifier || definition2.parent.type !== import_utils31.AST_NODE_TYPES.ImportDeclaration || definition2.importKind === "type" || definition2.parent.importKind === "type" || !isZodModule(definition2.parent.source.value)) return null;
-        return definition2.imported.type === import_utils31.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value;
+        if (definition2?.type !== import_utils30.AST_NODE_TYPES.ImportSpecifier || definition2.parent.type !== import_utils30.AST_NODE_TYPES.ImportDeclaration || definition2.importKind === "type" || definition2.parent.importKind === "type" || !isZodModule(definition2.parent.source.value)) return null;
+        return definition2.imported.type === import_utils30.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value;
       }
-      if (node.type !== import_utils31.AST_NODE_TYPES.MemberExpression) return null;
+      if (node.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return null;
       const receiver = unwrapExpression(node.object);
-      if (receiver.type !== import_utils31.AST_NODE_TYPES.Identifier) return null;
+      if (receiver.type !== import_utils30.AST_NODE_TYPES.Identifier) return null;
       const definition = binding3(receiver)?.defs[0]?.node;
-      if (definition === void 0 || definition.type !== import_utils31.AST_NODE_TYPES.ImportSpecifier && definition.type !== import_utils31.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils31.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
-      if (definition.type === import_utils31.AST_NODE_TYPES.ImportSpecifier && (definition.importKind === "type" || (definition.imported.type === import_utils31.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z")) return null;
-      return import_utils31.ASTUtils.getPropertyName(node);
+      if (definition === void 0 || definition.type !== import_utils30.AST_NODE_TYPES.ImportSpecifier && definition.type !== import_utils30.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils30.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
+      if (definition.type === import_utils30.AST_NODE_TYPES.ImportSpecifier && (definition.importKind === "type" || (definition.imported.type === import_utils30.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z")) return null;
+      return import_utils30.ASTUtils.getPropertyName(node);
     }
     const reported = /* @__PURE__ */ new Set();
     return {
       MemberExpression(node) {
-        const field = import_utils31.ASTUtils.getPropertyName(node);
+        const field = import_utils30.ASTUtils.getPropertyName(node);
         if (field === null) return;
         const call = parser(node.object);
         if (call === null || reported.has(call)) return;
@@ -3466,10 +3687,160 @@ var no_generic_json_parser_default = createRule({
       }
     };
   }
-});
+});
+
+// src/rules/no-redundant-local-alias.ts
+var import_utils33 = require("@typescript-eslint/utils");
+
+// src/rules/_unused-private-binding.ts
+var import_utils32 = require("@typescript-eslint/utils");
+
+// src/rules/_type-binding.ts
+var import_utils31 = require("@typescript-eslint/utils");
+function typeBinding(source, identifier) {
+  let scope = source.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== void 0 && (variable.isTypeVariable || variable.defs.some((definition) => definition.isTypeDefinition))) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return null;
+}
+var REFERENCE_INDEXES = /* @__PURE__ */ new WeakMap();
+function retainsNamedTypeUses(source, removed) {
+  const manager = source.scopeManager;
+  if (manager === null) return false;
+  const index = referenceIndex(source, manager);
+  for (const reference of referencesWithin(index.references, removed)) {
+    if (!reference.isRead()) continue;
+    const binding3 = reference.resolved;
+    if (!binding3 || !reference.isTypeReference && !reference.isValueReference) return false;
+    if (binding3.defs.length === 0) continue;
+    const reads = publicReadExtents(index, binding3);
+    const extent = reference.isTypeReference ? reference.isValueReference ? reads.both : reads.type : reads.value;
+    if (extent === null || extent.minStart >= removed.range[0] && extent.maxEnd <= removed.range[1]) return false;
+  }
+  return true;
+}
+function referenceIndex(source, manager) {
+  const cached = REFERENCE_INDEXES.get(source);
+  if (cached?.manager === manager) return cached;
+  const references = manager.scopes.flatMap((scope) => scope.references);
+  references.sort((left, right) => left.identifier.range[0] - right.identifier.range[0]);
+  const index = { manager, references, publicReads: /* @__PURE__ */ new Map() };
+  REFERENCE_INDEXES.set(source, index);
+  return index;
+}
+function* referencesWithin(references, removed) {
+  let low = 0;
+  let high = references.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    const reference = references[middle];
+    if (reference === void 0 || reference.identifier.range[0] >= removed.range[0]) high = middle;
+    else low = middle + 1;
+  }
+  for (let index = low; index < references.length; index++) {
+    const reference = references[index];
+    if (reference === void 0) continue;
+    if (reference.identifier.range[0] > removed.range[1]) break;
+    if (insideTypeRange(reference.identifier, removed)) yield reference;
+  }
+}
+function publicReadExtents(index, binding3) {
+  const cached = index.publicReads.get(binding3);
+  if (cached !== void 0) return cached;
+  let type = null;
+  let value = null;
+  let both = null;
+  for (const retained of binding3.references) {
+    if (!retained.isRead() || !retained.isTypeReference && !retained.isValueReference || binding3.defs.some((definition) => insideTypeRange(retained.identifier, definition.node)) || !publicTypeUse(retained.identifier)) continue;
+    if (retained.isTypeReference) type = extendExtent(type, retained.identifier);
+    if (retained.isValueReference) value = extendExtent(value, retained.identifier);
+    if (retained.isTypeReference && retained.isValueReference) both = extendExtent(both, retained.identifier);
+  }
+  const result = { type, value, both };
+  index.publicReads.set(binding3, result);
+  return result;
+}
+function extendExtent(extent, identifier) {
+  return {
+    minStart: Math.min(extent?.minStart ?? identifier.range[0], identifier.range[0]),
+    maxEnd: Math.max(extent?.maxEnd ?? identifier.range[1], identifier.range[1])
+  };
+}
+function publicTypeUse(identifier) {
+  let node = identifier;
+  while (node.parent) {
+    if (node.type === import_utils31.AST_NODE_TYPES.TSTypeAnnotation || node.type === import_utils31.AST_NODE_TYPES.TSTypePredicate || node.type === import_utils31.AST_NODE_TYPES.TSAsExpression || node.type === import_utils31.AST_NODE_TYPES.TSTypeAssertion) return false;
+    if (node.type === import_utils31.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      return node.parent.type === import_utils31.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.declaration === node && node.parent.parent.type === import_utils31.AST_NODE_TYPES.Program;
+    }
+    if (node.type === import_utils31.AST_NODE_TYPES.ExportSpecifier) {
+      return node.parent.type === import_utils31.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.source === null && node.parent.parent.type === import_utils31.AST_NODE_TYPES.Program;
+    }
+    node = node.parent;
+  }
+  return false;
+}
+function insideTypeRange(node, range) {
+  return node.range[0] >= range.range[0] && node.range[1] <= range.range[1];
+}
+
+// src/rules/_unused-private-binding.ts
+function isUnusedPrivateBinding(sourceCode, declaration, identifier, filename, allowedDeclarations = [declaration]) {
+  if (/\.d\.[cm]?ts$/u.test(filename)) return false;
+  const bindings = sourceCode.getDeclaredVariables(declaration).filter((binding3) => binding3.name === identifier.name);
+  if (bindings.length === 0 || bindings.some((binding3) => binding3.defs.length !== allowedDeclarations.length || binding3.defs.some((definition) => !allowedDeclarations.includes(definition.node)) || binding3.eslintUsed || binding3.references.some((reference) => reference.isRead() || reference.init !== true))) return false;
+  if (hasIdentifierNamed(sourceCode.ast, "eval")) return false;
+  const statement = declaration.type === import_utils32.AST_NODE_TYPES.VariableDeclarator ? declaration.parent : declaration;
+  if (statement.parent.type === import_utils32.AST_NODE_TYPES.ExportNamedDeclaration || statement.parent.type === import_utils32.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  if (statement.parent.type !== import_utils32.AST_NODE_TYPES.Program) return statement.parent.type === import_utils32.AST_NODE_TYPES.BlockStatement;
+  return sourceCode.ast.body.some((node) => node.type === import_utils32.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils32.AST_NODE_TYPES.ExportNamedDeclaration || node.type === import_utils32.AST_NODE_TYPES.ExportDefaultDeclaration || node.type === import_utils32.AST_NODE_TYPES.ExportAllDeclaration);
+}
+function hasOnlyDirectFactoryUses(variable) {
+  return variable.references.every((reference) => {
+    if (reference.isTypeReference && !reference.isValueReference) return true;
+    const identifier = reference.identifier;
+    const parent = identifier.parent;
+    if (parent.type === import_utils32.AST_NODE_TYPES.CallExpression && parent.callee === identifier) return true;
+    return parent.type === import_utils32.AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.parent.type === import_utils32.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
+  });
+}
+var IDENTIFIER_NAMES = /* @__PURE__ */ new WeakMap();
+function hasIdentifierNamed(node, name) {
+  let names = IDENTIFIER_NAMES.get(node);
+  if (names === void 0) {
+    const collected = /* @__PURE__ */ new Set();
+    const pending = [node];
+    const seen = /* @__PURE__ */ new WeakSet();
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (current === void 0 || seen.has(current)) continue;
+      seen.add(current);
+      if (current.type === import_utils32.AST_NODE_TYPES.Identifier || current.type === import_utils32.AST_NODE_TYPES.JSXIdentifier) collected.add(current.name);
+      forEachOwnAstChild(current, (child) => {
+        pending.push(child);
+      }, (key) => key !== "tokens" && key !== "comments");
+    }
+    names = collected;
+    IDENTIFIER_NAMES.set(node, names);
+  }
+  return names.has(name);
+}
+function privatePredicateBooleanFix(sourceCode, node, annotation, filename) {
+  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_utils32.AST_NODE_TYPES.FunctionDeclaration || node.id === null || !isUnusedPrivateBinding(sourceCode, node, node.id, filename) || sourceCode.getCommentsInside(annotation).length > 0) return null;
+  const text = `boolean${sourceCode.getText(annotation).replace(/[^\r\n\u2028\u2029]/gu, "")}`;
+  const neighbor = Math.max(0, annotation.range[0] - 1);
+  const before = sourceCode.text.slice(neighbor, annotation.range[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  const after = (sourceCode.text.slice(neighbor, annotation.range[0]) + text + sourceCode.text.slice(annotation.range[1], annotation.range[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  if (before.length !== after.length || before.some((ending, index) => ending !== after[index])) return null;
+  return (fixer) => fixer.replaceText(annotation, text);
+}
 
 // src/rules/no-redundant-local-alias.ts
-var import_utils32 = require("@typescript-eslint/utils");
 var NO_REDUNDANT_LOCAL_ALIAS_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Pass the original local into an object field instead of creating a single-use rename.",
@@ -3491,24 +3862,24 @@ var NO_REDUNDANT_LOCAL_ALIAS_DOCUMENTATION = {
 function stableSource(variable, alias) {
   const definition = variable.defs[0];
   if (variable.defs.length !== 1 || definition === void 0 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
-  return definition.type === "Parameter" || definition.node.type === import_utils32.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < alias.range[0];
+  return definition.type === "Parameter" || definition.node.type === import_utils33.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < alias.range[0];
 }
 var PRIMITIVE_PARAMETERS = /* @__PURE__ */ new Set([
-  import_utils32.AST_NODE_TYPES.TSStringKeyword,
-  import_utils32.AST_NODE_TYPES.TSNumberKeyword,
-  import_utils32.AST_NODE_TYPES.TSBooleanKeyword,
-  import_utils32.AST_NODE_TYPES.TSBigIntKeyword,
-  import_utils32.AST_NODE_TYPES.TSSymbolKeyword
+  import_utils33.AST_NODE_TYPES.TSStringKeyword,
+  import_utils33.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils33.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils33.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils33.AST_NODE_TYPES.TSSymbolKeyword
 ]);
 function closedPrimitiveReturnFix(sourceCode, node, property, source, target) {
   const statement = node.parent;
   const body3 = statement.parent;
-  if (body3.type !== import_utils32.AST_NODE_TYPES.BlockStatement) return null;
+  if (body3.type !== import_utils33.AST_NODE_TYPES.BlockStatement) return null;
   const owner = body3.parent;
-  if (owner.type !== import_utils32.AST_NODE_TYPES.FunctionDeclaration || owner.parent.type !== import_utils32.AST_NODE_TYPES.Program || owner.id === null || owner.async || owner.generator || owner.typeParameters !== void 0 || owner.returnType !== void 0 || owner.params.length !== 1 || body3.body.length !== 2 || body3.body[0] !== statement || node.id.type !== import_utils32.AST_NODE_TYPES.Identifier || node.id.name === "__proto__" || node.init?.type !== import_utils32.AST_NODE_TYPES.Identifier || sourceCode.getCommentsInside(owner).length !== 0 || hasIdentifierNamed(sourceCode.ast, "eval")) return null;
+  if (owner.type !== import_utils33.AST_NODE_TYPES.FunctionDeclaration || owner.parent.type !== import_utils33.AST_NODE_TYPES.Program || owner.id === null || owner.async || owner.generator || owner.typeParameters !== void 0 || owner.returnType !== void 0 || owner.params.length !== 1 || body3.body.length !== 2 || body3.body[0] !== statement || node.id.type !== import_utils33.AST_NODE_TYPES.Identifier || node.id.name === "__proto__" || node.init?.type !== import_utils33.AST_NODE_TYPES.Identifier || sourceCode.getCommentsInside(owner).length !== 0 || hasIdentifierNamed(sourceCode.ast, "eval")) return null;
   const parameter = owner.params[0];
   const returned2 = body3.body[1];
-  if (parameter?.type !== import_utils32.AST_NODE_TYPES.Identifier || parameter.optional === true || parameter.typeAnnotation === void 0 || !PRIMITIVE_PARAMETERS.has(parameter.typeAnnotation.typeAnnotation.type) || returned2?.type !== import_utils32.AST_NODE_TYPES.ReturnStatement || returned2.argument !== property.parent || property.parent.type !== import_utils32.AST_NODE_TYPES.ObjectExpression || property.parent.properties.length !== 1 || import_utils32.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name) !== source || import_utils32.ASTUtils.findVariable(sourceCode.getScope(property), node.init.name) !== source || source.references.some((reference) => reference.isTypeReference) || target.references.some((reference) => reference.isTypeReference)) return null;
+  if (parameter?.type !== import_utils33.AST_NODE_TYPES.Identifier || parameter.optional === true || parameter.typeAnnotation === void 0 || !PRIMITIVE_PARAMETERS.has(parameter.typeAnnotation.typeAnnotation.type) || returned2?.type !== import_utils33.AST_NODE_TYPES.ReturnStatement || returned2.argument !== property.parent || property.parent.type !== import_utils33.AST_NODE_TYPES.ObjectExpression || property.parent.properties.length !== 1 || import_utils33.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name) !== source || import_utils33.ASTUtils.findVariable(sourceCode.getScope(property), node.init.name) !== source || source.references.some((reference) => reference.isTypeReference) || target.references.some((reference) => reference.isTypeReference)) return null;
   const name = owner.id.name;
   const bindings = sourceCode.getDeclaredVariables(owner).filter((binding3) => binding3.name === name);
   if (bindings.length !== 1 || bindings[0]?.defs.length !== 1 || bindings[0].defs[0]?.node !== owner || bindings[0].references.some((reference) => reference.isTypeReference)) return null;
@@ -3535,21 +3906,21 @@ var no_redundant_local_alias_default = createRule({
   defaultOptions: [],
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
-    const hasModuleSyntax = context.sourceCode.ast.body.some((candidate2) => candidate2.type === import_utils32.AST_NODE_TYPES.ImportDeclaration || candidate2.type === import_utils32.AST_NODE_TYPES.ExportNamedDeclaration || candidate2.type === import_utils32.AST_NODE_TYPES.ExportDefaultDeclaration || candidate2.type === import_utils32.AST_NODE_TYPES.ExportAllDeclaration);
+    const hasModuleSyntax = context.sourceCode.ast.body.some((candidate2) => candidate2.type === import_utils33.AST_NODE_TYPES.ImportDeclaration || candidate2.type === import_utils33.AST_NODE_TYPES.ExportNamedDeclaration || candidate2.type === import_utils33.AST_NODE_TYPES.ExportDefaultDeclaration || candidate2.type === import_utils33.AST_NODE_TYPES.ExportAllDeclaration);
     return {
       VariableDeclarator(node) {
-        if (node.parent.kind !== "const" || node.parent.declarations.length !== 1 || node.id.type !== import_utils32.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0 || node.init?.type !== import_utils32.AST_NODE_TYPES.Identifier) return;
+        if (node.parent.kind !== "const" || node.parent.declarations.length !== 1 || node.id.type !== import_utils33.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0 || node.init?.type !== import_utils33.AST_NODE_TYPES.Identifier) return;
         const scope = context.sourceCode.getScope(node);
         if (scope.variableScope.type !== "function") return;
-        const target = import_utils32.ASTUtils.findVariable(scope, node.id.name);
-        const source = import_utils32.ASTUtils.findVariable(scope, node.init.name);
+        const target = import_utils33.ASTUtils.findVariable(scope, node.id.name);
+        const source = import_utils33.ASTUtils.findVariable(scope, node.init.name);
         if (target === null || source === null || !stableSource(source, node)) return;
         const reads = target.references.filter((reference) => reference.isRead());
         if (reads.length !== 1 || target.references.some((reference) => reference.isWrite() && !reference.init)) return;
         const read = reads[0];
         if (read === void 0 || read.from.variableScope !== scope.variableScope) return;
         const property = read.identifier.parent;
-        if (property.type !== import_utils32.AST_NODE_TYPES.Property || !property.shorthand || property.value !== read.identifier || property.parent.type !== import_utils32.AST_NODE_TYPES.ObjectExpression || property.computed || property.method || property.kind !== "init") return;
+        if (property.type !== import_utils33.AST_NODE_TYPES.Property || !property.shorthand || property.value !== read.identifier || property.parent.type !== import_utils33.AST_NODE_TYPES.ObjectExpression || property.computed || property.method || property.kind !== "init") return;
         context.report({ node, messageId: "redundantAlias", fix: hasModuleSyntax ? closedPrimitiveReturnFix(context.sourceCode, node, property, source, target) : null, data: { source: node.init.name, target: node.id.name } });
       }
     };
@@ -3557,14 +3928,14 @@ var no_redundant_local_alias_default = createRule({
 });
 
 // src/rules/no-mutating-container-transform.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 var MUTATORS = /* @__PURE__ */ new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"]);
 var PRIMITIVES = /* @__PURE__ */ new Set([
-  import_utils33.AST_NODE_TYPES.TSStringKeyword,
-  import_utils33.AST_NODE_TYPES.TSNumberKeyword,
-  import_utils33.AST_NODE_TYPES.TSBooleanKeyword,
-  import_utils33.AST_NODE_TYPES.TSBigIntKeyword,
-  import_utils33.AST_NODE_TYPES.TSSymbolKeyword
+  import_utils34.AST_NODE_TYPES.TSStringKeyword,
+  import_utils34.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils34.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils34.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils34.AST_NODE_TYPES.TSSymbolKeyword
 ]);
 var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -3583,27 +3954,27 @@ var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   ]
 };
 function arrayElement(node, sourceCode) {
-  if (node.type === import_utils33.AST_NODE_TYPES.TSArrayType) return node.elementType;
-  if (node.type === import_utils33.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils33.AST_NODE_TYPES.Identifier && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray") && (import_utils33.ASTUtils.findVariable(sourceCode.getScope(node.typeName), node.typeName.name)?.defs.length ?? 0) === 0 && node.typeArguments?.params.length === 1) return node.typeArguments.params[0] ?? null;
+  if (node.type === import_utils34.AST_NODE_TYPES.TSArrayType) return node.elementType;
+  if (node.type === import_utils34.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray") && (import_utils34.ASTUtils.findVariable(sourceCode.getScope(node.typeName), node.typeName.name)?.defs.length ?? 0) === 0 && node.typeArguments?.params.length === 1) return node.typeArguments.params[0] ?? null;
   return null;
 }
 function returnsArray(node, sourceCode) {
   let annotation = node.returnType?.typeAnnotation;
-  if (annotation?.type === import_utils33.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils33.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && (import_utils33.ASTUtils.findVariable(sourceCode.getScope(annotation.typeName), "Promise")?.defs.length ?? 0) === 0 && annotation.typeArguments?.params.length === 1) annotation = annotation.typeArguments.params[0];
+  if (annotation?.type === import_utils34.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && (import_utils34.ASTUtils.findVariable(sourceCode.getScope(annotation.typeName), "Promise")?.defs.length ?? 0) === 0 && annotation.typeArguments?.params.length === 1) annotation = annotation.typeArguments.params[0];
   return annotation !== void 0 && arrayElement(annotation, sourceCode) !== null;
 }
 function supported(statements) {
   return statements.every((statement) => {
     switch (statement.type) {
-      case import_utils33.AST_NODE_TYPES.ExpressionStatement:
-      case import_utils33.AST_NODE_TYPES.VariableDeclaration:
-      case import_utils33.AST_NODE_TYPES.ReturnStatement:
-      case import_utils33.AST_NODE_TYPES.ThrowStatement:
-      case import_utils33.AST_NODE_TYPES.EmptyStatement:
+      case import_utils34.AST_NODE_TYPES.ExpressionStatement:
+      case import_utils34.AST_NODE_TYPES.VariableDeclaration:
+      case import_utils34.AST_NODE_TYPES.ReturnStatement:
+      case import_utils34.AST_NODE_TYPES.ThrowStatement:
+      case import_utils34.AST_NODE_TYPES.EmptyStatement:
         return true;
-      case import_utils33.AST_NODE_TYPES.BlockStatement:
+      case import_utils34.AST_NODE_TYPES.BlockStatement:
         return supported(statement.body);
-      case import_utils33.AST_NODE_TYPES.IfStatement:
+      case import_utils34.AST_NODE_TYPES.IfStatement:
         return supported([statement.consequent]) && (statement.alternate === null || supported([statement.alternate]));
       default:
         return false;
@@ -3624,13 +3995,13 @@ var no_mutating_container_transform_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     const sourceCode = context.sourceCode;
     function binding3(node) {
-      return node.type === import_utils33.AST_NODE_TYPES.Identifier ? import_utils33.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
+      return node.type === import_utils34.AST_NODE_TYPES.Identifier ? import_utils34.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
     }
     function inspect(node) {
-      if (node.body?.type !== import_utils33.AST_NODE_TYPES.BlockStatement || !returnsArray(node, sourceCode) || !supported(node.body.body)) return;
+      if (node.body?.type !== import_utils34.AST_NODE_TYPES.BlockStatement || !returnsArray(node, sourceCode) || !supported(node.body.body)) return;
       const initial = /* @__PURE__ */ new Map();
       for (const parameter of node.params) {
-        if (parameter.type !== import_utils33.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
+        if (parameter.type !== import_utils34.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
         const element = arrayElement(parameter.typeAnnotation.typeAnnotation, sourceCode);
         const variable = binding3(parameter);
         if (element !== null && PRIMITIVES.has(element.type) && variable !== null) initial.set(variable, parameter.name);
@@ -3643,26 +4014,26 @@ var no_mutating_container_transform_default = createRule({
       }
       function expression(current, state) {
         switch (current.type) {
-          case import_utils33.AST_NODE_TYPES.FunctionExpression:
-          case import_utils33.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils33.AST_NODE_TYPES.ClassExpression:
+          case import_utils34.AST_NODE_TYPES.FunctionExpression:
+          case import_utils34.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils34.AST_NODE_TYPES.ClassExpression:
             return;
-          case import_utils33.AST_NODE_TYPES.AssignmentExpression:
+          case import_utils34.AST_NODE_TYPES.AssignmentExpression:
             assignment(current, state);
             return;
-          case import_utils33.AST_NODE_TYPES.LogicalExpression:
+          case import_utils34.AST_NODE_TYPES.LogicalExpression:
             logical(current, state);
             return;
-          case import_utils33.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils34.AST_NODE_TYPES.ConditionalExpression:
             conditional(current, state);
             return;
-          case import_utils33.AST_NODE_TYPES.UpdateExpression:
+          case import_utils34.AST_NODE_TYPES.UpdateExpression:
             write(current.argument, state);
             break;
-          case import_utils33.AST_NODE_TYPES.UnaryExpression:
+          case import_utils34.AST_NODE_TYPES.UnaryExpression:
             if (current.operator === "delete") write(current.argument, state);
             break;
-          case import_utils33.AST_NODE_TYPES.CallExpression:
+          case import_utils34.AST_NODE_TYPES.CallExpression:
             mutationCall(current, state);
             break;
           default:
@@ -3682,13 +4053,13 @@ var no_mutating_container_transform_default = createRule({
       function logical(current, state) {
         expression(current.left, state);
         const left = unwrapExpression(current.left);
-        if (left.type === import_utils33.AST_NODE_TYPES.Literal && (current.operator === "&&" && !left.value || current.operator === "||" && !!left.value || current.operator === "??" && left.value !== null)) return;
+        if (left.type === import_utils34.AST_NODE_TYPES.Literal && (current.operator === "&&" && !left.value || current.operator === "||" && !!left.value || current.operator === "??" && left.value !== null)) return;
         expression(current.right, state);
       }
       function conditional(current, state) {
         expression(current.test, state);
         const test = unwrapExpression(current.test);
-        if (test.type === import_utils33.AST_NODE_TYPES.Literal) {
+        if (test.type === import_utils34.AST_NODE_TYPES.Literal) {
           expression(test.value ? current.consequent : current.alternate, state);
           return;
         }
@@ -3696,13 +4067,13 @@ var no_mutating_container_transform_default = createRule({
         expression(current.alternate, state);
       }
       function mutationCall(current, state) {
-        if (current.callee.type !== import_utils33.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils33.ASTUtils.getPropertyName(current.callee) ?? "")) return;
+        if (current.callee.type !== import_utils34.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils34.ASTUtils.getPropertyName(current.callee) ?? "")) return;
         const parameter = origin(current.callee.object, state);
         if (parameter !== void 0 && first === null) first = { node: current, parameter };
       }
       function write(target, state) {
         target = unwrapExpression(target);
-        if (target.type !== import_utils33.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils33.ASTUtils.getPropertyName(target) !== "length") return;
+        if (target.type !== import_utils34.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils34.ASTUtils.getPropertyName(target) !== "length") return;
         const parameter = origin(target.object, state);
         if (parameter !== void 0 && first === null) first = { node: target, parameter };
       }
@@ -3712,18 +4083,18 @@ var no_mutating_container_transform_default = createRule({
       }
       function statement(current, state) {
         switch (current.type) {
-          case import_utils33.AST_NODE_TYPES.BlockStatement:
+          case import_utils34.AST_NODE_TYPES.BlockStatement:
             return statements(current.body, state);
-          case import_utils33.AST_NODE_TYPES.IfStatement:
+          case import_utils34.AST_NODE_TYPES.IfStatement:
             return branch(current, state);
-          case import_utils33.AST_NODE_TYPES.VariableDeclaration:
+          case import_utils34.AST_NODE_TYPES.VariableDeclaration:
             declarations(current, state);
             return false;
-          case import_utils33.AST_NODE_TYPES.ReturnStatement:
-          case import_utils33.AST_NODE_TYPES.ThrowStatement:
+          case import_utils34.AST_NODE_TYPES.ReturnStatement:
+          case import_utils34.AST_NODE_TYPES.ThrowStatement:
             if (current.argument !== null) expression(current.argument, state);
             return true;
-          case import_utils33.AST_NODE_TYPES.ExpressionStatement:
+          case import_utils34.AST_NODE_TYPES.ExpressionStatement:
             expression(current.expression, state);
             return false;
           default:
@@ -3732,7 +4103,7 @@ var no_mutating_container_transform_default = createRule({
       }
       function branch(current, state) {
         expression(current.test, state);
-        if (current.test.type === import_utils33.AST_NODE_TYPES.Literal) return current.test.value ? statements([current.consequent], state) : current.alternate !== null && statements([current.alternate], state);
+        if (current.test.type === import_utils34.AST_NODE_TYPES.Literal) return current.test.value ? statements([current.consequent], state) : current.alternate !== null && statements([current.alternate], state);
         const left = new Map(state);
         const right = new Map(state);
         const leftEnds = statements([current.consequent], left);
@@ -3767,60 +4138,8 @@ var no_mutating_container_transform_default = createRule({
 var import_utils36 = require("@typescript-eslint/utils");
 var import_typescript11 = __toESM(require("typescript"), 1);
 
-// src/rules/_checked-native-source.ts
-var import_typescript5 = __toESM(require("typescript"), 1);
-var CHECKED = /* @__PURE__ */ new WeakMap();
-var SINGLE_LINE_DIRECTIVE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/u;
-var MULTI_LINE_DIRECTIVE = /^[/*]*\s*@(?:ts-expect-error|ts-ignore)/u;
-var SINGLE_LINE_PRAGMA = /^\/\/\/?\s*@([^\s:]+)(?:(?:[^\S\r\n]|:).*)?$/mu;
-function currentNativeSource(sourceCode, services) {
-  const source = services.esTreeNodeToTSNodeMap.get(sourceCode.ast);
-  return import_typescript5.default.isSourceFile(source) && services.program.getSourceFile(source.fileName) === source && source.text === sourceCode.text ? source : null;
-}
-function checkedNativeSource(program, source) {
-  let files = CHECKED.get(program);
-  if (!files) {
-    files = /* @__PURE__ */ new WeakMap();
-    CHECKED.set(program, files);
-  }
-  const known2 = files.get(source);
-  if (known2 !== void 0) return known2;
-  const available = !program.getCompilerOptions().noCheck && !source.isDeclarationFile && (source.flags & (import_typescript5.default.NodeFlags.JavaScriptFile | import_typescript5.default.NodeFlags.JsonFile)) === 0 && !program.getProjectReferences()?.length && !program.getResolvedProjectReferences()?.length && program.getSourceFile(source.fileName) === source && !program.isSourceFileFromExternalLibrary(source) && !program.isSourceFileDefaultLibrary(source) && !program.getSyntacticDiagnostics(source).some((diagnostic) => diagnostic.category === import_typescript5.default.DiagnosticCategory.Error && diagnostic.file === source) && !checkingSuppressed(source) && !program.getSemanticDiagnostics(source).some((diagnostic) => diagnostic.category === import_typescript5.default.DiagnosticCategory.Error && diagnostic.file === source);
-  files.set(source, available);
-  return available;
-}
-function checkingSuppressed(source) {
-  if (!/@ts-/iu.test(source.text)) return false;
-  if (import_typescript5.default.getLeadingCommentRanges(source.text, 0)?.some((comment) => comment.kind === import_typescript5.default.SyntaxKind.SingleLineCommentTrivia && SINGLE_LINE_PRAGMA.exec(source.text.slice(comment.pos, comment.end))?.[1]?.toLowerCase() === "ts-nocheck")) return true;
-  const pending = [source];
-  while (pending.length) {
-    const node = pending.pop();
-    if (!node || import_typescript5.default.isJsxText(node) || import_typescript5.default.isJSDoc(node) || (node.flags & import_typescript5.default.NodeFlags.JSDoc) !== 0) continue;
-    if (!import_typescript5.default.isToken(node)) {
-      for (const child of node.getChildren(source)) pending.push(child);
-      continue;
-    }
-    if (tokenTriviaSuppressesChecking(node, source)) return true;
-  }
-  return false;
-}
-function tokenTriviaSuppressesChecking(node, source) {
-  const start = node.getStart(source);
-  for (const comment of [...import_typescript5.default.getLeadingCommentRanges(source.text, node.pos) ?? [], ...import_typescript5.default.getTrailingCommentRanges(source.text, node.pos) ?? []]) {
-    if (comment.pos < node.pos || comment.end > start) continue;
-    if (commentSuppressesChecking(source.text.slice(comment.pos, comment.end), comment.kind)) return true;
-  }
-  return false;
-}
-function commentSuppressesChecking(text, kind) {
-  if (kind === import_typescript5.default.SyntaxKind.SingleLineCommentTrivia) return SINGLE_LINE_DIRECTIVE.test(text);
-  let lastLine = text.length;
-  while (lastLine > 0 && !import_typescript5.default.isLineBreak(text.charCodeAt(lastLine - 1))) lastLine--;
-  return MULTI_LINE_DIRECTIVE.test(text.slice(lastLine).trimStart());
-}
-
 // src/rules/_closed-object-contract.ts
-var import_typescript6 = __toESM(require("typescript"), 1);
+var import_typescript9 = __toESM(require("typescript"), 1);
 function closedObjectContract(type, checker, singlePropertyOrigins = false) {
   return visitContract(type, {
     checker,
@@ -3842,7 +4161,7 @@ function visitContract(type, proof) {
 function completeObject(type, proof) {
   if (!ordinaryObject(type, proof.checker)) return false;
   if (proof.origins && !singleOrigins(type, proof.origins)) return false;
-  const declarations = type.getSymbol()?.getDeclarations()?.filter((declaration) => import_typescript6.default.isInterfaceDeclaration(declaration) || import_typescript6.default.isTypeLiteralNode(declaration));
+  const declarations = type.getSymbol()?.getDeclarations()?.filter((declaration) => import_typescript9.default.isInterfaceDeclaration(declaration) || import_typescript9.default.isTypeLiteralNode(declaration));
   if (!declarations?.length) return false;
   return declarations.every((declaration) => completeDeclaration(declaration, proof));
 }
@@ -3856,36 +4175,36 @@ function singleOrigins(type, origins) {
   return true;
 }
 function ordinaryObject(type, checker) {
-  if ((type.flags & import_typescript6.default.TypeFlags.Object) === 0 || type.isUnion() || checker.getIndexInfosOfType(type).length > 0) return false;
+  if ((type.flags & import_typescript9.default.TypeFlags.Object) === 0 || type.isUnion() || checker.getIndexInfosOfType(type).length > 0) return false;
   const object = type;
-  if ((object.objectFlags & (import_typescript6.default.ObjectFlags.Class | import_typescript6.default.ObjectFlags.Mapped)) !== 0) return false;
-  if ((object.objectFlags & import_typescript6.default.ObjectFlags.Reference) !== 0 && checker.getTypeArguments(type).some((argument) => (argument.flags & (import_typescript6.default.TypeFlags.Any | import_typescript6.default.TypeFlags.Unknown | import_typescript6.default.TypeFlags.TypeParameter)) !== 0)) return false;
-  return checker.getSignaturesOfType(type, import_typescript6.default.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, import_typescript6.default.SignatureKind.Construct).length === 0;
+  if ((object.objectFlags & (import_typescript9.default.ObjectFlags.Class | import_typescript9.default.ObjectFlags.Mapped)) !== 0) return false;
+  if ((object.objectFlags & import_typescript9.default.ObjectFlags.Reference) !== 0 && checker.getTypeArguments(type).some((argument) => (argument.flags & (import_typescript9.default.TypeFlags.Any | import_typescript9.default.TypeFlags.Unknown | import_typescript9.default.TypeFlags.TypeParameter)) !== 0)) return false;
+  return checker.getSignaturesOfType(type, import_typescript9.default.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, import_typescript9.default.SignatureKind.Construct).length === 0;
 }
 function completeDeclaration(declaration, proof) {
   if (!declaration.members.every((member3) => finiteMember(member3, proof.checker))) return false;
-  if (!import_typescript6.default.isInterfaceDeclaration(declaration)) return true;
+  if (!import_typescript9.default.isInterfaceDeclaration(declaration)) return true;
   if (declaration.typeParameters?.length) return false;
   return (declaration.heritageClauses ?? []).every((heritage) => heritage.types.every((base) => visitContract(proof.checker.getTypeAtLocation(base), proof)));
 }
 function finiteMember(member3, checker) {
-  if (import_typescript6.default.isIndexSignatureDeclaration(member3)) return false;
-  if (!member3.name || !import_typescript6.default.isComputedPropertyName(member3.name)) return true;
-  return (checker.getTypeAtLocation(member3.name.expression).flags & (import_typescript6.default.TypeFlags.StringLiteral | import_typescript6.default.TypeFlags.NumberLiteral | import_typescript6.default.TypeFlags.UniqueESSymbol)) !== 0;
+  if (import_typescript9.default.isIndexSignatureDeclaration(member3)) return false;
+  if (!member3.name || !import_typescript9.default.isComputedPropertyName(member3.name)) return true;
+  return (checker.getTypeAtLocation(member3.name.expression).flags & (import_typescript9.default.TypeFlags.StringLiteral | import_typescript9.default.TypeFlags.NumberLiteral | import_typescript9.default.TypeFlags.UniqueESSymbol)) !== 0;
 }
 
 // src/rules/_private-consumer-fix.ts
-var import_utils34 = require("@typescript-eslint/utils");
-var import_typescript7 = __toESM(require("typescript"), 1);
-var UNSAFE = import_typescript7.default.TypeFlags.Any | import_typescript7.default.TypeFlags.Unknown | import_typescript7.default.TypeFlags.Never | import_typescript7.default.TypeFlags.TypeParameter | import_typescript7.default.TypeFlags.Conditional | import_typescript7.default.TypeFlags.IndexedAccess | import_typescript7.default.TypeFlags.Substitution;
+var import_utils35 = require("@typescript-eslint/utils");
+var import_typescript10 = __toESM(require("typescript"), 1);
+var UNSAFE = import_typescript10.default.TypeFlags.Any | import_typescript10.default.TypeFlags.Unknown | import_typescript10.default.TypeFlags.Never | import_typescript10.default.TypeFlags.TypeParameter | import_typescript10.default.TypeFlags.Conditional | import_typescript10.default.TypeFlags.IndexedAccess | import_typescript10.default.TypeFlags.Substitution;
 function validConsumerFixCalls(node, parameter, sourceCode, services) {
   if (sourceCode.getAllComments().some((comment) => /@ts-(?:expect-error|ignore|nocheck)\b/u.test(comment.value))) return false;
-  const owner = node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration ? node : node.parent;
-  if (owner.type !== import_utils34.AST_NODE_TYPES.FunctionDeclaration && owner.type !== import_utils34.AST_NODE_TYPES.VariableDeclarator) return false;
+  const owner = node.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration ? node : node.parent;
+  if (owner.type !== import_utils35.AST_NODE_TYPES.FunctionDeclaration && owner.type !== import_utils35.AST_NODE_TYPES.VariableDeclarator) return false;
   const binding3 = sourceCode.getDeclaredVariables(owner).find((variable) => variable.defs.some((definition) => definition.node === owner && (definition.type === "FunctionName" || definition.type === "Variable")));
   if (!binding3) return false;
   const declaration = services.esTreeNodeToTSNodeMap.get(node);
-  if (!import_typescript7.default.isFunctionDeclaration(declaration) && !import_typescript7.default.isArrowFunction(declaration) || parameter.parent !== declaration || declaration.parameters.some((entry) => import_typescript7.default.isIdentifier(entry.name) && entry.name.text === "this")) return false;
+  if (!import_typescript10.default.isFunctionDeclaration(declaration) && !import_typescript10.default.isArrowFunction(declaration) || parameter.parent !== declaration || declaration.parameters.some((entry) => import_typescript10.default.isIdentifier(entry.name) && entry.name.text === "this")) return false;
   const selected = declaration.parameters.indexOf(parameter);
   if (selected < 0) return false;
   const checker = services.program.getTypeChecker();
@@ -3901,7 +4220,7 @@ function validConsumerFixCalls(node, parameter, sourceCode, services) {
   const validArguments = (call) => {
     if (declaration.parameters.length > 1) {
       const nativeCall = services.esTreeNodeToTSNodeMap.get(call);
-      if (!import_typescript7.default.isCallExpression(nativeCall) || checker.getResolvedSignature(nativeCall)?.declaration !== declaration) return false;
+      if (!import_typescript10.default.isCallExpression(nativeCall) || checker.getResolvedSignature(nativeCall)?.declaration !== declaration) return false;
     }
     return call.arguments.every((argument, index) => {
       const target = originals[index];
@@ -3917,7 +4236,7 @@ function validConsumerFixCalls(node, parameter, sourceCode, services) {
       continue;
     }
     const call = reference.identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils34.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== declaration.parameters.length || !call.arguments.every((argument) => argument.type === import_utils34.AST_NODE_TYPES.Identifier) || !validArguments(call)) return false;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils35.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== declaration.parameters.length || !call.arguments.every((argument) => argument.type === import_utils35.AST_NODE_TYPES.Identifier) || !validArguments(call)) return false;
     calls += 1;
   }
   return calls > 0;
@@ -3968,250 +4287,6 @@ function minimalConsumerFix(sourceCode, annotation, removed) {
   return sameLineTerminators(sourceCode, annotation, text) ? (fixer) => fixer.replaceText(annotation, text) : null;
 }
 
-// src/rules/_private-scalar-consumer.ts
-var import_utils35 = require("@typescript-eslint/utils");
-var import_typescript10 = __toESM(require("typescript"), 1);
-
-// src/rules/_scalar-parameter-view.ts
-var import_typescript9 = __toESM(require("typescript"), 1);
-
-// src/rules/_native-const-value.ts
-var import_typescript8 = __toESM(require("typescript"), 1);
-function constInitializer(declaration) {
-  if (!declaration || !import_typescript8.default.isVariableDeclaration(declaration) || !import_typescript8.default.isVariableDeclarationList(declaration.parent) || (declaration.parent.flags & import_typescript8.default.NodeFlags.BlockScoped) !== import_typescript8.default.NodeFlags.Const) return void 0;
-  let initializer = declaration.initializer;
-  while (initializer && import_typescript8.default.isParenthesizedExpression(initializer)) initializer = initializer.expression;
-  return initializer;
-}
-function unassertedValue(node) {
-  let value = node;
-  while (import_typescript8.default.isParenthesizedExpression(value) || import_typescript8.default.isAsExpression(value) || import_typescript8.default.isTypeAssertionExpression(value) || import_typescript8.default.isNonNullExpression(value) || import_typescript8.default.isSatisfiesExpression(value)) value = value.expression;
-  return value;
-}
-
-// src/rules/_scalar-parameter-view.ts
-var SCALAR_OPERATORS = /* @__PURE__ */ new Set([
-  import_typescript9.default.SyntaxKind.PlusToken,
-  import_typescript9.default.SyntaxKind.MinusToken,
-  import_typescript9.default.SyntaxKind.AsteriskToken,
-  import_typescript9.default.SyntaxKind.SlashToken,
-  import_typescript9.default.SyntaxKind.PercentToken,
-  import_typescript9.default.SyntaxKind.AsteriskAsteriskToken,
-  import_typescript9.default.SyntaxKind.LessThanToken,
-  import_typescript9.default.SyntaxKind.LessThanEqualsToken,
-  import_typescript9.default.SyntaxKind.GreaterThanToken,
-  import_typescript9.default.SyntaxKind.GreaterThanEqualsToken,
-  import_typescript9.default.SyntaxKind.EqualsEqualsEqualsToken,
-  import_typescript9.default.SyntaxKind.ExclamationEqualsEqualsToken,
-  import_typescript9.default.SyntaxKind.EqualsEqualsToken,
-  import_typescript9.default.SyntaxKind.ExclamationEqualsToken,
-  import_typescript9.default.SyntaxKind.AmpersandAmpersandToken,
-  import_typescript9.default.SyntaxKind.BarBarToken,
-  import_typescript9.default.SyntaxKind.QuestionQuestionToken
-]);
-var SCALAR_PREFIXES = /* @__PURE__ */ new Set([import_typescript9.default.SyntaxKind.PlusToken, import_typescript9.default.SyntaxKind.MinusToken, import_typescript9.default.SyntaxKind.ExclamationToken, import_typescript9.default.SyntaxKind.TildeToken]);
-var RETURNED_OPERANDS = /* @__PURE__ */ new Set([import_typescript9.default.SyntaxKind.AmpersandAmpersandToken, import_typescript9.default.SyntaxKind.BarBarToken, import_typescript9.default.SyntaxKind.QuestionQuestionToken]);
-function scalarParameterView(parameter, body3, checker) {
-  return parameterReads(parameter, body3, checker, true);
-}
-function scalarParameterReads(parameter, body3, checker, callProgram, auxiliaries) {
-  return parameterReads(parameter, body3, checker, false, callProgram, auxiliaries);
-}
-function parameterReads(parameter, body3, checker, jsx, callProgram, auxiliaries) {
-  if (parameter.dotDotDotToken || parameter.initializer || import_typescript9.default.isArrayBindingPattern(parameter.name)) return null;
-  const root = import_typescript9.default.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
-  if (import_typescript9.default.isIdentifier(parameter.name) && !root) return null;
-  const reads = /* @__PURE__ */ new Set();
-  const aliases = parameterAliases(parameter.name, checker, reads);
-  if (!aliases) return null;
-  const expression = returnedExpression(body3);
-  const view = { checker, props: checker.getTypeAtLocation(parameter), root, aliases, reads, callProgram, auxiliaries };
-  return expression && scalarView(expression, view, jsx) ? reads : null;
-}
-function scalarType(type, allowUndefined = true) {
-  if (type.isUnion()) return type.types.every((part) => scalarType(part, allowUndefined));
-  const flags = import_typescript9.default.TypeFlags.StringLike | import_typescript9.default.TypeFlags.NumberLike | import_typescript9.default.TypeFlags.BooleanLike | import_typescript9.default.TypeFlags.BigIntLike | import_typescript9.default.TypeFlags.Null;
-  return (type.flags & (allowUndefined ? flags | import_typescript9.default.TypeFlags.Undefined : flags)) !== 0;
-}
-function parameterAliases(name, checker, reads) {
-  const aliases = /* @__PURE__ */ new Map();
-  if (import_typescript9.default.isIdentifier(name)) return aliases;
-  for (const element of name.elements) {
-    const key = element.propertyName ?? element.name;
-    if (element.dotDotDotToken || element.initializer || !import_typescript9.default.isIdentifier(element.name) || !import_typescript9.default.isIdentifier(key) && !import_typescript9.default.isStringLiteralLike(key) && !import_typescript9.default.isNumericLiteral(key)) return null;
-    const binding3 = checker.getSymbolAtLocation(element.name);
-    if (!binding3) return null;
-    reads.add(key.text);
-    aliases.set(binding3, key.text);
-  }
-  return aliases;
-}
-function returnedExpression(body3) {
-  if (!import_typescript9.default.isBlock(body3)) return body3;
-  const statement = body3.statements.length === 1 ? body3.statements[0] : void 0;
-  return statement && import_typescript9.default.isReturnStatement(statement) ? statement.expression : void 0;
-}
-function scalarView(node, view, jsx = false) {
-  if (scalarLiteral(node)) return true;
-  if (import_typescript9.default.isCallExpression(node)) return !jsx && scalarCall(node, view);
-  if (import_typescript9.default.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view, jsx));
-  if (import_typescript9.default.isIdentifier(node)) {
-    const binding3 = view.checker.getSymbolAtLocation(node);
-    if (binding3 && view.auxiliaries?.has(binding3)) return scalarType(view.checker.getTypeAtLocation(node));
-    const key = binding3 && view.aliases.get(binding3);
-    return key !== void 0 && readField(node, key, view);
-  }
-  if (import_typescript9.default.isPropertyAccessExpression(node) || import_typescript9.default.isElementAccessExpression(node)) return memberRead(node, view);
-  return scalarOperation(node, view, jsx);
-}
-function scalarOperation(node, view, jsx) {
-  if (import_typescript9.default.isParenthesizedExpression(node) || import_typescript9.default.isNonNullExpression(node)) return scalarView(node.expression, view, jsx);
-  if (import_typescript9.default.isTypeOfExpression(node)) return scalarView(node.expression, view);
-  if (import_typescript9.default.isConditionalExpression(node)) return scalarView(node.condition, view) && scalarView(node.whenTrue, view, jsx) && scalarView(node.whenFalse, view, jsx);
-  if (import_typescript9.default.isBinaryExpression(node)) return binaryView(node, view, jsx);
-  if (import_typescript9.default.isPrefixUnaryExpression(node)) return SCALAR_PREFIXES.has(node.operator) && scalarView(node.operand, view);
-  if (import_typescript9.default.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view));
-  return jsx && jsxView(node, view);
-}
-function scalarCall(node, view) {
-  if (!view.callProgram || node.questionDotToken || node.typeArguments?.length || !import_typescript9.default.isIdentifier(node.expression) || !node.arguments.length || node.arguments.some(import_typescript9.default.isSpreadElement)) return false;
-  const declarations = view.checker.getSymbolAtLocation(node.expression)?.declarations;
-  const declaration = declarations?.length === 1 ? declarations[0] : void 0;
-  const helper = declaration && localHelper(declaration);
-  if (!helper || helper.getSourceFile() !== node.getSourceFile() || helper.typeParameters?.length || !helper.type || !node.arguments.every((argument) => scalarView(argument, view))) return false;
-  if (!checkedNativeSource(view.callProgram, node.getSourceFile())) return false;
-  const signature = view.checker.getResolvedSignature(node);
-  return signature?.declaration === helper && !view.checker.getTypePredicateOfSignature(signature) && scalarType(view.checker.getTypeAtLocation(node));
-}
-function localHelper(node) {
-  if (import_typescript9.default.isFunctionDeclaration(node)) return node.body && import_typescript9.default.isSourceFile(node.parent) ? node : void 0;
-  if (!import_typescript9.default.isVariableDeclaration(node) || node.type || !node.initializer || constInitializer(node) !== node.initializer || !import_typescript9.default.isArrowFunction(node.initializer) || !import_typescript9.default.isVariableStatement(node.parent.parent) || !import_typescript9.default.isSourceFile(node.parent.parent.parent)) return void 0;
-  return node.initializer;
-}
-function binaryView(node, view, jsx) {
-  const returned2 = jsx && RETURNED_OPERANDS.has(node.operatorToken.kind);
-  return SCALAR_OPERATORS.has(node.operatorToken.kind) && scalarView(node.left, view, returned2) && scalarView(node.right, view, returned2);
-}
-function scalarLiteral(node) {
-  return import_typescript9.default.isStringLiteralLike(node) || import_typescript9.default.isNumericLiteral(node) || import_typescript9.default.isBigIntLiteral(node) || import_typescript9.default.isJsxText(node) || node.kind === import_typescript9.default.SyntaxKind.TrueKeyword || node.kind === import_typescript9.default.SyntaxKind.FalseKeyword || node.kind === import_typescript9.default.SyntaxKind.NullKeyword;
-}
-function memberRead(node, view) {
-  if (!view.root || !import_typescript9.default.isIdentifier(node.expression) || view.checker.getSymbolAtLocation(node.expression) !== view.root) return false;
-  const key = import_typescript9.default.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && (import_typescript9.default.isStringLiteralLike(node.argumentExpression) || import_typescript9.default.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
-  return key !== void 0 && readField(node, key, view);
-}
-function readField(node, key, view) {
-  if (!view.checker.getPropertyOfType(view.props, key) || !scalarType(view.checker.getTypeAtLocation(node))) return false;
-  view.reads.add(key);
-  return true;
-}
-function jsxView(node, view) {
-  if (import_typescript9.default.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view, true));
-  if (import_typescript9.default.isJsxElement(node)) return jsxView(node.openingElement, view) && node.children.every((child) => scalarView(child, view, true));
-  if (!import_typescript9.default.isJsxOpeningElement(node) && !import_typescript9.default.isJsxSelfClosingElement(node)) return false;
-  if (!import_typescript9.default.isIdentifier(node.tagName) || !/^[a-z][A-Za-z0-9]*$/u.test(node.tagName.text)) return false;
-  return node.attributes.properties.every((attribute) => intrinsicAttribute(attribute, view));
-}
-function intrinsicAttribute(attribute, view) {
-  return import_typescript9.default.isJsxAttribute(attribute) && import_typescript9.default.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view));
-}
-
-// src/rules/_private-scalar-consumer.ts
-function directEval(node) {
-  let callee = unwrapExpression(node.callee);
-  while (callee.type === import_utils35.AST_NODE_TYPES.TSInstantiationExpression) callee = unwrapExpression(callee.expression);
-  return callee.type === import_utils35.AST_NODE_TYPES.Identifier && callee.name === "eval";
-}
-function primitiveKeyword(node) {
-  return node !== void 0 && (node.kind === import_typescript10.default.SyntaxKind.StringKeyword || node.kind === import_typescript10.default.SyntaxKind.NumberKeyword || node.kind === import_typescript10.default.SyntaxKind.BooleanKeyword || node.kind === import_typescript10.default.SyntaxKind.BigIntKeyword);
-}
-function nullishPrimitiveUnion(node) {
-  return node !== void 0 && import_typescript10.default.isUnionTypeNode(node) && node.types.length === 2 && node.types.some(primitiveKeyword) && node.types.some((part) => part.kind === import_typescript10.default.SyntaxKind.UndefinedKeyword || import_typescript10.default.isLiteralTypeNode(part) && part.literal.kind === import_typescript10.default.SyntaxKind.NullKeyword);
-}
-function consumerAnnotation(node, auxiliaryScalars = false) {
-  if (node.params.length !== 1) {
-    if (!auxiliaryScalars) return void 0;
-    let annotation;
-    for (const parameter2 of node.params) {
-      if (parameter2.type !== import_utils35.AST_NODE_TYPES.Identifier && parameter2.type !== import_utils35.AST_NODE_TYPES.ObjectPattern) continue;
-      const current = parameter2.typeAnnotation?.typeAnnotation;
-      if (current?.type !== import_utils35.AST_NODE_TYPES.TSTypeLiteral) continue;
-      if (annotation) return void 0;
-      annotation = current;
-    }
-    return annotation;
-  }
-  const parameter = node.params[0];
-  return parameter?.type === import_utils35.AST_NODE_TYPES.Identifier || parameter?.type === import_utils35.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
-}
-function exportedSymbols(source, checker) {
-  const symbol = checker.getSymbolAtLocation(source);
-  return new Set(symbol ? checker.getExportsOfModule(symbol).map((entry) => (entry.flags & import_typescript10.default.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(entry) : entry) : []);
-}
-function privateScalarConsumer(node, sourceCode, services, exports2, options = {}) {
-  const native = services.esTreeNodeToTSNodeMap.get(node);
-  if (!import_typescript10.default.isFunctionDeclaration(native) && !import_typescript10.default.isArrowFunction(native) || !native.body) return null;
-  let parameter = native.parameters[0];
-  if (native.parameters.length !== 1) {
-    const annotation = consumerAnnotation(node, options.auxiliaryScalars);
-    const selected = annotation && services.esTreeNodeToTSNodeMap.get(annotation);
-    parameter = native.parameters.find((entry) => entry.type === selected);
-  }
-  if (!parameter || !independentSignature(native, parameter, options.auxiliaryScalars === true)) return null;
-  const checker = services.program.getTypeChecker();
-  if (!import_typescript10.default.isExternalModule(native.getSourceFile()) || !services.program.getCompilerOptions().strict) return null;
-  if (!privateDirectCallable(node, native, sourceCode, checker, exports2)) return null;
-  const signature = checker.getSignatureFromDeclaration(native);
-  if (!signature || signature.typeParameters?.length || checker.getTypePredicateOfSignature(signature)) return null;
-  const expression = returnedExpression(native.body);
-  if (!expression || !checker.isTypeAssignableTo(checker.getTypeAtLocation(expression), checker.getReturnTypeOfSignature(signature))) return null;
-  const auxiliaries = native.parameters.length > 1 ? auxiliaryBindings(native, parameter, checker) : void 0;
-  if (auxiliaries === null) return null;
-  const reads = scalarParameterReads(parameter, native.body, checker, options.scalarCalls ? services.program : void 0, auxiliaries);
-  return reads?.size ? { parameter, reads } : null;
-}
-function privateDirectCallable(node, native, sourceCode, checker, exports2) {
-  const binding3 = callableBinding(node, sourceCode);
-  if (!binding3 || binding3.defs.length !== 1) return false;
-  const name = import_typescript10.default.isFunctionDeclaration(native) ? native.name : import_typescript10.default.isVariableDeclaration(native.parent) ? native.parent.name : void 0;
-  const symbol = name && checker.getSymbolAtLocation(name);
-  return symbol !== void 0 && symbol.declarations?.length === 1 && !exports2.has(symbol) && directCalls(binding3, native.parameters.length);
-}
-function independentSignature(native, selected, auxiliaryScalars) {
-  if (!auxiliaryScalars && native.parameters.length !== 1 || native.typeParameters?.length || native.asteriskToken || native.modifiers?.length || !primitiveKeyword(native.type)) return false;
-  return native.parameters.every((parameter) => parameter.type !== void 0 && !parameter.modifiers?.length && !parameter.questionToken && !parameter.initializer && !parameter.dotDotDotToken && (!import_typescript10.default.isIdentifier(parameter.name) || parameter.name.text !== "this") && (parameter === selected || import_typescript10.default.isIdentifier(parameter.name) && primitiveKeyword(parameter.type)));
-}
-function auxiliaryBindings(native, selected, checker) {
-  const bindings = /* @__PURE__ */ new Set();
-  for (const parameter of native.parameters) {
-    if (parameter === selected) continue;
-    const symbol = import_typescript10.default.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
-    if (!symbol || symbol.declarations?.length !== 1 || symbol.declarations[0] !== parameter || bindings.has(symbol)) return null;
-    bindings.add(symbol);
-  }
-  return bindings;
-}
-function callableBinding(node, sourceCode) {
-  if (node.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration) {
-    if (node.parent.type !== import_utils35.AST_NODE_TYPES.Program) return void 0;
-    return sourceCode.getDeclaredVariables(node).find((variable) => variable.defs.some((definition) => definition.type === "FunctionName" && definition.node === node));
-  }
-  const declaration = node.parent;
-  if (declaration.type !== import_utils35.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils35.AST_NODE_TYPES.Identifier || declaration.id.typeAnnotation || declaration.parent.kind !== "const" || declaration.parent.parent.type !== import_utils35.AST_NODE_TYPES.Program) return void 0;
-  return sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
-}
-function directCalls(binding3, arity) {
-  let calls = 0;
-  const stable2 = stableValueBinding(binding3, (reference) => {
-    const identifier = reference.identifier;
-    const call = identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils35.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== arity || !call.arguments.every((argument) => argument.type === import_utils35.AST_NODE_TYPES.Identifier)) return false;
-    calls += 1;
-    return true;
-  });
-  return stable2 && calls > 0;
-}
-
 // src/rules/no-redundant-consumer-union.ts
 var CONFIG3 = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler"}}' };
 var EXAMPLE = 'export {}; interface Animal {readonly name: string} interface Dog extends Animal {readonly breed: string} export type KeptDog = Dog; const dog: Dog = {name: "Ada", breed: "Collie"}; function label(value: Dog | Animal): string {return value.name;} label(dog);';
@@ -5539,7 +5614,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "18.0.3",
+  version: "18.0.5",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -28703,7 +28778,7 @@ var import_utils165 = require("@typescript-eslint/utils");
 
 // src/rules/_existing-type-alias-fix.ts
 var import_utils164 = require("@typescript-eslint/utils");
-var PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+var PRIMITIVE_TYPES2 = /* @__PURE__ */ new Set([
   "TSStringKeyword",
   "TSNumberKeyword",
   "TSBooleanKeyword",
@@ -28760,7 +28835,7 @@ function tokenSignature(sourceCode, node) {
   );
 }
 function closedType(node) {
-  if (PRIMITIVE_TYPES.has(node.type)) return true;
+  if (PRIMITIVE_TYPES2.has(node.type)) return true;
   switch (node.type) {
     case import_utils164.AST_NODE_TYPES.TSLiteralType:
       return node.literal.type === import_utils164.AST_NODE_TYPES.Literal || node.literal.type === import_utils164.AST_NODE_TYPES.UnaryExpression && node.literal.operator === "-" && node.literal.argument.type === import_utils164.AST_NODE_TYPES.Literal;
@@ -30748,8 +30823,8 @@ var memberValidationPolarity = (test, access) => {
   }
   if (test.type === import_utils173.AST_NODE_TYPES.BinaryExpression) {
     const isMatchingTypeof = (node) => node.type === import_utils173.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === import_utils173.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))) {
+    const isPrimitiveType2 = (node) => node.type === import_utils173.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+    if (!(isMatchingTypeof(test.left) && isPrimitiveType2(test.right) || isMatchingTypeof(test.right) && isPrimitiveType2(test.left))) {
       return null;
     }
     if (test.operator === "===" || test.operator === "==") {