@sarj/eslint-plugin 16.36.6 → 16.38.50

package/dist/index.cjs

@@ -678,41 +678,230 @@ var no_mutating_input_with_result_default = createRule({
 });
 
 // src/rules/no-negative-only-http-status-assertion.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils10 = require("@typescript-eslint/utils");
 
 // src/rules/_native-fetch-reference.ts
+var import_utils8 = require("@typescript-eslint/utils");
+
+// src/rules/_native-runtime-unchanged.ts
+var import_utils7 = require("@typescript-eslint/utils");
+
+// src/rules/_stable-value-binding.ts
 var import_utils5 = require("@typescript-eslint/utils");
+function typeOnlyReference(reference) {
+  if (reference.isTypeReference && !reference.isValueReference) return true;
+  let current = outerExpression(reference.identifier);
+  while (current.parent?.type === import_utils5.AST_NODE_TYPES.TSQualifiedName && current.parent.left === current) {
+    current = current.parent;
+  }
+  return current.parent?.type === import_utils5.AST_NODE_TYPES.TSTypeQuery && current.parent.exprName === current;
+}
+function stableValueBinding(variable, acceptRead) {
+  let initializer;
+  return variable.references.every((reference) => {
+    if (!reference.isWrite()) return acceptRead?.(reference) ?? true;
+    if (reference.init !== true || initializer !== void 0 && initializer !== reference.identifier) return false;
+    initializer = reference.identifier;
+    return true;
+  });
+}
+
+// src/rules/_static-string.ts
+var import_utils6 = require("@typescript-eslint/utils");
+function staticString(node) {
+  if (node === void 0) return null;
+  const value = unwrapExpression(node);
+  if (value.type === import_utils6.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
+  return value.type === import_utils6.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_utils6.AST_NODE_TYPES.Identifier) return staticString(value);
+  let values = SCOPED_STRING_VALUES.get(sourceCode);
+  if (values === void 0) {
+    values = /* @__PURE__ */ new WeakMap();
+    SCOPED_STRING_VALUES.set(sourceCode, values);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [];
+  let result = null;
+  while (value.type === import_utils6.AST_NODE_TYPES.Identifier) {
+    const binding3 = import_utils6.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+    if (binding3 === null || seen.has(binding3)) break;
+    if (values.has(binding3)) {
+      result = values.get(binding3) ?? null;
+      break;
+    }
+    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_utils6.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_utils6.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_utils6.ASTUtils.getPropertyName(node);
+  if (direct !== null || !node.computed) return direct;
+  const key = node.type === import_utils6.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
+  return scopedStaticString(key, sourceCode);
+}
+
+// src/rules/_native-runtime-unchanged.ts
+var INDEXES = /* @__PURE__ */ new WeakMap();
+var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "global", "window", "self"]);
+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_utils7.AST_NODE_TYPES.MemberExpression && staticPropertyName(node, sourceCode) === "constructor" || name === "fetch" && node.type === import_utils7.AST_NODE_TYPES.Property && node.parent.type === import_utils7.AST_NODE_TYPES.ObjectPattern && staticPropertyName(node, sourceCode) === "constructor" || name === "RegExp" && node.type === import_utils7.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;
+}
+function runtimeIndex(sourceCode) {
+  const cached = INDEXES.get(sourceCode);
+  if (cached !== void 0) return cached;
+  const references = sourceCode.scopeManager?.scopes.flatMap((scope) => scope.references.filter((reference) => reference.isValueReference !== false)) ?? [];
+  const nodes = [];
+  const pending = [sourceCode.ast];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (node === void 0) continue;
+    nodes.push(node);
+    forEachAstChild(node, sourceCode.visitorKeys, (child) => {
+      pending.push(child);
+    });
+  }
+  const index = { references, nodes, results: /* @__PURE__ */ new Map(), fetchAliases: /* @__PURE__ */ new Map() };
+  INDEXES.set(sourceCode, index);
+  return index;
+}
+function unsafeReference(node, sourceCode, name, index) {
+  if (!ambient(node, sourceCode)) return false;
+  if (node.name === "eval" || node.name === "Function") return true;
+  if (node.name === name) return name === "fetch" ? !fetchRead(node, sourceCode, index) : !nativeRead(node, name);
+  if (!GLOBAL_OBJECTS.has(node.name)) return false;
+  const value = outerExpression(node);
+  const property = value.parent;
+  if (name === "fetch" && property?.type === import_utils7.AST_NODE_TYPES.UnaryExpression && property.operator === "typeof") return false;
+  if (property?.type !== import_utils7.AST_NODE_TYPES.MemberExpression || property.object !== value) {
+    return name !== "fetch" || !fetchProjection(value, sourceCode, index);
+  }
+  const key = staticPropertyName(property, sourceCode);
+  if (key === null || key === "eval" || key === "Function" || key === "constructor") return true;
+  if (name === "fetch" && GLOBAL_OBJECTS.has(key)) return true;
+  return key === name && !(name === "fetch" ? fetchRead(property, sourceCode, index) : nativeRead(property, name));
+}
+function ambient(node, sourceCode) {
+  const variable = import_utils7.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_utils7.AST_NODE_TYPES.CallExpression && parent.callee === value || parent?.type === import_utils7.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
+  if (parent?.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator || parent.init !== value || parent.id.type !== import_utils7.AST_NODE_TYPES.Identifier) return false;
+  return stableConstBinding(parent.id, sourceCode) ?? false;
+}
+function stableConstBinding(node, sourceCode) {
+  const binding3 = import_utils7.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_utils7.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);
+  return use === true || use !== false && fetchAliasRead(use, sourceCode, index);
+}
+function fetchAliasRead(binding3, sourceCode, index) {
+  const pending = [binding3];
+  const visited = [];
+  let safe = true;
+  while (pending.length > 0 && safe) {
+    const current = pending.pop();
+    if (current === void 0) continue;
+    const cached = index.fetchAliases.get(current);
+    if (cached === "safe") continue;
+    if (cached !== void 0) {
+      safe = false;
+      break;
+    }
+    index.fetchAliases.set(current, "visiting");
+    visited.push(current);
+    const captures = fetchAliasCaptures(current, sourceCode);
+    if (captures === false) {
+      safe = false;
+      break;
+    }
+    for (const captured of captures) pending.push(captured);
+  }
+  for (const current of visited) index.fetchAliases.set(current, safe ? "safe" : "unsafe");
+  return safe;
+}
+function fetchAliasCaptures(binding3, sourceCode) {
+  const captures = [];
+  for (const reference of binding3.references) {
+    if (reference.isValueReference === false || reference.init === true || typeOnlyReference(reference)) continue;
+    const use = fetchUse(reference.identifier, sourceCode);
+    if (use === false) return false;
+    if (use !== true) captures.push(use);
+  }
+  return captures;
+}
+function fetchProjection(node, sourceCode, index) {
+  const declaration = node.parent;
+  if (declaration?.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils7.AST_NODE_TYPES.ObjectPattern || declaration.id.properties.length !== 1) return false;
+  const [property] = declaration.id.properties;
+  if (property?.type !== import_utils7.AST_NODE_TYPES.Property || staticPropertyName(property, sourceCode) !== "fetch" || property.value.type !== import_utils7.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_utils7.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
+  if (name !== "Error") return false;
+  return parent?.type === import_utils7.AST_NODE_TYPES.NewExpression && parent.callee === value || parent?.type === import_utils7.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.right === value;
+}
+
+// src/rules/_native-fetch-reference.ts
 var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
-function nativeFetchReference(node, sourceCode, seen = /* @__PURE__ */ new Set()) {
+function nativeFetchReference(node, sourceCode) {
+  return lexicalFetchReference(node, sourceCode) && nativeRuntimeUnchanged(sourceCode, "fetch");
+}
+function lexicalFetchReference(node, sourceCode, seen = /* @__PURE__ */ new Set()) {
   const expression = unwrapExpression(node);
-  if (expression.type === import_utils5.AST_NODE_TYPES.MemberExpression) {
-    return import_utils5.ASTUtils.getPropertyName(expression) === "fetch" && globalReceiver(expression.object, sourceCode);
+  if (expression.type === import_utils8.AST_NODE_TYPES.MemberExpression) {
+    return staticPropertyName(expression, sourceCode) === "fetch" && globalReceiver(expression.object, sourceCode);
   }
-  if (expression.type !== import_utils5.AST_NODE_TYPES.Identifier) return false;
-  const binding3 = import_utils5.ASTUtils.findVariable(sourceCode.getScope(expression), expression.name);
+  if (expression.type !== import_utils8.AST_NODE_TYPES.Identifier) return false;
+  const binding3 = import_utils8.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_utils5.AST_NODE_TYPES.Identifier) {
-    return nativeFetchReference(definition.node.init, sourceCode, seen);
+  if (definition.node.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
+    return lexicalFetchReference(definition.node.init, sourceCode, seen);
   }
-  return definition.node.id.type === import_utils5.AST_NODE_TYPES.ObjectPattern && globalReceiver(definition.node.init, sourceCode) && definition.node.id.properties.some((property) => property.type === import_utils5.AST_NODE_TYPES.Property && import_utils5.ASTUtils.getPropertyName(property) === "fetch" && property.value.type === import_utils5.AST_NODE_TYPES.Identifier && import_utils5.ASTUtils.findVariable(sourceCode.getScope(property.value), property.value.name) === binding3);
+  return definition.node.id.type === import_utils8.AST_NODE_TYPES.ObjectPattern && globalReceiver(definition.node.init, sourceCode) && definition.node.id.properties.some((property) => property.type === import_utils8.AST_NODE_TYPES.Property && staticPropertyName(property, sourceCode) === "fetch" && property.value.type === import_utils8.AST_NODE_TYPES.Identifier && import_utils8.ASTUtils.findVariable(sourceCode.getScope(property.value), property.value.name) === binding3);
 }
 function globalReceiver(node, sourceCode) {
   const receiver = unwrapExpression(node);
-  return receiver.type === import_utils5.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS.has(receiver.name) && !import_utils5.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
+  return receiver.type === import_utils8.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS.has(receiver.name) && !import_utils8.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
 }
 
 // src/rules/_test-mock-provenance.ts
-var import_utils6 = require("@typescript-eslint/utils");
+var import_utils9 = require("@typescript-eslint/utils");
 function importedTestMockNamespace(source, identifier) {
-  const binding3 = import_utils6.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils9.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   const importedBinding = runtimeImportBinding(binding3);
-  if (importedBinding === null || importedBinding.specifier.type !== import_utils6.AST_NODE_TYPES.ImportSpecifier) return null;
+  if (importedBinding === null || importedBinding.specifier.type !== import_utils9.AST_NODE_TYPES.ImportSpecifier) return null;
   const specifier = importedBinding.specifier;
-  const imported = specifier.imported.type === import_utils6.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+  const imported = specifier.imported.type === import_utils9.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";
@@ -720,12 +909,12 @@ function importedTestMockNamespace(source, identifier) {
 }
 function isUnshadowedTestMockGlobal(source, identifier) {
   if (identifier.name !== "vi" && identifier.name !== "jest") return false;
-  const binding3 = import_utils6.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils9.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_utils6.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const binding3 = import_utils9.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
   if (binding3 === null || binding3.defs.length === 0) {
     return binding3?.references.some((reference) => reference.isWrite()) ? null : identifier.name;
   }
@@ -733,22 +922,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_utils6.AST_NODE_TYPES.ImportSpecifier) {
+  if (specifier.type === import_utils9.AST_NODE_TYPES.ImportSpecifier) {
     if (isNodeAssertion) return "assert";
     if (!TEST_FRAMEWORK_MODULES.has(module2)) return null;
-    const imported = specifier.imported.type === import_utils6.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+    const imported = specifier.imported.type === import_utils9.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_utils6.AST_NODE_TYPES.ImportDefaultSpecifier ? "test" : null;
+  return kind === "test" && module2 === "node:test" && specifier.type === import_utils9.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_utils6.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type") return null;
+  if (definition?.type !== "ImportBinding" || definition.parent.type !== import_utils9.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type") return null;
   const specifier = definition.node;
-  if (specifier.type !== import_utils6.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils6.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils6.AST_NODE_TYPES.ImportNamespaceSpecifier) return null;
-  if (specifier.type === import_utils6.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") return null;
+  if (specifier.type !== import_utils9.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils9.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils9.AST_NODE_TYPES.ImportNamespaceSpecifier) return null;
+  if (specifier.type === import_utils9.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") return null;
   return { module: definition.parent.source.value, specifier };
 }
 function vitestFixtureTestName(source, identifier) {
@@ -756,24 +945,24 @@ function vitestFixtureTestName(source, identifier) {
 }
 function fixtureTestName(node, source, seen) {
   node = unwrapExpression(node);
-  if (node.type === import_utils6.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils9.AST_NODE_TYPES.CallExpression) {
     const callee = unwrapExpression(node.callee);
-    return !node.optional && callee.type === import_utils6.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils6.ASTUtils.getPropertyName(callee) === "extend" && node.arguments.length > 0 && !node.arguments.some((argument) => argument.type === import_utils6.AST_NODE_TYPES.SpreadElement) ? fixtureTestName(callee.object, source, seen) : null;
+    return !node.optional && callee.type === import_utils9.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils9.ASTUtils.getPropertyName(callee) === "extend" && node.arguments.length > 0 && !node.arguments.some((argument) => argument.type === import_utils9.AST_NODE_TYPES.SpreadElement) ? fixtureTestName(callee.object, source, seen) : null;
   }
-  if (node.type !== import_utils6.AST_NODE_TYPES.Identifier) return null;
-  const binding3 = import_utils6.ASTUtils.findVariable(source.getScope(node), node.name);
+  if (node.type !== import_utils9.AST_NODE_TYPES.Identifier) return null;
+  const binding3 = import_utils9.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_utils6.AST_NODE_TYPES.ImportSpecifier) {
+  if (imported?.module === "vitest" && imported.specifier.type === import_utils9.AST_NODE_TYPES.ImportSpecifier) {
     const name = imported.specifier.imported;
-    const value = name.type === import_utils6.AST_NODE_TYPES.Identifier ? name.name : name.value;
+    const value = name.type === import_utils9.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_utils6.AST_NODE_TYPES.VariableDeclarator || definition.node.id.type !== import_utils6.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_utils9.AST_NODE_TYPES.VariableDeclarator || definition.node.id.type !== import_utils9.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_utils6.AST_NODE_TYPES.CallExpression ? fixtureTestName(initializer, source, seen) : null;
+  return initializer.type === import_utils9.AST_NODE_TYPES.CallExpression ? fixtureTestName(initializer, source, seen) : null;
 }
 var FIXTURE_API_STABILITY = /* @__PURE__ */ new WeakMap();
 function unchangedFixtureApi(binding3) {
@@ -783,9 +972,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_utils6.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = outerExpression(use.parent);
+    while (use.parent?.type === import_utils9.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = outerExpression(use.parent);
     const parent = use.parent;
-    return parent?.type === import_utils6.AST_NODE_TYPES.CallExpression && parent.callee === use || parent?.type === import_utils6.AST_NODE_TYPES.ExportSpecifier || parent?.type === import_utils6.AST_NODE_TYPES.ExportDefaultDeclaration || parent?.type === import_utils6.AST_NODE_TYPES.TSTypeQuery || parent?.type === import_utils6.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof";
+    return parent?.type === import_utils9.AST_NODE_TYPES.CallExpression && parent.callee === use || parent?.type === import_utils9.AST_NODE_TYPES.ExportSpecifier || parent?.type === import_utils9.AST_NODE_TYPES.ExportDefaultDeclaration || parent?.type === import_utils9.AST_NODE_TYPES.TSTypeQuery || parent?.type === import_utils9.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof";
   });
   FIXTURE_API_STABILITY.set(binding3, unchanged);
   return unchanged;
@@ -815,72 +1004,72 @@ var NO_NEGATIVE_ONLY_HTTP_STATUS_ASSERTION_DOCUMENTATION = {
   ]
 };
 function statusAssertion(source, call) {
-  if (call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils7.AST_NODE_TYPES.Literal || typeof call.arguments[0].value !== "number" || call.callee.type !== import_utils7.AST_NODE_TYPES.MemberExpression) return null;
-  const matcher = import_utils7.ASTUtils.getPropertyName(call.callee);
+  if (call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils10.AST_NODE_TYPES.Literal || typeof call.arguments[0].value !== "number" || call.callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression) return null;
+  const matcher = import_utils10.ASTUtils.getPropertyName(call.callee);
   if (matcher === null) return null;
   let object = unwrapExpression(call.callee.object);
-  const negative = object.type === import_utils7.AST_NODE_TYPES.MemberExpression && import_utils7.ASTUtils.getPropertyName(object) === "not";
-  if (negative && object.type === import_utils7.AST_NODE_TYPES.MemberExpression) object = unwrapExpression(object.object);
-  if (object.type !== import_utils7.AST_NODE_TYPES.CallExpression || object.arguments.length !== 1 || object.callee.type !== import_utils7.AST_NODE_TYPES.Identifier || runtimeTestFrameworkName(source, object.callee, "assertion") !== "expect") return null;
+  const negative = object.type === import_utils10.AST_NODE_TYPES.MemberExpression && import_utils10.ASTUtils.getPropertyName(object) === "not";
+  if (negative && object.type === import_utils10.AST_NODE_TYPES.MemberExpression) object = unwrapExpression(object.object);
+  if (object.type !== import_utils10.AST_NODE_TYPES.CallExpression || object.arguments.length !== 1 || object.callee.type !== import_utils10.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_utils7.AST_NODE_TYPES.SpreadElement ? null : fetchResponse(source, argument);
+  const response = argument === void 0 || argument.type === import_utils10.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_utils7.AST_NODE_TYPES.MemberExpression || import_utils7.ASTUtils.getPropertyName(node) !== "status" || node.object.type !== import_utils7.AST_NODE_TYPES.Identifier) return null;
+  if (node.type !== import_utils10.AST_NODE_TYPES.MemberExpression || import_utils10.ASTUtils.getPropertyName(node) !== "status" || node.object.type !== import_utils10.AST_NODE_TYPES.Identifier) return null;
   return responseBinding(source, node.object);
 }
 function responseBinding(source, node, seen = /* @__PURE__ */ new Set()) {
-  const variable = import_utils7.ASTUtils.findVariable(source.getScope(node), node.name);
+  const variable = import_utils10.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_utils7.AST_NODE_TYPES.Identifier) {
+  if (parameter?.type === "Parameter" && parameter.name.type === import_utils10.AST_NODE_TYPES.Identifier) {
     const annotation = parameter.name.typeAnnotation?.typeAnnotation;
-    return annotation?.type === import_utils7.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Response" && (import_utils7.ASTUtils.findVariable(source.getScope(annotation.typeName), "Response")?.defs.length ?? 0) === 0 ? variable : null;
+    return annotation?.type === import_utils10.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils10.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Response" && (import_utils10.ASTUtils.findVariable(source.getScope(annotation.typeName), "Response")?.defs.length ?? 0) === 0 ? variable : null;
   }
-  if (definition?.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator || definition.parent.kind !== "const" || definition.init === null) return null;
+  if (definition?.type !== import_utils10.AST_NODE_TYPES.VariableDeclarator || definition.parent.kind !== "const" || definition.init === null) return null;
   let initial = unwrapExpression(definition.init);
-  if (initial.type === import_utils7.AST_NODE_TYPES.AwaitExpression) initial = unwrapExpression(initial.argument);
-  if (initial.type === import_utils7.AST_NODE_TYPES.Identifier) return responseBinding(source, initial, seen);
+  if (initial.type === import_utils10.AST_NODE_TYPES.AwaitExpression) initial = unwrapExpression(initial.argument);
+  if (initial.type === import_utils10.AST_NODE_TYPES.Identifier) return responseBinding(source, initial, seen);
   return nativeResponse(initial, source) ? variable : null;
 }
 function nativeResponse(initial, source) {
-  if (initial.type === import_utils7.AST_NODE_TYPES.NewExpression && initial.callee.type === import_utils7.AST_NODE_TYPES.Identifier && initial.callee.name === "Response" && (import_utils7.ASTUtils.findVariable(source.getScope(initial.callee), "Response")?.defs.length ?? 0) === 0) return true;
-  if (initial.type === import_utils7.AST_NODE_TYPES.CallExpression && nativeFetchReference(initial.callee, source)) return true;
-  if (initial.type !== import_utils7.AST_NODE_TYPES.CallExpression || initial.callee.type !== import_utils7.AST_NODE_TYPES.Identifier) return false;
+  if (initial.type === import_utils10.AST_NODE_TYPES.NewExpression && initial.callee.type === import_utils10.AST_NODE_TYPES.Identifier && initial.callee.name === "Response" && (import_utils10.ASTUtils.findVariable(source.getScope(initial.callee), "Response")?.defs.length ?? 0) === 0) return true;
+  if (initial.type === import_utils10.AST_NODE_TYPES.CallExpression && nativeFetchReference(initial.callee, source)) return true;
+  if (initial.type !== import_utils10.AST_NODE_TYPES.CallExpression || initial.callee.type !== import_utils10.AST_NODE_TYPES.Identifier) return false;
   const callee = initial.callee;
-  const binding3 = import_utils7.ASTUtils.findVariable(source.getScope(callee), callee.name);
+  const binding3 = import_utils10.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_utils7.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_utils10.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_utils7.AST_NODE_TYPES.ImportDefaultSpecifier) return imported.parent.source.value === "node-fetch";
-  if (specifier.type !== import_utils7.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type") return false;
-  const importedName7 = specifier.imported.type === import_utils7.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+  if (specifier.type === import_utils10.AST_NODE_TYPES.ImportDefaultSpecifier) return imported.parent.source.value === "node-fetch";
+  if (specifier.type !== import_utils10.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type") return false;
+  const importedName7 = specifier.imported.type === import_utils10.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_utils7.AST_NODE_TYPES.FunctionDeclaration) return null;
-    if (current.type !== import_utils7.AST_NODE_TYPES.ArrowFunctionExpression && current.type !== import_utils7.AST_NODE_TYPES.FunctionExpression) continue;
+    if (current.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) return null;
+    if (current.type !== import_utils10.AST_NODE_TYPES.ArrowFunctionExpression && current.type !== import_utils10.AST_NODE_TYPES.FunctionExpression) continue;
     const registration2 = directArgumentCall(current);
     const callee = registration2?.callee;
-    if (callee?.type !== import_utils7.AST_NODE_TYPES.Identifier) return null;
+    if (callee?.type !== import_utils10.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_utils7.AST_NODE_TYPES.BlockStatement) return false;
+  if (test.body.type !== import_utils10.AST_NODE_TYPES.BlockStatement) return false;
   return test.body.body.some((statement) => {
-    if (statement.type !== import_utils7.AST_NODE_TYPES.ExpressionStatement) return false;
+    if (statement.type !== import_utils10.AST_NODE_TYPES.ExpressionStatement) return false;
     let expression = unwrapExpression(statement.expression);
-    if (expression.type === import_utils7.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
-    if (expression.type !== import_utils7.AST_NODE_TYPES.CallExpression) return false;
+    if (expression.type === import_utils10.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
+    if (expression.type !== import_utils10.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;
   });
@@ -911,7 +1100,7 @@ var no_negative_only_http_status_assertion_default = createRule({
 });
 
 // src/rules/prefer-test-fixture-reuse.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils11 = 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"]);
@@ -933,24 +1122,24 @@ var PREFER_TEST_FIXTURE_REUSE_DOCUMENTATION = {
   ]
 };
 function stableBinding(source, identifier) {
-  const variable = import_utils8.ASTUtils.findVariable(source.getScope(identifier), identifier.name);
+  const variable = import_utils11.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_utils8.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
+  if (node.type !== import_utils11.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_utils8.AST_NODE_TYPES.ImportDeclaration && definition.parent.importKind !== "type" && (definition.node.type !== import_utils8.AST_NODE_TYPES.ImportSpecifier || definition.node.importKind !== "type")) return variable;
-  if (definition.node.type === import_utils8.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_utils11.AST_NODE_TYPES.ImportDeclaration && definition.parent.importKind !== "type" && (definition.node.type !== import_utils11.AST_NODE_TYPES.ImportSpecifier || definition.node.importKind !== "type")) return variable;
+  if (definition.node.type === import_utils11.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_utils8.AST_NODE_TYPES.Identifier || depth >= MAX_DEPTH) return null;
+  if (node.type !== import_utils11.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;
@@ -962,35 +1151,35 @@ function fixtureApi(source, expression, depth = 0) {
 }
 function importedFixtureApi(variable) {
   const definition = variable.defs[0];
-  if (definition?.type === "ImportBinding" && definition.parent.type === import_utils8.AST_NODE_TYPES.ImportDeclaration && FRAMEWORKS.has(definition.parent.source.value) && definition.parent.importKind !== "type" && definition.node.type === import_utils8.AST_NODE_TYPES.ImportSpecifier && definition.node.importKind !== "type") {
+  if (definition?.type === "ImportBinding" && definition.parent.type === import_utils11.AST_NODE_TYPES.ImportDeclaration && FRAMEWORKS.has(definition.parent.source.value) && definition.parent.importKind !== "type" && definition.node.type === import_utils11.AST_NODE_TYPES.ImportSpecifier && definition.node.importKind !== "type") {
     const imported = definition.node.imported;
-    const name = imported.type === import_utils8.AST_NODE_TYPES.Identifier ? imported.name : imported.value;
+    const name = imported.type === import_utils11.AST_NODE_TYPES.Identifier ? imported.name : imported.value;
     return name === "test" || name === "it";
   }
   return false;
 }
 function fixtureExtension(declaration, before) {
-  if (declaration.type !== import_utils8.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= before) return null;
+  if (declaration.type !== import_utils11.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_utils8.AST_NODE_TYPES.CallExpression || initial.optional || initial.arguments.length !== 1 || initial.callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression || initial.callee.optional || import_utils8.ASTUtils.getPropertyName(initial.callee) !== "extend") return null;
+  if (initial.type !== import_utils11.AST_NODE_TYPES.CallExpression || initial.optional || initial.arguments.length !== 1 || initial.callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression || initial.callee.optional || import_utils11.ASTUtils.getPropertyName(initial.callee) !== "extend") return null;
   const declarations = initial.arguments[0];
-  if (declarations?.type !== import_utils8.AST_NODE_TYPES.ObjectExpression || declarations.properties.some((property) => property.type !== import_utils8.AST_NODE_TYPES.Property || property.computed || property.kind !== "init")) return null;
+  if (declarations?.type !== import_utils11.AST_NODE_TYPES.ObjectExpression || declarations.properties.some((property) => property.type !== import_utils11.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_utils8.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = use.parent;
-    return use.parent?.type !== import_utils8.AST_NODE_TYPES.CallExpression || use.parent.callee !== use;
+    while (use.parent?.type === import_utils11.AST_NODE_TYPES.MemberExpression && use.parent.object === use) use = use.parent;
+    return use.parent?.type !== import_utils11.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_utils8.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils8.AST_NODE_TYPES.AssignmentPattern) continue;
-    const name = import_utils8.ASTUtils.getPropertyName(property);
-    if (name === null || property.value.type === import_utils8.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) continue;
+    if (property.type !== import_utils11.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils11.AST_NODE_TYPES.AssignmentPattern) continue;
+    const name = import_utils11.ASTUtils.getPropertyName(property);
+    if (name === null || property.value.type === import_utils11.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) continue;
     const constructor = fixtureConstructor(source, property.value);
     if (constructor === null) result.delete(name);
     else result.set(name, constructor);
@@ -999,24 +1188,24 @@ function fixtureConstructors(source, declarations, inherited) {
 }
 function fixtureConstructor(source, value) {
   value = unwrapExpression(value);
-  if (value.type !== import_utils8.AST_NODE_TYPES.ArrowFunctionExpression && value.type !== import_utils8.AST_NODE_TYPES.FunctionExpression) return newConstructor(source, value);
+  if (value.type !== import_utils11.AST_NODE_TYPES.ArrowFunctionExpression && value.type !== import_utils11.AST_NODE_TYPES.FunctionExpression) return newConstructor(source, value);
   const use = value.params[1];
-  if (use?.type !== import_utils8.AST_NODE_TYPES.Identifier) return null;
+  if (use?.type !== import_utils11.AST_NODE_TYPES.Identifier) return null;
   const binding3 = stableBinding(source, use);
-  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils8.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 1 && node.callee.type === import_utils8.AST_NODE_TYPES.Identifier && stableBinding(source, node.callee) === binding3);
+  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils11.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 1 && node.callee.type === import_utils11.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_utils8.AST_NODE_TYPES.SpreadElement ? null : newConstructor(source, argument);
+  return argument === void 0 || argument.type === import_utils11.AST_NODE_TYPES.SpreadElement ? null : newConstructor(source, argument);
 }
 function newConstructor(source, expression) {
   const value = unwrapExpression(expression);
-  if (value.type === import_utils8.AST_NODE_TYPES.NewExpression) return constructorBinding(source, value.callee);
-  if (value.type !== import_utils8.AST_NODE_TYPES.Identifier) return null;
+  if (value.type === import_utils11.AST_NODE_TYPES.NewExpression) return constructorBinding(source, value.callee);
+  if (value.type !== import_utils11.AST_NODE_TYPES.Identifier) return null;
   const variable = stableBinding(source, value);
   const declaration = variable?.defs[0]?.node;
-  if (declaration?.type !== import_utils8.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.init === null || declaration.range[1] >= value.range[0]) return null;
+  if (declaration?.type !== import_utils11.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_utils8.AST_NODE_TYPES.NewExpression ? constructorBinding(source, initial.callee) : null;
+  return initial.type === import_utils11.AST_NODE_TYPES.NewExpression ? constructorBinding(source, initial.callee) : null;
 }
 function scopeNodes(root, source) {
   const result = [];
@@ -1025,7 +1214,7 @@ function scopeNodes(root, source) {
     const node = pending.pop();
     if (node === void 0) continue;
     result.push(node);
-    if (node !== root && (node.type === import_utils8.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils8.AST_NODE_TYPES.FunctionExpression || node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils8.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils8.AST_NODE_TYPES.ClassExpression)) continue;
+    if (node !== root && (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils11.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils11.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));
@@ -1039,13 +1228,13 @@ function isNode2(value) {
 }
 function testApiCallee(expression) {
   let node = unwrapExpression(expression);
-  while (node.type === import_utils8.AST_NODE_TYPES.MemberExpression && !node.optional && TEST_MODIFIERS.has(import_utils8.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
+  while (node.type === import_utils11.AST_NODE_TYPES.MemberExpression && !node.optional && TEST_MODIFIERS.has(import_utils11.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_utils8.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils8.AST_NODE_TYPES.FunctionExpression) return current;
-    if (current.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration) return null;
+    if (current.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils11.AST_NODE_TYPES.FunctionExpression) return current;
+    if (current.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration) return null;
   }
   return null;
 }
@@ -1067,13 +1256,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_utils8.AST_NODE_TYPES.ObjectPattern) return;
+        if (parameter?.type !== import_utils11.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_utils8.AST_NODE_TYPES.Property || property.computed) continue;
-          const name = import_utils8.ASTUtils.getPropertyName(property);
+          if (property.type !== import_utils11.AST_NODE_TYPES.Property || property.computed) continue;
+          const name = import_utils11.ASTUtils.getPropertyName(property);
           if (name !== null && entries.get(name) === constructor) {
             context.report({ node, messageId: "reuseFixture", data: { fixture: name } });
             return;
@@ -1085,7 +1274,7 @@ var prefer_test_fixture_reuse_default = createRule({
 });
 
 // src/rules/no-return-disposed-resource.ts
-var import_utils9 = require("@typescript-eslint/utils");
+var import_utils12 = 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.",
@@ -1105,16 +1294,16 @@ var NO_RETURN_DISPOSED_RESOURCE_DOCUMENTATION = {
 };
 function owningFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (current.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils9.AST_NODE_TYPES.FunctionExpression || current.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) return current;
+    if (current.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils12.AST_NODE_TYPES.FunctionExpression || current.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) return current;
   }
   return null;
 }
 function resourceOwner(source, value, seen = /* @__PURE__ */ new Set()) {
   const node = unwrapExpression(value);
-  if (node.type !== import_utils9.AST_NODE_TYPES.Identifier) return null;
-  const variable = import_utils9.ASTUtils.findVariable(source.getScope(node), node.name);
+  if (node.type !== import_utils12.AST_NODE_TYPES.Identifier) return null;
+  const variable = import_utils12.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_utils9.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_utils12.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;
@@ -1143,7 +1332,7 @@ var no_return_disposed_resource_default = createRule({
 });
 
 // src/rules/require-jwt-lifetime.ts
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils13 = 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.",
@@ -1171,36 +1360,36 @@ var require_jwt_lifetime_default = createRule({
     function inspect(input) {
       if (input === null) return;
       let node = unwrapExpression(input);
-      if (node.type === import_utils10.AST_NODE_TYPES.AwaitExpression) node = unwrapExpression(node.argument);
-      if (node.type !== import_utils10.AST_NODE_TYPES.CallExpression || !isVerifier(node.callee)) return;
+      if (node.type === import_utils13.AST_NODE_TYPES.AwaitExpression) node = unwrapExpression(node.argument);
+      if (node.type !== import_utils13.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_utils10.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils10.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type === import_utils13.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils13.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
         const declaration = variable?.defs[0]?.node;
-        return variable?.defs.length === 1 && declaration?.type === import_utils10.AST_NODE_TYPES.ImportSpecifier && declaration.parent.type === import_utils10.AST_NODE_TYPES.ImportDeclaration && declaration.importKind !== "type" && declaration.parent.importKind !== "type" && declaration.parent.source.value === "jose" && declaration.imported.type === import_utils10.AST_NODE_TYPES.Identifier && declaration.imported.name === "jwtVerify";
+        return variable?.defs.length === 1 && declaration?.type === import_utils13.AST_NODE_TYPES.ImportSpecifier && declaration.parent.type === import_utils13.AST_NODE_TYPES.ImportDeclaration && declaration.importKind !== "type" && declaration.parent.importKind !== "type" && declaration.parent.source.value === "jose" && declaration.imported.type === import_utils13.AST_NODE_TYPES.Identifier && declaration.imported.name === "jwtVerify";
       }
-      if (node.type !== import_utils10.AST_NODE_TYPES.MemberExpression || import_utils10.ASTUtils.getPropertyName(node) !== "jwtVerify" || node.object.type !== import_utils10.AST_NODE_TYPES.Identifier) return false;
-      const definition = import_utils10.ASTUtils.findVariable(sourceCode.getScope(node.object), node.object.name)?.defs[0]?.node;
-      return definition?.type === import_utils10.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && definition.parent.source.value === "jose";
+      if (node.type !== import_utils13.AST_NODE_TYPES.MemberExpression || import_utils13.ASTUtils.getPropertyName(node) !== "jwtVerify" || node.object.type !== import_utils13.AST_NODE_TYPES.Identifier) return false;
+      const definition = import_utils13.ASTUtils.findVariable(sourceCode.getScope(node.object), node.object.name)?.defs[0]?.node;
+      return definition?.type === import_utils13.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_utils10.AST_NODE_TYPES.ObjectExpression || options.properties.some((property) => property.type !== import_utils10.AST_NODE_TYPES.Property || property.computed)) return false;
-      return !options.properties.some((property) => property.type === import_utils10.AST_NODE_TYPES.Property && lifetimeProperty(property));
+      if (options.type !== import_utils13.AST_NODE_TYPES.ObjectExpression || options.properties.some((property) => property.type !== import_utils13.AST_NODE_TYPES.Property || property.computed)) return false;
+      return !options.properties.some((property) => property.type === import_utils13.AST_NODE_TYPES.Property && lifetimeProperty(property));
     }
     function lifetimeProperty(property) {
-      const name = property.key.type === import_utils10.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils10.AST_NODE_TYPES.Literal ? property.key.value : null;
+      const name = property.key.type === import_utils13.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils13.AST_NODE_TYPES.Literal ? property.key.value : null;
       if (name === "maxTokenAge") {
-        if (property.value.type !== import_utils10.AST_NODE_TYPES.Literal) return true;
+        if (property.value.type !== import_utils13.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_utils10.AST_NODE_TYPES.ArrayExpression || property.value.elements.some((element) => element?.type !== import_utils10.AST_NODE_TYPES.Literal)) return true;
-      return property.value.elements.some((element) => element?.type === import_utils10.AST_NODE_TYPES.Literal && element.value === "exp");
+      if (property.value.type !== import_utils13.AST_NODE_TYPES.ArrayExpression || property.value.elements.some((element) => element?.type !== import_utils13.AST_NODE_TYPES.Literal)) return true;
+      return property.value.elements.some((element) => element?.type === import_utils13.AST_NODE_TYPES.Literal && element.value === "exp");
     }
     return {
       ReturnStatement(node) {
@@ -1214,7 +1403,7 @@ var require_jwt_lifetime_default = createRule({
 });
 
 // src/rules/no-discarded-validation-result.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils14 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
@@ -1250,52 +1439,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_utils11.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils11.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils14.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
         const definition = variable?.defs[0]?.node;
         if (variable?.defs.length !== 1) return null;
-        if (definition?.type === import_utils11.AST_NODE_TYPES.ImportSpecifier && definition.parent.type === import_utils11.AST_NODE_TYPES.ImportDeclaration && definition.importKind !== "type" && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
-        if (definition?.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
-        if (definition?.type === import_utils11.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_utils14.AST_NODE_TYPES.ImportSpecifier && definition.parent.type === import_utils14.AST_NODE_TYPES.ImportDeclaration && definition.importKind !== "type" && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
+        if (definition?.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier && definition.parent.importKind !== "type" && isZodModule(definition.parent.source.value)) return { changed: false };
+        if (definition?.type === import_utils14.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_utils11.AST_NODE_TYPES.MemberExpression) {
+      if (node.type === import_utils14.AST_NODE_TYPES.MemberExpression) {
         const owner2 = schema(node.object, depth + 1);
         return owner2;
       }
-      if (node.type !== import_utils11.AST_NODE_TYPES.CallExpression) return null;
+      if (node.type !== import_utils14.AST_NODE_TYPES.CallExpression) return null;
       const owner = schema(node.callee, depth + 1);
       if (owner === null) return null;
-      const invokedChange = node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && CHANGING.has(import_utils11.ASTUtils.getPropertyName(node.callee) ?? "");
-      const coerced = node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && coercionNamespace(node.callee.object);
+      const invokedChange = node.callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && CHANGING.has(import_utils14.ASTUtils.getPropertyName(node.callee) ?? "");
+      const coerced = node.callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && coercionNamespace(node.callee.object);
       const changedArgument = node.arguments.some((argument) => {
-        if (argument.type === import_utils11.AST_NODE_TYPES.ArrayExpression) return argument.elements.some((element) => element !== null && schema(element, depth + 1)?.changed === true);
-        if (argument.type === import_utils11.AST_NODE_TYPES.ObjectExpression) return argument.properties.some((property) => property.type === import_utils11.AST_NODE_TYPES.Property && schema(property.value, depth + 1)?.changed === true);
+        if (argument.type === import_utils14.AST_NODE_TYPES.ArrayExpression) return argument.elements.some((element) => element !== null && schema(element, depth + 1)?.changed === true);
+        if (argument.type === import_utils14.AST_NODE_TYPES.ObjectExpression) return argument.properties.some((property) => property.type === import_utils14.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_utils11.AST_NODE_TYPES.MemberExpression && import_utils11.ASTUtils.getPropertyName(node) === "coerce") {
+      if (node.type === import_utils14.AST_NODE_TYPES.MemberExpression && import_utils14.ASTUtils.getPropertyName(node) === "coerce") {
         namespace = true;
         node = node.object;
       }
-      if (node.type !== import_utils11.AST_NODE_TYPES.Identifier) return false;
-      const variable = import_utils11.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      if (node.type !== import_utils14.AST_NODE_TYPES.Identifier) return false;
+      const variable = import_utils14.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_utils11.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return false;
-      if (definition.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier) return namespace;
-      if (definition.type !== import_utils11.AST_NODE_TYPES.ImportSpecifier || definition.importKind === "type") return false;
-      const name = definition.imported.type === import_utils11.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value;
+      if (variable?.defs.length !== 1 || definition === void 0 || definition.parent.type !== import_utils14.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return false;
+      if (definition.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier) return namespace;
+      if (definition.type !== import_utils14.AST_NODE_TYPES.ImportSpecifier || definition.importKind === "type") return false;
+      const name = definition.imported.type === import_utils14.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_utils11.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
-        if (expression.type !== import_utils11.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression) return;
-        const method = import_utils11.ASTUtils.getPropertyName(expression.callee);
+        if (expression.type === import_utils14.AST_NODE_TYPES.AwaitExpression) expression = unwrapExpression(expression.argument);
+        if (expression.type !== import_utils14.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils14.AST_NODE_TYPES.MemberExpression) return;
+        const method = import_utils14.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" });
@@ -1305,7 +1494,7 @@ var no_discarded_validation_result_default = createRule({
 });
 
 // src/rules/production-derived-test-cases.ts
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils15 = 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 = {
@@ -1340,52 +1529,52 @@ var production_derived_test_cases_default = createRule({
     const tables = [];
     const asserted = /* @__PURE__ */ new Set();
     function binding3(node) {
-      return import_utils12.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      return import_utils15.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_utils12.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils12.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_utils12.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      if (variable?.defs.length !== 1 || specifier?.type !== import_utils15.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils15.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_utils15.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
     }
     function production(node) {
       node = unwrapExpression(node);
-      if (node.type !== import_utils12.AST_NODE_TYPES.Identifier) return null;
+      if (node.type !== import_utils15.AST_NODE_TYPES.Identifier) return null;
       const variable = binding3(node);
       const specifier = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || specifier?.type !== import_utils12.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils12.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_utils12.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      if (variable?.defs.length !== 1 || specifier?.type !== import_utils15.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || specifier.parent.type !== import_utils15.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_utils15.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_utils12.AST_NODE_TYPES.MemberExpression && ["only", "skip", "concurrent", "sequential"].includes(import_utils12.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
-      if (node.type !== import_utils12.AST_NODE_TYPES.Identifier) return false;
+      while (node.type === import_utils15.AST_NODE_TYPES.MemberExpression && ["only", "skip", "concurrent", "sequential"].includes(import_utils15.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
+      if (node.type !== import_utils15.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_utils12.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils12.AST_NODE_TYPES.MemberExpression && ["each", "for"].includes(import_utils12.ASTUtils.getPropertyName(node.callee) ?? "") && runner(node.callee.object);
+      return node.type === import_utils15.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils15.AST_NODE_TYPES.MemberExpression && ["each", "for"].includes(import_utils15.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_utils12.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils15.AST_NODE_TYPES.Identifier) {
         const variable = binding3(node);
         const definition = variable?.defs[0]?.node;
-        return variable?.defs.length === 1 && definition?.type === import_utils12.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_utils12.AST_NODE_TYPES.CallExpression && (caseTable(reference.identifier.parent) || reference.identifier.parent.callee.type === import_utils12.AST_NODE_TYPES.Identifier && importedName7(reference.identifier.parent.callee, "vitest") === "expect" || reference.identifier.parent.callee.type === import_utils12.AST_NODE_TYPES.MemberExpression && ["toEqual", "toStrictEqual"].includes(import_utils12.ASTUtils.getPropertyName(reference.identifier.parent.callee) ?? ""))) && literalTable(definition.init, seen);
+        return variable?.defs.length === 1 && definition?.type === import_utils15.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_utils15.AST_NODE_TYPES.CallExpression && (caseTable(reference.identifier.parent) || reference.identifier.parent.callee.type === import_utils15.AST_NODE_TYPES.Identifier && importedName7(reference.identifier.parent.callee, "vitest") === "expect" || reference.identifier.parent.callee.type === import_utils15.AST_NODE_TYPES.MemberExpression && ["toEqual", "toStrictEqual"].includes(import_utils15.ASTUtils.getPropertyName(reference.identifier.parent.callee) ?? ""))) && literalTable(definition.init, seen);
       }
-      return node.type === import_utils12.AST_NODE_TYPES.ArrayExpression && node.elements.every((element) => element?.type === import_utils12.AST_NODE_TYPES.Literal && !("regex" in element));
+      return node.type === import_utils15.AST_NODE_TYPES.ArrayExpression && node.elements.every((element) => element?.type === import_utils15.AST_NODE_TYPES.Literal && !("regex" in element));
     }
     function unconditional(node) {
       const statement = node.parent;
-      if (statement.type !== import_utils12.AST_NODE_TYPES.ExpressionStatement) return false;
-      if (statement.parent.type === import_utils12.AST_NODE_TYPES.Program) return true;
+      if (statement.type !== import_utils15.AST_NODE_TYPES.ExpressionStatement) return false;
+      if (statement.parent.type === import_utils15.AST_NODE_TYPES.Program) return true;
       const block = statement.parent;
-      if (block.type !== import_utils12.AST_NODE_TYPES.BlockStatement || block.parent.type !== import_utils12.AST_NODE_TYPES.ArrowFunctionExpression && block.parent.type !== import_utils12.AST_NODE_TYPES.FunctionExpression) return false;
+      if (block.type !== import_utils15.AST_NODE_TYPES.BlockStatement || block.parent.type !== import_utils15.AST_NODE_TYPES.ArrowFunctionExpression && block.parent.type !== import_utils15.AST_NODE_TYPES.FunctionExpression) return false;
       const call = block.parent.parent;
-      return call.type === import_utils12.AST_NODE_TYPES.CallExpression && runner(call.callee);
+      return call.type === import_utils15.AST_NODE_TYPES.CallExpression && runner(call.callee);
     }
     return {
       CallExpression(node) {
@@ -1393,9 +1582,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_utils12.AST_NODE_TYPES.MemberExpression || !["toEqual", "toStrictEqual"].includes(import_utils12.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_utils15.AST_NODE_TYPES.MemberExpression || !["toEqual", "toStrictEqual"].includes(import_utils15.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_utils12.AST_NODE_TYPES.CallExpression || expect.callee.type !== import_utils12.AST_NODE_TYPES.Identifier || importedName7(expect.callee, "vitest") !== "expect" || expect.arguments.length !== 1 || expect.arguments[0] === void 0) return;
+        if (expect.type !== import_utils15.AST_NODE_TYPES.CallExpression || expect.callee.type !== import_utils15.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);
       },
@@ -1407,14 +1596,14 @@ var production_derived_test_cases_default = createRule({
 });
 
 // src/rules/require-constrained-schema-integer.ts
-var import_utils13 = require("@typescript-eslint/utils");
+var import_utils16 = 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_utils13.AST_NODE_TYPES.Literal && typeof node.value === "number") return node.value;
-  if (node.type === import_utils13.AST_NODE_TYPES.UnaryExpression && (node.operator === "-" || node.operator === "+")) {
+  if (node.type === import_utils16.AST_NODE_TYPES.Literal && typeof node.value === "number") return node.value;
+  if (node.type === import_utils16.AST_NODE_TYPES.UnaryExpression && (node.operator === "-" || node.operator === "+")) {
     const value = numericLiteral(node.argument);
     return value === null ? null : node.operator === "-" ? -value : value;
   }
@@ -1451,35 +1640,35 @@ var require_constrained_schema_integer_default = createRule({
     const sourceCode = context.sourceCode;
     function factory(node) {
       node = unwrapExpression(node);
-      if (node.type === import_utils13.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils16.AST_NODE_TYPES.Identifier) {
         const definition2 = imported(node);
-        return definition2?.type === import_utils13.AST_NODE_TYPES.ImportSpecifier ? definition2.imported.type === import_utils13.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value : null;
+        return definition2?.type === import_utils16.AST_NODE_TYPES.ImportSpecifier ? definition2.imported.type === import_utils16.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value : null;
       }
-      if (node.type !== import_utils13.AST_NODE_TYPES.MemberExpression) return null;
+      if (node.type !== import_utils16.AST_NODE_TYPES.MemberExpression) return null;
       let receiver = unwrapExpression(node.object);
-      if (receiver.type === import_utils13.AST_NODE_TYPES.MemberExpression && import_utils13.ASTUtils.getPropertyName(receiver) === "coerce") receiver = unwrapExpression(receiver.object);
-      if (receiver.type !== import_utils13.AST_NODE_TYPES.Identifier) return null;
+      if (receiver.type === import_utils16.AST_NODE_TYPES.MemberExpression && import_utils16.ASTUtils.getPropertyName(receiver) === "coerce") receiver = unwrapExpression(receiver.object);
+      if (receiver.type !== import_utils16.AST_NODE_TYPES.Identifier) return null;
       const definition = imported(receiver);
-      if (definition === null || definition.type === import_utils13.AST_NODE_TYPES.ImportSpecifier && (definition.imported.type === import_utils13.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z") return null;
-      return import_utils13.ASTUtils.getPropertyName(node);
+      if (definition === null || definition.type === import_utils16.AST_NODE_TYPES.ImportSpecifier && (definition.imported.type === import_utils16.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z") return null;
+      return import_utils16.ASTUtils.getPropertyName(node);
     }
     function imported(identifier) {
-      const variable = import_utils13.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = import_utils16.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
       const definition = variable?.defs[0]?.node;
-      if (variable?.defs.length !== 1 || definition?.type !== import_utils13.AST_NODE_TYPES.ImportSpecifier && definition?.type !== import_utils13.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils13.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
-      return definition.type === import_utils13.AST_NODE_TYPES.ImportSpecifier && definition.importKind === "type" ? null : definition;
+      if (variable?.defs.length !== 1 || definition?.type !== import_utils16.AST_NODE_TYPES.ImportSpecifier && definition?.type !== import_utils16.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils16.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
+      return definition.type === import_utils16.AST_NODE_TYPES.ImportSpecifier && definition.importKind === "type" ? null : definition;
     }
     function constrained(value, minimum) {
       const calls = [];
       value = unwrapExpression(value);
-      while (value.type === import_utils13.AST_NODE_TYPES.CallExpression) {
+      while (value.type === import_utils16.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_utils13.AST_NODE_TYPES.MemberExpression) return null;
-        const method = import_utils13.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils16.AST_NODE_TYPES.MemberExpression) return null;
+        const method = import_utils16.ASTUtils.getPropertyName(callee);
         if (method === null) return null;
         calls.push({ method, call: value });
         value = unwrapExpression(callee.object);
@@ -1504,7 +1693,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_utils13.AST_NODE_TYPES.SpreadElement) return null;
+      if (argument === void 0 || argument.type === import_utils16.AST_NODE_TYPES.SpreadElement) return null;
       const bound = numericLiteral(argument);
       return bound === null || bound >= minimum - (exclusive ? 1 : 0);
     }
@@ -1513,10 +1702,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_utils13.AST_NODE_TYPES.ObjectExpression) return;
+        if (shape?.type !== import_utils16.AST_NODE_TYPES.ObjectExpression) return;
         for (const property of shape.properties) {
-          if (property.type !== import_utils13.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method) continue;
-          const field = import_utils13.ASTUtils.getPropertyName(property);
+          if (property.type !== import_utils16.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method) continue;
+          const field = import_utils16.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 } });
@@ -1527,7 +1716,7 @@ var require_constrained_schema_integer_default = createRule({
 });
 
 // src/rules/no-generic-json-parser.ts
-var import_utils14 = require("@typescript-eslint/utils");
+var import_utils17 = 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 = {
@@ -1560,60 +1749,60 @@ var no_generic_json_parser_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     const sourceCode = context.sourceCode;
     function binding3(node) {
-      return import_utils14.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+      return import_utils17.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_utils14.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_utils17.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_utils14.AST_NODE_TYPES.AwaitExpression) return parser(node.argument, seen, true);
-      if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils17.AST_NODE_TYPES.AwaitExpression) return parser(node.argument, seen, true);
+      if (node.type === import_utils17.AST_NODE_TYPES.Identifier) {
         const value = initializer(node);
         return value === null ? null : parser(value, seen, awaited);
       }
-      if (node.type !== import_utils14.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils14.AST_NODE_TYPES.MemberExpression || !["parse", "parseAsync"].includes(import_utils14.ASTUtils.getPropertyName(node.callee) ?? "")) return null;
-      if (import_utils14.ASTUtils.getPropertyName(node.callee) === "parseAsync" && !awaited) return null;
+      if (node.type !== import_utils17.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression || !["parse", "parseAsync"].includes(import_utils17.ASTUtils.getPropertyName(node.callee) ?? "")) return null;
+      if (import_utils17.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_utils14.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils17.AST_NODE_TYPES.Identifier) {
         const value = initializer(node);
         return value !== null && openSchema(value, seen);
       }
-      if (node.type !== import_utils14.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils17.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_utils14.AST_NODE_TYPES.MemberExpression && WRAPPERS.has(import_utils14.ASTUtils.getPropertyName(callee) ?? "") && openSchema(callee.object, seen);
+      return callee.type === import_utils17.AST_NODE_TYPES.MemberExpression && WRAPPERS.has(import_utils17.ASTUtils.getPropertyName(callee) ?? "") && openSchema(callee.object, seen);
     }
     function factory(node) {
       node = unwrapExpression(node);
-      if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils17.AST_NODE_TYPES.Identifier) {
         const definition2 = binding3(node)?.defs[0]?.node;
-        if (definition2?.type !== import_utils14.AST_NODE_TYPES.ImportSpecifier || definition2.parent.type !== import_utils14.AST_NODE_TYPES.ImportDeclaration || definition2.importKind === "type" || definition2.parent.importKind === "type" || !isZodModule(definition2.parent.source.value)) return null;
-        return definition2.imported.type === import_utils14.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value;
+        if (definition2?.type !== import_utils17.AST_NODE_TYPES.ImportSpecifier || definition2.parent.type !== import_utils17.AST_NODE_TYPES.ImportDeclaration || definition2.importKind === "type" || definition2.parent.importKind === "type" || !isZodModule(definition2.parent.source.value)) return null;
+        return definition2.imported.type === import_utils17.AST_NODE_TYPES.Identifier ? definition2.imported.name : definition2.imported.value;
       }
-      if (node.type !== import_utils14.AST_NODE_TYPES.MemberExpression) return null;
+      if (node.type !== import_utils17.AST_NODE_TYPES.MemberExpression) return null;
       const receiver = unwrapExpression(node.object);
-      if (receiver.type !== import_utils14.AST_NODE_TYPES.Identifier) return null;
+      if (receiver.type !== import_utils17.AST_NODE_TYPES.Identifier) return null;
       const definition = binding3(receiver)?.defs[0]?.node;
-      if (definition === void 0 || definition.type !== import_utils14.AST_NODE_TYPES.ImportSpecifier && definition.type !== import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils14.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
-      if (definition.type === import_utils14.AST_NODE_TYPES.ImportSpecifier && (definition.importKind === "type" || (definition.imported.type === import_utils14.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z")) return null;
-      return import_utils14.ASTUtils.getPropertyName(node);
+      if (definition === void 0 || definition.type !== import_utils17.AST_NODE_TYPES.ImportSpecifier && definition.type !== import_utils17.AST_NODE_TYPES.ImportNamespaceSpecifier || definition.parent.type !== import_utils17.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !isZodModule(definition.parent.source.value)) return null;
+      if (definition.type === import_utils17.AST_NODE_TYPES.ImportSpecifier && (definition.importKind === "type" || (definition.imported.type === import_utils17.AST_NODE_TYPES.Identifier ? definition.imported.name : definition.imported.value) !== "z")) return null;
+      return import_utils17.ASTUtils.getPropertyName(node);
     }
     const reported = /* @__PURE__ */ new Set();
     return {
       MemberExpression(node) {
-        const field = import_utils14.ASTUtils.getPropertyName(node);
+        const field = import_utils17.ASTUtils.getPropertyName(node);
         if (field === null) return;
         const call = parser(node.object);
         if (call === null || reported.has(call)) return;
@@ -1625,7 +1814,7 @@ var no_generic_json_parser_default = createRule({
 });
 
 // src/rules/no-redundant-local-alias.ts
-var import_utils15 = require("@typescript-eslint/utils");
+var import_utils18 = 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.",
@@ -1644,7 +1833,7 @@ 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_utils15.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_utils18.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < alias.range[0];
 }
 var no_redundant_local_alias_default = createRule({
   name: "no-redundant-local-alias",
@@ -1660,18 +1849,18 @@ var no_redundant_local_alias_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     return {
       VariableDeclarator(node) {
-        if (node.parent.kind !== "const" || node.parent.declarations.length !== 1 || node.id.type !== import_utils15.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0 || node.init?.type !== import_utils15.AST_NODE_TYPES.Identifier) return;
+        if (node.parent.kind !== "const" || node.parent.declarations.length !== 1 || node.id.type !== import_utils18.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0 || node.init?.type !== import_utils18.AST_NODE_TYPES.Identifier) return;
         const scope = context.sourceCode.getScope(node);
         if (scope.variableScope.type !== "function") return;
-        const target = import_utils15.ASTUtils.findVariable(scope, node.id.name);
-        const source = import_utils15.ASTUtils.findVariable(scope, node.init.name);
+        const target = import_utils18.ASTUtils.findVariable(scope, node.id.name);
+        const source = import_utils18.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_utils15.AST_NODE_TYPES.Property || !property.shorthand || property.value !== read.identifier || property.parent.type !== import_utils15.AST_NODE_TYPES.ObjectExpression || property.computed || property.method || property.kind !== "init") return;
+        if (property.type !== import_utils18.AST_NODE_TYPES.Property || !property.shorthand || property.value !== read.identifier || property.parent.type !== import_utils18.AST_NODE_TYPES.ObjectExpression || property.computed || property.method || property.kind !== "init") return;
         context.report({ node, messageId: "redundantAlias", data: { source: node.init.name, target: node.id.name } });
       }
     };
@@ -1679,10 +1868,10 @@ var no_redundant_local_alias_default = createRule({
 });
 
 // src/rules/no-test-comments.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 
 // src/rules/_comments.ts
-var import_utils16 = require("@typescript-eslint/utils");
+var import_utils19 = 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/;
@@ -1768,10 +1957,10 @@ var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
 var TOKEN_PLURAL_MIN = 4;
 var RESTATABLE_STATEMENTS = /* @__PURE__ */ new Set([
-  import_utils16.AST_NODE_TYPES.ExpressionStatement,
-  import_utils16.AST_NODE_TYPES.ReturnStatement,
-  import_utils16.AST_NODE_TYPES.ThrowStatement,
-  import_utils16.AST_NODE_TYPES.VariableDeclaration
+  import_utils19.AST_NODE_TYPES.ExpressionStatement,
+  import_utils19.AST_NODE_TYPES.ReturnStatement,
+  import_utils19.AST_NODE_TYPES.ThrowStatement,
+  import_utils19.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([
@@ -1830,12 +2019,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_utils16.AST_NODE_TYPES.Program; node = node.parent) {
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils19.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_utils16.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
+    if (node.type === import_utils19.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
       return null;
     }
     return node;
@@ -1845,8 +2034,8 @@ function restatableStatementNodeBelow(comment, sourceCode) {
 function isTrivialInitializer(node) {
   return node.declarations.every((declarator) => {
     const init = declarator.init;
-    if (init == null || init.type === import_utils16.AST_NODE_TYPES.Literal) return true;
-    return init.type === import_utils16.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils16.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
+    if (init == null || init.type === import_utils19.AST_NODE_TYPES.Literal) return true;
+    return init.type === import_utils19.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils19.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
   });
 }
 function restatesStatementHead(body3, statement) {
@@ -1873,7 +2062,7 @@ function headTokens(source) {
 }
 
 // src/rules/_comment-edits.ts
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 function physicalLineEnd(text, offset) {
   const newline = text.indexOf("\n", offset);
   return newline < 0 ? text.length : newline;
@@ -2000,7 +2189,7 @@ var no_test_comments_default = createRule({
     if (!isTestFile(context) || isGeneratedFile(context, context.sourceCode.text)) return {};
     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_utils18.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils18.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_utils21.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils21.AST_NODE_TYPES.ImportSpecifier || specifier.importKind !== "type")) && ["vitest", "@jest/globals", "@playwright/test", "bun:test", "node:test"].includes(statement.source.value));
     if (!unambiguous && !framework) return {};
     return {
       Program() {
@@ -2050,14 +2239,14 @@ var no_test_comments_default = createRule({
 });
 
 // src/rules/no-mutating-container-transform.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 var MUTATORS = /* @__PURE__ */ new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"]);
 var PRIMITIVES = /* @__PURE__ */ new Set([
-  import_utils19.AST_NODE_TYPES.TSStringKeyword,
-  import_utils19.AST_NODE_TYPES.TSNumberKeyword,
-  import_utils19.AST_NODE_TYPES.TSBooleanKeyword,
-  import_utils19.AST_NODE_TYPES.TSBigIntKeyword,
-  import_utils19.AST_NODE_TYPES.TSSymbolKeyword
+  import_utils22.AST_NODE_TYPES.TSStringKeyword,
+  import_utils22.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils22.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils22.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils22.AST_NODE_TYPES.TSSymbolKeyword
 ]);
 var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -2076,27 +2265,27 @@ var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   ]
 };
 function arrayElement(node, sourceCode) {
-  if (node.type === import_utils19.AST_NODE_TYPES.TSArrayType) return node.elementType;
-  if (node.type === import_utils19.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils19.AST_NODE_TYPES.Identifier && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray") && (import_utils19.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_utils22.AST_NODE_TYPES.TSArrayType) return node.elementType;
+  if (node.type === import_utils22.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils22.AST_NODE_TYPES.Identifier && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray") && (import_utils22.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_utils19.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils19.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && (import_utils19.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_utils22.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils22.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && (import_utils22.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_utils19.AST_NODE_TYPES.ExpressionStatement:
-      case import_utils19.AST_NODE_TYPES.VariableDeclaration:
-      case import_utils19.AST_NODE_TYPES.ReturnStatement:
-      case import_utils19.AST_NODE_TYPES.ThrowStatement:
-      case import_utils19.AST_NODE_TYPES.EmptyStatement:
+      case import_utils22.AST_NODE_TYPES.ExpressionStatement:
+      case import_utils22.AST_NODE_TYPES.VariableDeclaration:
+      case import_utils22.AST_NODE_TYPES.ReturnStatement:
+      case import_utils22.AST_NODE_TYPES.ThrowStatement:
+      case import_utils22.AST_NODE_TYPES.EmptyStatement:
         return true;
-      case import_utils19.AST_NODE_TYPES.BlockStatement:
+      case import_utils22.AST_NODE_TYPES.BlockStatement:
         return supported(statement.body);
-      case import_utils19.AST_NODE_TYPES.IfStatement:
+      case import_utils22.AST_NODE_TYPES.IfStatement:
         return supported([statement.consequent]) && (statement.alternate === null || supported([statement.alternate]));
       default:
         return false;
@@ -2117,13 +2306,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_utils19.AST_NODE_TYPES.Identifier ? import_utils19.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
+      return node.type === import_utils22.AST_NODE_TYPES.Identifier ? import_utils22.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
     }
     function inspect(node) {
-      if (node.body?.type !== import_utils19.AST_NODE_TYPES.BlockStatement || !returnsArray(node, sourceCode) || !supported(node.body.body)) return;
+      if (node.body?.type !== import_utils22.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_utils19.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
+        if (parameter.type !== import_utils22.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);
@@ -2136,26 +2325,26 @@ var no_mutating_container_transform_default = createRule({
       }
       function expression(current, state) {
         switch (current.type) {
-          case import_utils19.AST_NODE_TYPES.FunctionExpression:
-          case import_utils19.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils19.AST_NODE_TYPES.ClassExpression:
+          case import_utils22.AST_NODE_TYPES.FunctionExpression:
+          case import_utils22.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils22.AST_NODE_TYPES.ClassExpression:
             return;
-          case import_utils19.AST_NODE_TYPES.AssignmentExpression:
+          case import_utils22.AST_NODE_TYPES.AssignmentExpression:
             assignment(current, state);
             return;
-          case import_utils19.AST_NODE_TYPES.LogicalExpression:
+          case import_utils22.AST_NODE_TYPES.LogicalExpression:
             logical(current, state);
             return;
-          case import_utils19.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils22.AST_NODE_TYPES.ConditionalExpression:
             conditional(current, state);
             return;
-          case import_utils19.AST_NODE_TYPES.UpdateExpression:
+          case import_utils22.AST_NODE_TYPES.UpdateExpression:
             write(current.argument, state);
             break;
-          case import_utils19.AST_NODE_TYPES.UnaryExpression:
+          case import_utils22.AST_NODE_TYPES.UnaryExpression:
             if (current.operator === "delete") write(current.argument, state);
             break;
-          case import_utils19.AST_NODE_TYPES.CallExpression:
+          case import_utils22.AST_NODE_TYPES.CallExpression:
             mutationCall(current, state);
             break;
           default:
@@ -2175,13 +2364,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_utils19.AST_NODE_TYPES.Literal && (current.operator === "&&" && !left.value || current.operator === "||" && !!left.value || current.operator === "??" && left.value !== null)) return;
+        if (left.type === import_utils22.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_utils19.AST_NODE_TYPES.Literal) {
+        if (test.type === import_utils22.AST_NODE_TYPES.Literal) {
           expression(test.value ? current.consequent : current.alternate, state);
           return;
         }
@@ -2189,13 +2378,13 @@ var no_mutating_container_transform_default = createRule({
         expression(current.alternate, state);
       }
       function mutationCall(current, state) {
-        if (current.callee.type !== import_utils19.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils19.ASTUtils.getPropertyName(current.callee) ?? "")) return;
+        if (current.callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils22.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_utils19.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils19.ASTUtils.getPropertyName(target) !== "length") return;
+        if (target.type !== import_utils22.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils22.ASTUtils.getPropertyName(target) !== "length") return;
         const parameter = origin(target.object, state);
         if (parameter !== void 0 && first === null) first = { node: target, parameter };
       }
@@ -2205,18 +2394,18 @@ var no_mutating_container_transform_default = createRule({
       }
       function statement(current, state) {
         switch (current.type) {
-          case import_utils19.AST_NODE_TYPES.BlockStatement:
+          case import_utils22.AST_NODE_TYPES.BlockStatement:
             return statements(current.body, state);
-          case import_utils19.AST_NODE_TYPES.IfStatement:
+          case import_utils22.AST_NODE_TYPES.IfStatement:
             return branch(current, state);
-          case import_utils19.AST_NODE_TYPES.VariableDeclaration:
+          case import_utils22.AST_NODE_TYPES.VariableDeclaration:
             declarations(current, state);
             return false;
-          case import_utils19.AST_NODE_TYPES.ReturnStatement:
-          case import_utils19.AST_NODE_TYPES.ThrowStatement:
+          case import_utils22.AST_NODE_TYPES.ReturnStatement:
+          case import_utils22.AST_NODE_TYPES.ThrowStatement:
             if (current.argument !== null) expression(current.argument, state);
             return true;
-          case import_utils19.AST_NODE_TYPES.ExpressionStatement:
+          case import_utils22.AST_NODE_TYPES.ExpressionStatement:
             expression(current.expression, state);
             return false;
           default:
@@ -2225,7 +2414,7 @@ var no_mutating_container_transform_default = createRule({
       }
       function branch(current, state) {
         expression(current.test, state);
-        if (current.test.type === import_utils19.AST_NODE_TYPES.Literal) return current.test.value ? statements([current.consequent], state) : current.alternate !== null && statements([current.alternate], state);
+        if (current.test.type === import_utils22.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);
@@ -2257,7 +2446,7 @@ var no_mutating_container_transform_default = createRule({
 });
 
 // src/rules/no-redundant-consumer-union.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var import_typescript7 = __toESM(require("typescript"), 1);
 
 // src/rules/_checked-native-source.ts
@@ -2368,11 +2557,11 @@ function finiteMember(member3, checker) {
 }
 
 // src/rules/_private-consumer-fix.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var import_typescript3 = __toESM(require("typescript"), 1);
 
 // src/rules/_type-binding.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 function typeBinding(source, identifier) {
   let scope = source.getScope(identifier);
   while (scope !== null) {
@@ -2398,12 +2587,12 @@ function retainsNamedTypeUses(source, removed) {
 function publicTypeUse(identifier) {
   let node = identifier;
   while (node.parent) {
-    if (node.type === import_utils20.AST_NODE_TYPES.TSTypeAnnotation || node.type === import_utils20.AST_NODE_TYPES.TSTypePredicate || node.type === import_utils20.AST_NODE_TYPES.TSAsExpression || node.type === import_utils20.AST_NODE_TYPES.TSTypeAssertion) return false;
-    if (node.type === import_utils20.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      return node.parent.type === import_utils20.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.declaration === node && node.parent.parent.type === import_utils20.AST_NODE_TYPES.Program;
+    if (node.type === import_utils23.AST_NODE_TYPES.TSTypeAnnotation || node.type === import_utils23.AST_NODE_TYPES.TSTypePredicate || node.type === import_utils23.AST_NODE_TYPES.TSAsExpression || node.type === import_utils23.AST_NODE_TYPES.TSTypeAssertion) return false;
+    if (node.type === import_utils23.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      return node.parent.type === import_utils23.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.declaration === node && node.parent.parent.type === import_utils23.AST_NODE_TYPES.Program;
     }
-    if (node.type === import_utils20.AST_NODE_TYPES.ExportSpecifier) {
-      return node.parent.type === import_utils20.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.source === null && node.parent.parent.type === import_utils20.AST_NODE_TYPES.Program;
+    if (node.type === import_utils23.AST_NODE_TYPES.ExportSpecifier) {
+      return node.parent.type === import_utils23.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.source === null && node.parent.parent.type === import_utils23.AST_NODE_TYPES.Program;
     }
     node = node.parent;
   }
@@ -2417,8 +2606,8 @@ function insideTypeRange(node, range) {
 var UNSAFE = import_typescript3.default.TypeFlags.Any | import_typescript3.default.TypeFlags.Unknown | import_typescript3.default.TypeFlags.Never | import_typescript3.default.TypeFlags.TypeParameter | import_typescript3.default.TypeFlags.Conditional | import_typescript3.default.TypeFlags.IndexedAccess | import_typescript3.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_utils21.AST_NODE_TYPES.FunctionDeclaration ? node : node.parent;
-  if (owner.type !== import_utils21.AST_NODE_TYPES.FunctionDeclaration && owner.type !== import_utils21.AST_NODE_TYPES.VariableDeclarator) return false;
+  const owner = node.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration ? node : node.parent;
+  if (owner.type !== import_utils24.AST_NODE_TYPES.FunctionDeclaration && owner.type !== import_utils24.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 checker = services.program.getTypeChecker();
@@ -2436,7 +2625,7 @@ function validConsumerFixCalls(node, parameter, sourceCode, services) {
       continue;
     }
     const call = reference.identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils21.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils24.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils24.AST_NODE_TYPES.Identifier) return false;
     const argument = services.esTreeNodeToTSNodeMap.get(call.arguments[0]);
     const type = checker.getTypeAtLocation(argument);
     if (!knownArgument(type, argument, fields2, checker) || !checker.isTypeAssignableTo(type, original)) return false;
@@ -2491,7 +2680,7 @@ function minimalConsumerFix(sourceCode, annotation, removed) {
 }
 
 // src/rules/_private-scalar-consumer.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var import_typescript6 = __toESM(require("typescript"), 1);
 
 // src/rules/_scalar-parameter-view.ts
@@ -2637,31 +2826,11 @@ 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_utils22 = require("@typescript-eslint/utils");
-function typeOnlyReference(reference) {
-  if (reference.isTypeReference && !reference.isValueReference) return true;
-  let current = outerExpression(reference.identifier);
-  while (current.parent?.type === import_utils22.AST_NODE_TYPES.TSQualifiedName && current.parent.left === current) {
-    current = current.parent;
-  }
-  return current.parent?.type === import_utils22.AST_NODE_TYPES.TSTypeQuery && current.parent.exprName === current;
-}
-function stableValueBinding(variable, acceptRead) {
-  let initializer;
-  return variable.references.every((reference) => {
-    if (!reference.isWrite()) return acceptRead?.(reference) ?? true;
-    if (reference.init !== true || initializer !== void 0 && initializer !== reference.identifier) return false;
-    initializer = reference.identifier;
-    return true;
-  });
-}
-
 // src/rules/_private-scalar-consumer.ts
 function directEval(node) {
   let callee = unwrapExpression(node.callee);
-  while (callee.type === import_utils23.AST_NODE_TYPES.TSInstantiationExpression) callee = unwrapExpression(callee.expression);
-  return callee.type === import_utils23.AST_NODE_TYPES.Identifier && callee.name === "eval";
+  while (callee.type === import_utils25.AST_NODE_TYPES.TSInstantiationExpression) callee = unwrapExpression(callee.expression);
+  return callee.type === import_utils25.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);
@@ -2672,7 +2841,7 @@ function nullishPrimitiveUnion(node) {
 function consumerAnnotation(node) {
   if (node.params.length !== 1) return void 0;
   const parameter = node.params[0];
-  return parameter?.type === import_utils23.AST_NODE_TYPES.Identifier || parameter?.type === import_utils23.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
+  return parameter?.type === import_utils25.AST_NODE_TYPES.Identifier || parameter?.type === import_utils25.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
 }
 function exportedSymbols(source, checker) {
   const symbol = checker.getSymbolAtLocation(source);
@@ -2703,12 +2872,12 @@ function independentSignature(native) {
   return parameter !== void 0 && parameter.type !== void 0 && !parameter.modifiers?.length && !parameter.questionToken && !parameter.initializer && !parameter.dotDotDotToken && (!import_typescript6.default.isIdentifier(parameter.name) || parameter.name.text !== "this");
 }
 function callableBinding(node, sourceCode) {
-  if (node.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration) {
-    if (node.parent.type !== import_utils23.AST_NODE_TYPES.Program) return void 0;
+  if (node.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.parent.type !== import_utils25.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_utils23.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils23.AST_NODE_TYPES.Identifier || declaration.id.typeAnnotation || declaration.parent.kind !== "const" || declaration.parent.parent.type !== import_utils23.AST_NODE_TYPES.Program) return void 0;
+  if (declaration.type !== import_utils25.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils25.AST_NODE_TYPES.Identifier || declaration.id.typeAnnotation || declaration.parent.kind !== "const" || declaration.parent.parent.type !== import_utils25.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) {
@@ -2716,7 +2885,7 @@ function directCalls(binding3) {
   const stable2 = stableValueBinding(binding3, (reference) => {
     const identifier = reference.identifier;
     const call = identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils23.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils23.AST_NODE_TYPES.Identifier) return false;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils25.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== 1 || call.arguments[0]?.type !== import_utils25.AST_NODE_TYPES.Identifier) return false;
     calls += 1;
     return true;
   });
@@ -2727,6 +2896,7 @@ function directCalls(binding3) {
 var CONFIG = { 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);';
 var NULLABLE_EXAMPLE = EXAMPLE.replace("readonly name: string", "readonly name: string | null").replace("return value.name;", "return value.name ?? '';");
+var OPTIONAL_EXAMPLE = EXAMPLE.replace("readonly breed: string", "readonly breed?: string");
 var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Keep the covering object contract in a private scalar consumer union.",
@@ -2738,12 +2908,14 @@ var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
     "Automatic fixes additionally require every existing identifier caller to be natively assignable to the original contract, without Any, unknown, error or unresolved types on the relevant surface. Comments inside the annotation and TypeScript suppression directives keep the finding manual. Removed named types/imports must retain an independent top-level exported type-alias or direct type-export read. Other removable annotations/assertions, the covering annotation and own-definition/self references cannot keep one another live; otherwise simultaneous fixes can introduce unused-type errors. The exact authored covering type and terminator token sequence are retained; edits that would merge distinct CR and LF terminators remain manual; no producer, call or function body is rewritten.",
     "Only an inline binary parameter union in a strict module's top-level private scalar consumer is supported. Exactly one parameter, an explicit broad primitive return annotation, a single pure returned scalar expression and direct identifier-argument callers are required. Type queries or type-only exports of the callable, public APIs, callbacks, contextual signatures, overloads, generics, decorators, async functions, direct eval and fresh-object callers prevent findings.",
     "Both alternatives must have complete ordinary finite structural surfaces consisting only of explicitly readonly broad string, number, boolean or bigint properties, optionally paired directly with null or undefined in an exact two-part union. Required and optional nullable fields may be read under the same native coverage proof. Every field must have one actual declaration origin throughout each alternative's inheritance/intersection graph. Shared ancestors retain that origin; repeated merged fields, explicit overrides and independently declared overlapping fields abstain, including valid compatible declarations. This excludes recovered conflicting properties without claiming whole-source health. Aliases, imports, re-exports and ordinary inheritance are resolved by the parser-owned TypeScript checker. Any, unknown, missing imports, open/generic/mapped/indexed types, classes, brands, literal discriminants, methods, properties with scalar type aliases, parenthesized or more complex property unions, callbacks and recursive or nested object fields are unsupported.",
-    "Reports only proper native assignability: covered is assignable to covering and the reverse is false. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any also cannot witness coverage. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; mutually assignable but nonidentical structures are excluded.",
+    "Reports proper native assignability, where covered is assignable to covering and the reverse is false, or mutual native assignability with a strict smaller declared covering surface and only optional covered-only members. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any cannot replace explicit declared coverage or the native Optional requirement. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; equal-key and incomparable mutually assignable structures are excluded. The mutual case additionally requires inline contracts or locally bound interfaces/type aliases whose alias and heritage references can be traced through the parser-owned type scope. Merged interface fragments must all resolve to the reference's same native symbol; mixed exported/local recovery abstains. Imported, global and qualified-namespace references in that path abstain; proper one-way coverage retains its existing alias/import support.",
     "General union simplification can change Extract, conditional types, in-narrowing, fresh-literal checking and public presentation. Those contexts are excluded even when ordinary assignment succeeds. Flat destructuring counts every bound field as read; whole-object escape, mutation, helpers, closures, reflection, serialization, dynamic reads, implicit Object capabilities and JSX prevent findings. Imported Python protocol assignability is not approximated by this rule."
   ],
   examples: [
     { id: "covered-alternative", title: "The private consumer needs the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "public-contract", title: "A public union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
+    { id: "optional-covered-alternative", scenarioId: "optional-readonly-contract", title: "An unread optional breed retains the smaller Animal surface", outcome: "match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("Dog | Animal", "Animal") }] },
+    { id: "optional-public-contract", scenarioId: "optional-readonly-contract", title: "A public optional union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
     { id: "nullable-covered-alternative", scenarioId: "nullable-readonly-contract", title: "A nullable name retains the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "nullable-domain-contract", scenarioId: "nullable-readonly-contract", title: "A literal breed keeps the authored domain contract", outcome: "no-match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("readonly breed: string", "readonly breed: 'Collie'") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true }
   ]
@@ -2758,6 +2930,68 @@ function scalarFields(type, checker) {
   }
   return fields2.size ? fields2 : null;
 }
+function localContractBindings(roots, source, services) {
+  const pending = [...roots];
+  const visited = /* @__PURE__ */ new Set();
+  for (let index = 0; index < pending.length; index++) {
+    const node = pending[index];
+    if (!node || visited.has(node)) continue;
+    visited.add(node);
+    const references = localContractReferences(node, source, services);
+    if (references === null) return false;
+    pending.push(...references);
+  }
+  return true;
+}
+function localContractReferences(node, source, services) {
+  switch (node.type) {
+    case import_utils26.AST_NODE_TYPES.TSTypeLiteral:
+      return [];
+    case import_utils26.AST_NODE_TYPES.TSIntersectionType:
+      return node.types;
+    case import_utils26.AST_NODE_TYPES.TSTypeReference:
+      return !node.typeArguments && node.typeName.type === import_utils26.AST_NODE_TYPES.Identifier ? [node.typeName] : null;
+    case import_utils26.AST_NODE_TYPES.Identifier:
+      return localBindingReferences(node, source, services);
+    default:
+      return null;
+  }
+}
+function localBindingReferences(identifier, source, services) {
+  const definitions2 = typeBinding(source, identifier)?.defs.filter((definition) => definition.isTypeDefinition).map((definition) => definition.node);
+  if (!definitions2?.length || !definitions2.every(moduleTypeDeclaration)) return null;
+  const first = definitions2[0];
+  if (definitions2.length === 1 && first?.type === import_utils26.AST_NODE_TYPES.TSTypeAliasDeclaration && !first.typeParameters) return [first.typeAnnotation];
+  const interfaces = definitions2.filter((definition) => definition.type === import_utils26.AST_NODE_TYPES.TSInterfaceDeclaration);
+  if (interfaces.length !== definitions2.length || interfaces.some((declaration) => declaration.typeParameters)) return null;
+  if (interfaces.length > 1) {
+    const checker = services.program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(identifier));
+    if (!symbol || interfaces.some((declaration) => checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(declaration.id)) !== symbol)) return null;
+  }
+  const bases = interfaces.flatMap((declaration) => declaration.extends.map((base) => base.expression));
+  return bases.every((base) => base.type === import_utils26.AST_NODE_TYPES.Identifier) ? bases : null;
+}
+function moduleTypeDeclaration(node) {
+  const parent = node.parent;
+  if (parent?.type === import_utils26.AST_NODE_TYPES.Program) return true;
+  if (parent?.type !== import_utils26.AST_NODE_TYPES.ExportNamedDeclaration && parent?.type !== import_utils26.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  return parent.parent.type === import_utils26.AST_NODE_TYPES.Program;
+}
+function coveringAlternative(leftNode, rightNode, checker, fieldsOf, reads) {
+  const left = checker.getTypeFromTypeNode(leftNode);
+  const right = checker.getTypeFromTypeNode(rightNode);
+  const leftFields = fieldsOf(left);
+  const rightFields = fieldsOf(right);
+  if (!leftFields || !rightFields) return null;
+  const forward = checker.isTypeAssignableTo(left, right);
+  const reverse = checker.isTypeAssignableTo(right, left);
+  const mutual = forward && reverse;
+  if (!forward && !reverse || mutual && leftFields.size === rightFields.size) return null;
+  const [covered2, covering, coveredFields, coveringFields] = forward && (!reverse || leftFields.size > rightFields.size) ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
+  if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || mutual && [...coveredFields].some(([key, required]) => required && !coveringFields.has(key)) || [...reads].some((key) => !coveringFields.has(key)) || ![...reads].some((key) => coveringFields.get(key))) return null;
+  return { covered: covered2, covering, mutual };
+}
 function privateUnionFix(sourceCode, services, proof) {
   const covering = services.tsNodeToESTreeNodeMap.get(proof.covering);
   if (!validConsumerFixCalls(proof.candidate, proof.parameter, sourceCode, services)) return null;
@@ -2777,7 +3011,7 @@ var no_redundant_consumer_union_default = createRule({
     let dynamic = false;
     const remember = (node) => {
       const annotation = consumerAnnotation(node);
-      if (annotation?.type === import_utils24.AST_NODE_TYPES.TSUnionType && annotation.types.length === 2) candidates.push(node);
+      if (annotation?.type === import_utils26.AST_NODE_TYPES.TSUnionType && annotation.types.length === 2) candidates.push(node);
     };
     return {
       FunctionDeclaration: remember,
@@ -2787,7 +3021,7 @@ var no_redundant_consumer_union_default = createRule({
       },
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
-        const services = import_utils24.ESLintUtils.getParserServices(context);
+        const services = import_utils26.ESLintUtils.getParserServices(context);
         const source = currentNativeSource(context.sourceCode, services);
         if (!source) return;
         const checker = services.program.getTypeChecker();
@@ -2808,17 +3042,11 @@ var no_redundant_consumer_union_default = createRule({
           const leftNode = annotation.types[0];
           const rightNode = annotation.types[1];
           if (!leftNode || !rightNode) continue;
-          const left = checker.getTypeFromTypeNode(leftNode);
-          const right = checker.getTypeFromTypeNode(rightNode);
-          const leftFields = fieldsOf(left);
-          const rightFields = fieldsOf(right);
-          if (!leftFields || !rightFields) continue;
-          const forward = checker.isTypeAssignableTo(left, right);
-          const reverse = checker.isTypeAssignableTo(right, left);
-          if (forward === reverse) continue;
-          const [coveredNode, coveringNode, coveredFields, coveringFields] = forward ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
-          if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || [...consumer.reads].some((key) => !coveringFields.has(key)) || ![...consumer.reads].some((key) => coveringFields.get(key))) continue;
+          const coverage = coveringAlternative(leftNode, rightNode, checker, fieldsOf, consumer.reads);
+          if (!coverage) continue;
           const reportNode = services.tsNodeToESTreeNodeMap.get(annotation);
+          if (coverage.mutual && (reportNode.type !== import_utils26.AST_NODE_TYPES.TSUnionType || !localContractBindings(reportNode.types, context.sourceCode, services))) continue;
+          const { covered: coveredNode, covering: coveringNode } = coverage;
           const fix = privateUnionFix(context.sourceCode, services, {
             candidate: candidate2,
             parameter: consumer.parameter,
@@ -2835,7 +3063,7 @@ var no_redundant_consumer_union_default = createRule({
 });
 
 // src/rules/prefer-minimal-parameter-contract.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var import_typescript8 = __toESM(require("typescript"), 1);
 var CONFIG2 = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler"}}' };
 var EXAMPLE2 = 'export {}; const account = {name: "Ada", email: "a"}; function label(user: {readonly email: string; readonly name: string}): string {return user.name;} label(account);';
@@ -2886,7 +3114,7 @@ var prefer_minimal_parameter_contract_default = createRule({
     const candidates = [];
     let dynamic = false;
     const remember = (node) => {
-      if (consumerAnnotation(node)?.type === import_utils25.AST_NODE_TYPES.TSTypeLiteral) candidates.push(node);
+      if (consumerAnnotation(node)?.type === import_utils27.AST_NODE_TYPES.TSTypeLiteral) candidates.push(node);
     };
     return {
       FunctionDeclaration: remember,
@@ -2896,7 +3124,7 @@ var prefer_minimal_parameter_contract_default = createRule({
       },
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
-        const services = import_utils25.ESLintUtils.getParserServices(context);
+        const services = import_utils27.ESLintUtils.getParserServices(context);
         const source = currentNativeSource(context.sourceCode, services);
         if (!source) return;
         const checker = services.program.getTypeChecker();
@@ -2920,7 +3148,7 @@ var prefer_minimal_parameter_contract_default = createRule({
 });
 
 // src/rules/no-excess-jsx-props.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 var import_typescript10 = __toESM(require("typescript"), 1);
 
 // src/rules/_ordinary-object-effects.ts
@@ -3262,11 +3490,11 @@ var PRIMITIVE_OPERATORS = /* @__PURE__ */ new Set([
 function plainLiteralFields(node) {
   const fields2 = /* @__PURE__ */ new Map();
   for (const property of node.properties) {
-    if (property.type !== import_utils26.AST_NODE_TYPES.Property || property.kind !== "init") return null;
+    if (property.type !== import_utils28.AST_NODE_TYPES.Property || property.kind !== "init") return null;
     const key = property.key;
     let name;
-    if (!property.computed && key.type === import_utils26.AST_NODE_TYPES.Identifier) name = key.name;
-    else if (key.type === import_utils26.AST_NODE_TYPES.Literal && (typeof key.value === "string" || typeof key.value === "number")) name = String(key.value);
+    if (!property.computed && key.type === import_utils28.AST_NODE_TYPES.Identifier) name = key.name;
+    else if (key.type === import_utils28.AST_NODE_TYPES.Literal && (typeof key.value === "string" || typeof key.value === "number")) name = String(key.value);
     else return null;
     if (name === "__proto__") return null;
     fields2.set(name, property);
@@ -3378,35 +3606,35 @@ function localObjectFields(symbol, source, proof) {
   if (!native || native.getSourceFile() !== source || !initializer || !import_typescript10.default.isObjectLiteralExpression(initializer)) return null;
   const declaration = proof.services.tsNodeToESTreeNodeMap.get(native);
   const literal2 = proof.services.tsNodeToESTreeNodeMap.get(initializer);
-  if (declaration.type !== import_utils26.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.id.type !== import_utils26.AST_NODE_TYPES.Identifier || literal2.type !== import_utils26.AST_NODE_TYPES.ObjectExpression || declaration.parent.parent.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration) return null;
+  if (declaration.type !== import_utils28.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.id.type !== import_utils28.AST_NODE_TYPES.Identifier || literal2.type !== import_utils28.AST_NODE_TYPES.ObjectExpression || declaration.parent.parent.type === import_utils28.AST_NODE_TYPES.ExportNamedDeclaration) return null;
   const fields2 = plainLiteralFields(literal2);
   const binding3 = proof.sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
   if (!fields2 || !binding3 || binding3.defs.length !== 1 || !stableValueBinding(binding3, (reference) => {
     if (!reference.isReadOnly() || reference.isTypeReference) return false;
     const member3 = reference.identifier.parent;
-    return member3.type === import_utils26.AST_NODE_TYPES.MemberExpression && member3.object === reference.identifier && readonlyFieldValue(member3, fields2);
+    return member3.type === import_utils28.AST_NODE_TYPES.MemberExpression && member3.object === reference.identifier && readonlyFieldValue(member3, fields2);
   })) return null;
   return fields2;
 }
 function staticMemberKey(member3) {
   const property = member3.property;
-  return !member3.computed && property.type === import_utils26.AST_NODE_TYPES.Identifier ? property.name : property.type === import_utils26.AST_NODE_TYPES.Literal && (typeof property.value === "string" || typeof property.value === "number") ? String(property.value) : void 0;
+  return !member3.computed && property.type === import_utils28.AST_NODE_TYPES.Identifier ? property.name : property.type === import_utils28.AST_NODE_TYPES.Literal && (typeof property.value === "string" || typeof property.value === "number") ? String(property.value) : void 0;
 }
 function readonlyFieldValue(member3, fields2) {
   const key = staticMemberKey(member3);
   if (key === void 0 || !fields2.has(key)) return false;
   const parent = member3.parent;
-  if (parent.type === import_utils26.AST_NODE_TYPES.Property && parent.value === member3 && parent.parent.type === import_utils26.AST_NODE_TYPES.ObjectExpression) {
+  if (parent.type === import_utils28.AST_NODE_TYPES.Property && parent.value === member3 && parent.parent.type === import_utils28.AST_NODE_TYPES.ObjectExpression) {
     const object = parent.parent;
     const owner = object.parent;
-    return owner.type === import_utils26.AST_NODE_TYPES.JSXSpreadAttribute && owner.argument === object || owner.type === import_utils26.AST_NODE_TYPES.VariableDeclarator && owner.init === object;
+    return owner.type === import_utils28.AST_NODE_TYPES.JSXSpreadAttribute && owner.argument === object || owner.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && owner.init === object;
   }
-  return parent.type === import_utils26.AST_NODE_TYPES.JSXExpressionContainer && parent.expression === member3 || parent.type === import_utils26.AST_NODE_TYPES.VariableDeclarator && parent.init === member3;
+  return parent.type === import_utils28.AST_NODE_TYPES.JSXExpressionContainer && parent.expression === member3 || parent.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && parent.init === member3;
 }
 function privateElementDeclaration(opening) {
   const value = outerExpression(opening.parent);
   const declaration = value.parent;
-  return declaration.type === import_utils26.AST_NODE_TYPES.VariableDeclarator && declaration.init === value && declaration.id.type === import_utils26.AST_NODE_TYPES.Identifier && declaration.parent.kind === "const" && declaration.parent.parent.type !== import_utils26.AST_NODE_TYPES.ExportNamedDeclaration ? declaration : null;
+  return declaration.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && declaration.init === value && declaration.id.type === import_utils28.AST_NODE_TYPES.Identifier && declaration.parent.kind === "const" && declaration.parent.parent.type !== import_utils28.AST_NODE_TYPES.ExportNamedDeclaration ? declaration : null;
 }
 function closedElementValue(opening, declaration, fields2, reads, proof) {
   if (!proof.staticScope || !closedInvocation(opening, proof) || !constInitializer(proof.services.esTreeNodeToTSNodeMap.get(declaration))) return false;
@@ -3432,10 +3660,10 @@ function closedInvocation(node, proof) {
 }
 function independentInvocation(scope, proof) {
   const block = scope.block;
-  if (block.type !== import_utils26.AST_NODE_TYPES.ArrowFunctionExpression && block.type !== import_utils26.AST_NODE_TYPES.FunctionDeclaration && block.type !== import_utils26.AST_NODE_TYPES.FunctionExpression) return false;
+  if (block.type !== import_utils28.AST_NODE_TYPES.ArrowFunctionExpression && block.type !== import_utils28.AST_NODE_TYPES.FunctionDeclaration && block.type !== import_utils28.AST_NODE_TYPES.FunctionExpression) return false;
   if (block.async || block.generator || scope.set.get("arguments")?.references.some((reference) => !typeOnlyReference(reference))) return false;
   for (const parameter of block.params) {
-    if (parameter.type !== import_utils26.AST_NODE_TYPES.Identifier || parameter.name === "this") return false;
+    if (parameter.type !== import_utils28.AST_NODE_TYPES.Identifier || parameter.name === "this") return false;
     const binding3 = scope.set.get(parameter.name);
     if (!binding3 || binding3.references.some((reference) => !typeOnlyReference(reference))) return false;
   }
@@ -3443,16 +3671,16 @@ function independentInvocation(scope, proof) {
     if (typeOnlyReference(reference)) return true;
     const value = outerExpression(reference.identifier);
     const parent = value.parent;
-    const read = parent?.type === import_utils26.AST_NODE_TYPES.MemberExpression && parent.object === value ? parent : value;
+    const read = parent?.type === import_utils28.AST_NODE_TYPES.MemberExpression && parent.object === value ? parent : value;
     return primitiveValue(proof.services.esTreeNodeToTSNodeMap.get(read), proof, /* @__PURE__ */ new Set());
   });
 }
 function consumedElementRead(node, fields2, reads) {
   const identifier = outerExpression(node);
   const props = identifier.parent;
-  if (!props || props.type !== import_utils26.AST_NODE_TYPES.MemberExpression || props.object !== identifier || props.optional || staticMemberKey(props) !== "props") return false;
+  if (!props || props.type !== import_utils28.AST_NODE_TYPES.MemberExpression || props.object !== identifier || props.optional || staticMemberKey(props) !== "props") return false;
   const member3 = props.parent;
-  if (member3.type !== import_utils26.AST_NODE_TYPES.MemberExpression || member3.object !== props || member3.optional) return false;
+  if (member3.type !== import_utils28.AST_NODE_TYPES.MemberExpression || member3.object !== props || member3.optional) return false;
   const key = staticMemberKey(member3);
   return key !== void 0 && reads.has(key) && readonlyFieldValue(member3, fields2);
 }
@@ -3480,7 +3708,7 @@ var no_excess_jsx_props_default = createRule({
     const evaluate = (node, declaration, fields2) => {
       const keys = [...fields2.keys()];
       const opening = node.parent;
-      services ??= import_utils26.ESLintUtils.getParserServices(context);
+      services ??= import_utils28.ESLintUtils.getParserServices(context);
       standardJSX ??= supportedJSX(services.program.getCompilerOptions(), context.sourceCode.getAllComments());
       if (!standardJSX) return;
       const checker = services.program.getTypeChecker();
@@ -3513,9 +3741,9 @@ var no_excess_jsx_props_default = createRule({
     };
     return {
       JSXSpreadAttribute(node) {
-        if (node.argument.type !== import_utils26.AST_NODE_TYPES.ObjectExpression) return;
+        if (node.argument.type !== import_utils28.AST_NODE_TYPES.ObjectExpression) return;
         const opening = node.parent;
-        if (!opening.selfClosing || opening.attributes.length !== 1 || opening.name.type !== import_utils26.AST_NODE_TYPES.JSXIdentifier || /^[a-z]/u.test(opening.name.name)) return;
+        if (!opening.selfClosing || opening.attributes.length !== 1 || opening.name.type !== import_utils28.AST_NODE_TYPES.JSXIdentifier || /^[a-z]/u.test(opening.name.name)) return;
         const declaration = privateElementDeclaration(opening);
         if (!declaration) return;
         const fields2 = literalFields(node.argument);
@@ -3527,7 +3755,7 @@ var no_excess_jsx_props_default = createRule({
       },
       "Program:exit"() {
         if (!candidates.length) return;
-        services = import_utils26.ESLintUtils.getParserServices(context);
+        services = import_utils28.ESLintUtils.getParserServices(context);
         if (!currentNativeSource(context.sourceCode, services)) return;
         for (const { node, declaration, fields: fields2 } of candidates) evaluate(node, declaration, fields2);
       }
@@ -3536,7 +3764,7 @@ var no_excess_jsx_props_default = createRule({
 });
 
 // src/rules/prefer-native-fetch-in-server-actions.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 var KY_MODULE = /^ky(?:\/.*)?$/u;
 var PREFER_NATIVE_FETCH_IN_SERVER_ACTIONS_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -3600,19 +3828,19 @@ var prefer_native_fetch_in_server_actions_default = createRule({
 });
 function hasUseServerDirective(program) {
   for (const statement of program.body) {
-    if (statement.type !== import_utils27.AST_NODE_TYPES.ExpressionStatement || statement.directive === void 0) return false;
+    if (statement.type !== import_utils29.AST_NODE_TYPES.ExpressionStatement || statement.directive === void 0) return false;
     if (statement.directive === "use server") return true;
   }
   return false;
 }
 function isTypeOnly(node) {
   return node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every(
-    (specifier) => specifier.type === import_utils27.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
+    (specifier) => specifier.type === import_utils29.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
   );
 }
 
 // src/rules/no-credential-in-browser-storage.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 
 // src/rules/_secret-names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -3756,54 +3984,10 @@ function isAuthSecretName(identifier) {
   return hasApiKey(tokens);
 }
 
-// src/rules/_static-string.ts
-var import_utils28 = require("@typescript-eslint/utils");
-function staticString(node) {
-  if (node === void 0) return null;
-  const value = unwrapExpression(node);
-  if (value.type === import_utils28.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
-  return value.type === import_utils28.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_utils28.AST_NODE_TYPES.Identifier) return staticString(value);
-  let values = SCOPED_STRING_VALUES.get(sourceCode);
-  if (values === void 0) {
-    values = /* @__PURE__ */ new WeakMap();
-    SCOPED_STRING_VALUES.set(sourceCode, values);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const pending = [];
-  let result = null;
-  while (value.type === import_utils28.AST_NODE_TYPES.Identifier) {
-    const binding3 = import_utils28.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
-    if (binding3 === null || seen.has(binding3)) break;
-    if (values.has(binding3)) {
-      result = values.get(binding3) ?? null;
-      break;
-    }
-    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_utils28.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_utils28.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_utils28.ASTUtils.getPropertyName(node);
-  if (direct !== null || !node.computed) return direct;
-  const key = node.type === import_utils28.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
-  return scopedStaticString(key, sourceCode);
-}
-
 // src/rules/no-credential-in-browser-storage.ts
 var STORAGE_NAMES = /* @__PURE__ */ new Set(["localStorage", "sessionStorage"]);
 var METADATA_WORDS = /* @__PURE__ */ new Set(["page", "cursor", "next", "hint", "expires", "expiry", "expiration"]);
-var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["window", "globalThis", "self"]);
+var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set(["window", "globalThis", "self"]);
 var NO_CREDENTIAL_IN_BROWSER_STORAGE_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Do not write credential-named values to browser storage or script-readable cookies.",
@@ -3861,7 +4045,7 @@ var no_credential_in_browser_storage_default = createRule({
     return {
       CallExpression(node) {
         const callee = unwrapExpression(node.callee);
-        if (callee.type !== import_utils29.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils29.AST_NODE_TYPES.Identifier || callee.property.name !== "setItem" || !isStorage(sourceCode, callee.object)) {
+        if (callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier || callee.property.name !== "setItem" || !isStorage(sourceCode, callee.object)) {
           return;
         }
         const [key] = node.arguments;
@@ -3869,12 +4053,12 @@ var no_credential_in_browser_storage_default = createRule({
       },
       AssignmentExpression(node) {
         const target = node.left;
-        if (target.type !== import_utils29.AST_NODE_TYPES.MemberExpression) return;
+        if (target.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return;
         if (isStorage(sourceCode, target.object)) {
           report2(node, storedPropertyKey(sourceCode, target));
           return;
         }
-        if (!target.computed && target.property.type === import_utils29.AST_NODE_TYPES.Identifier && target.property.name === "cookie" && globalMemberName(sourceCode, target.object) === "document") {
+        if (!target.computed && target.property.type === import_utils30.AST_NODE_TYPES.Identifier && target.property.name === "cookie" && globalMemberName(sourceCode, target.object) === "document") {
           report2(node, cookieName(node.right));
         }
       }
@@ -3887,34 +4071,34 @@ function isStorage(sourceCode, node) {
 }
 function globalMemberName(sourceCode, node) {
   const value = unwrapExpression(node);
-  if (value.type === import_utils29.AST_NODE_TYPES.Identifier) return isUnshadowed(sourceCode, value) ? value.name : null;
-  if (value.type === import_utils29.AST_NODE_TYPES.MemberExpression && !value.computed && value.object.type === import_utils29.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(value.object.name) && value.property.type === import_utils29.AST_NODE_TYPES.Identifier && isUnshadowed(sourceCode, value.object)) {
+  if (value.type === import_utils30.AST_NODE_TYPES.Identifier) return isUnshadowed(sourceCode, value) ? value.name : null;
+  if (value.type === import_utils30.AST_NODE_TYPES.MemberExpression && !value.computed && value.object.type === import_utils30.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(value.object.name) && value.property.type === import_utils30.AST_NODE_TYPES.Identifier && isUnshadowed(sourceCode, value.object)) {
     return value.property.name;
   }
   return null;
 }
 function isUnshadowed(sourceCode, node) {
-  const variable = import_utils29.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  const variable = import_utils30.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function storedPropertyKey(sourceCode, target) {
-  if (!target.computed) return target.property.type === import_utils29.AST_NODE_TYPES.Identifier ? target.property.name : null;
+  if (!target.computed) return target.property.type === import_utils30.AST_NODE_TYPES.Identifier ? target.property.name : null;
   return scopedStaticString(target.property, sourceCode);
 }
 function cookieName(value) {
   let expression = unwrapExpression(value);
-  while (expression.type === import_utils29.AST_NODE_TYPES.BinaryExpression && expression.operator === "+") {
+  while (expression.type === import_utils30.AST_NODE_TYPES.BinaryExpression && expression.operator === "+") {
     expression = unwrapExpression(expression.left);
   }
   let text = null;
-  if (expression.type === import_utils29.AST_NODE_TYPES.Literal && typeof expression.value === "string") text = expression.value;
-  if (expression.type === import_utils29.AST_NODE_TYPES.TemplateLiteral) text = expression.quasis[0]?.value.cooked ?? null;
+  if (expression.type === import_utils30.AST_NODE_TYPES.Literal && typeof expression.value === "string") text = expression.value;
+  if (expression.type === import_utils30.AST_NODE_TYPES.TemplateLiteral) text = expression.quasis[0]?.value.cooked ?? null;
   if (text === null || !text.includes("=")) return null;
   return text.slice(0, text.indexOf("=")).trim();
 }
 
 // src/rules/no-numeric-search-param-coercion.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 var GLOBAL_PARSERS = /* @__PURE__ */ new Set(["parseInt", "parseFloat", "Number"]);
 var NUMBER_PARSERS = /* @__PURE__ */ new Set(["parseInt", "parseFloat"]);
 var SEARCH_PARAM_TYPES = /* @__PURE__ */ new Set(["URLSearchParams", "ReadonlyURLSearchParams"]);
@@ -3971,7 +4155,7 @@ var no_numeric_search_param_coercion_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text) || isTestFile(context)) return {};
     let services;
     try {
-      services = import_utils30.ESLintUtils.getParserServices(context);
+      services = import_utils31.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -3993,27 +4177,27 @@ var no_numeric_search_param_coercion_default = createRule({
   }
 });
 function isNumericParser(sourceCode, callee) {
-  if (callee.type === import_utils30.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils31.AST_NODE_TYPES.Identifier) {
     return GLOBAL_PARSERS.has(callee.name) && isUnshadowedGlobal(sourceCode, callee);
   }
-  return callee.type === import_utils30.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils30.AST_NODE_TYPES.Identifier && callee.object.name === "Number" && callee.property.type === import_utils30.AST_NODE_TYPES.Identifier && NUMBER_PARSERS.has(callee.property.name) && isUnshadowedGlobal(sourceCode, callee.object);
+  return callee.type === import_utils31.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils31.AST_NODE_TYPES.Identifier && callee.object.name === "Number" && callee.property.type === import_utils31.AST_NODE_TYPES.Identifier && NUMBER_PARSERS.has(callee.property.name) && isUnshadowedGlobal(sourceCode, callee.object);
 }
 function isUnshadowedGlobal(sourceCode, node) {
-  const variable = import_utils30.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  const variable = import_utils31.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function searchParamGetCall(argument) {
   let value = unwrapExpression(argument);
-  if (value.type === import_utils30.AST_NODE_TYPES.AwaitExpression) value = unwrapExpression(value.argument);
-  if (value.type === import_utils30.AST_NODE_TYPES.LogicalExpression && value.operator === "??") value = unwrapExpression(value.left);
-  if (value.type === import_utils30.AST_NODE_TYPES.ChainExpression) value = value.expression;
-  if (value.type !== import_utils30.AST_NODE_TYPES.CallExpression || value.callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || value.callee.computed || value.callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier || value.callee.property.name !== "get") {
+  if (value.type === import_utils31.AST_NODE_TYPES.AwaitExpression) value = unwrapExpression(value.argument);
+  if (value.type === import_utils31.AST_NODE_TYPES.LogicalExpression && value.operator === "??") value = unwrapExpression(value.left);
+  if (value.type === import_utils31.AST_NODE_TYPES.ChainExpression) value = value.expression;
+  if (value.type !== import_utils31.AST_NODE_TYPES.CallExpression || value.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || value.callee.computed || value.callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || value.callee.property.name !== "get") {
     return null;
   }
   return value;
 }
 function isSearchParamReceiver(call, services) {
-  if (call.callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return false;
+  if (call.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression) return false;
   const checker = services.program.getTypeChecker();
   const type = checker.getNonNullableType(
     checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(call.callee.object))
@@ -4025,7 +4209,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.36.6",
+  version: "16.38.50",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -4147,11 +4331,11 @@ var package_default = {
 };
 
 // src/rules/require-explicit-contract-implementation.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 var ts12 = __toESM(require("typescript"), 1);
 
 // src/rules/_closed-nominal-inheritance-fix.ts
-var import_utils31 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 var import_typescript11 = __toESM(require("typescript"), 1);
 function closedNominalInheritanceFix(sourceCode, call, consumer, implementation, contract) {
   const source = call.getSourceFile();
@@ -4225,7 +4409,7 @@ function exactRejection(sourceCode, statement) {
   const identifier = sourceCode.getNodeByRangeIndex(
     rejected.expression.expression.getStart()
   );
-  return identifier?.type === import_utils31.AST_NODE_TYPES.Identifier && identifier.name === "TypeError" && (import_utils31.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
+  return identifier?.type === import_utils32.AST_NODE_TYPES.Identifier && identifier.name === "TypeError" && (import_utils32.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
 }
 function exactConstruction(node, consumer, implementation) {
   if (!import_typescript11.default.isIdentifier(node.expression) || node.expression.text !== consumer || node.typeArguments !== void 0 || node.arguments?.length !== 1)
@@ -4591,7 +4775,7 @@ var require_explicit_contract_implementation_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap)
       return {};
-    const services = import_utils32.ESLintUtils.getParserServices(context);
+    const services = import_utils33.ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
     function inspect(node) {
       const tsNode = services.esTreeNodeToTSNodeMap.get(node);
@@ -4606,7 +4790,7 @@ var require_explicit_contract_implementation_default = createRule({
         return;
       const parameters = signature.getParameters();
       for (const [index, argument] of node.arguments.entries()) {
-        if (argument.type !== import_utils32.AST_NODE_TYPES.NewExpression) continue;
+        if (argument.type !== import_utils33.AST_NODE_TYPES.NewExpression) continue;
         const parameter = parameters[index];
         if (parameter === void 0) continue;
         const tsArgument = services.esTreeNodeToTSNodeMap.get(argument);
@@ -4653,18 +4837,18 @@ var require_explicit_contract_implementation_default = createRule({
 });
 
 // src/rules/require-explicit-service-contract.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils36 = require("@typescript-eslint/utils");
 
 // src/rules/_existing-factory-contract-fix.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 function existingFactoryContractFix(sourceCode, candidate2) {
   if (sourceCode.ast.body.length !== 4 || sourceCode.getAllComments().length !== 0)
     return null;
   const [contractStatement, worker, classStatement, factoryStatement] = sourceCode.ast.body;
-  const contract = contractStatement?.type === import_utils33.AST_NODE_TYPES.ExportNamedDeclaration ? contractStatement.declaration : null;
-  const implementation = classStatement?.type === import_utils33.AST_NODE_TYPES.ExportNamedDeclaration ? classStatement.declaration : classStatement;
-  const factory = factoryStatement?.type === import_utils33.AST_NODE_TYPES.ExportNamedDeclaration ? factoryStatement.declaration : null;
-  if (contract?.type !== import_utils33.AST_NODE_TYPES.TSTypeAliasDeclaration || worker?.type !== import_utils33.AST_NODE_TYPES.TSInterfaceDeclaration || implementation?.type !== import_utils33.AST_NODE_TYPES.ClassDeclaration || implementation !== candidate2 || !ordinaryClass(implementation) || !ordinaryFactory(factory))
+  const contract = contractStatement?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? contractStatement.declaration : null;
+  const implementation = classStatement?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? classStatement.declaration : classStatement;
+  const factory = factoryStatement?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? factoryStatement.declaration : null;
+  if (contract?.type !== import_utils34.AST_NODE_TYPES.TSTypeAliasDeclaration || worker?.type !== import_utils34.AST_NODE_TYPES.TSInterfaceDeclaration || implementation?.type !== import_utils34.AST_NODE_TYPES.ClassDeclaration || implementation !== candidate2 || !ordinaryClass(implementation) || !ordinaryFactory(factory))
     return null;
   const operation2 = contractOperation(contract);
   if (operation2 === null || interfaceOperation(worker) !== operation2)
@@ -4683,17 +4867,17 @@ function ordinaryClass(node) {
   return node.id !== null && !node.declare && !node.abstract && node.decorators.length === 0 && node.superClass === null && node.implements.length === 0 && node.typeParameters === void 0 && node.body.body.length === 2;
 }
 function ordinaryFactory(node) {
-  return node?.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.params.length === 1 && node.body.body.length === 1;
+  return node?.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.params.length === 1 && node.body.body.length === 1;
 }
 function interfaceOperation(node) {
   return !node.declare && node.extends.length === 0 && node.typeParameters === void 0 ? singletonOperation(node.body.body) : null;
 }
 function contractOperation(node) {
-  return !node.declare && node.typeParameters === void 0 && node.typeAnnotation.type === import_utils33.AST_NODE_TYPES.TSTypeLiteral ? singletonOperation(node.typeAnnotation.members) : null;
+  return !node.declare && node.typeParameters === void 0 && node.typeAnnotation.type === import_utils34.AST_NODE_TYPES.TSTypeLiteral ? singletonOperation(node.typeAnnotation.members) : null;
 }
 function singletonOperation(members) {
   const member3 = members[0];
-  return members.length === 1 && member3?.type === import_utils33.AST_NODE_TYPES.TSMethodSignature && member3.kind === "method" && !member3.computed && !member3.optional && member3.key.type === import_utils33.AST_NODE_TYPES.Identifier && member3.params.length === 0 && member3.typeParameters === void 0 && member3.returnType?.typeAnnotation.type === import_utils33.AST_NODE_TYPES.TSVoidKeyword ? member3.key.name : null;
+  return members.length === 1 && member3?.type === import_utils34.AST_NODE_TYPES.TSMethodSignature && member3.kind === "method" && !member3.computed && !member3.optional && member3.key.type === import_utils34.AST_NODE_TYPES.Identifier && member3.params.length === 0 && member3.typeParameters === void 0 && member3.returnType?.typeAnnotation.type === import_utils34.AST_NODE_TYPES.TSVoidKeyword ? member3.key.name : null;
 }
 function uniqueDeclarations(sourceCode, declarations) {
   const names = declarations.flatMap(
@@ -4704,7 +4888,7 @@ function uniqueDeclarations(sourceCode, declarations) {
   );
 }
 function sameBinding(sourceCode, reference, declaration) {
-  const binding3 = import_utils33.ASTUtils.findVariable(
+  const binding3 = import_utils34.ASTUtils.findVariable(
     sourceCode.getScope(reference),
     reference.name
   );
@@ -4712,45 +4896,45 @@ function sameBinding(sourceCode, reference, declaration) {
 }
 function retainedWorker(sourceCode, implementation, worker) {
   const constructor = implementation.body.body[0];
-  if (constructor?.type !== import_utils33.AST_NODE_TYPES.MethodDefinition || constructor.value.type !== import_utils33.AST_NODE_TYPES.FunctionExpression || constructor.kind !== "constructor" || constructor.computed || constructor.static || constructor.decorators.length !== 0 || constructor.optional || constructor.accessibility !== void 0 && constructor.accessibility !== "public" || constructor.value.async || constructor.value.generator || constructor.value.typeParameters !== void 0 || constructor.value.returnType !== void 0 || constructor.value.body.body.length !== 0 || constructor.value.params.length !== 1)
+  if (constructor?.type !== import_utils34.AST_NODE_TYPES.MethodDefinition || constructor.value.type !== import_utils34.AST_NODE_TYPES.FunctionExpression || constructor.kind !== "constructor" || constructor.computed || constructor.static || constructor.decorators.length !== 0 || constructor.optional || constructor.accessibility !== void 0 && constructor.accessibility !== "public" || constructor.value.async || constructor.value.generator || constructor.value.typeParameters !== void 0 || constructor.value.returnType !== void 0 || constructor.value.body.body.length !== 0 || constructor.value.params.length !== 1)
     return null;
   const property = constructor.value.params[0];
-  if (property?.type !== import_utils33.AST_NODE_TYPES.TSParameterProperty || property.accessibility !== "private" || !property.readonly || property.override || property.decorators.length !== 0 || property.parameter.type !== import_utils33.AST_NODE_TYPES.Identifier || property.parameter.optional || !typeReference(sourceCode, property.parameter.typeAnnotation, worker))
+  if (property?.type !== import_utils34.AST_NODE_TYPES.TSParameterProperty || property.accessibility !== "private" || !property.readonly || property.override || property.decorators.length !== 0 || property.parameter.type !== import_utils34.AST_NODE_TYPES.Identifier || property.parameter.optional || !typeReference(sourceCode, property.parameter.typeAnnotation, worker))
     return null;
   return property.parameter.name;
 }
 function typeReference(sourceCode, annotation, declaration) {
   const type = annotation?.typeAnnotation;
-  return type?.type === import_utils33.AST_NODE_TYPES.TSTypeReference && type.typeArguments === void 0 && type.typeName.type === import_utils33.AST_NODE_TYPES.Identifier && sameBinding(sourceCode, type.typeName, declaration);
+  return type?.type === import_utils34.AST_NODE_TYPES.TSTypeReference && type.typeArguments === void 0 && type.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && sameBinding(sourceCode, type.typeName, declaration);
 }
 function forwardsOperation(implementation, field, operation2) {
   const method = implementation.body.body[1];
-  if (method?.type !== import_utils33.AST_NODE_TYPES.MethodDefinition || method.kind !== "method" || method.value.type !== import_utils33.AST_NODE_TYPES.FunctionExpression || method.computed || method.static || method.optional || method.override || method.decorators.length !== 0 || method.accessibility !== void 0 && method.accessibility !== "public" || method.key.type !== import_utils33.AST_NODE_TYPES.Identifier || method.key.name !== operation2 || method.value.async || method.value.generator || method.value.typeParameters !== void 0 || method.value.params.length !== 0 || method.value.body.body.length !== 1 || method.value.returnType?.typeAnnotation.type !== import_utils33.AST_NODE_TYPES.TSVoidKeyword)
+  if (method?.type !== import_utils34.AST_NODE_TYPES.MethodDefinition || method.kind !== "method" || method.value.type !== import_utils34.AST_NODE_TYPES.FunctionExpression || method.computed || method.static || method.optional || method.override || method.decorators.length !== 0 || method.accessibility !== void 0 && method.accessibility !== "public" || method.key.type !== import_utils34.AST_NODE_TYPES.Identifier || method.key.name !== operation2 || method.value.async || method.value.generator || method.value.typeParameters !== void 0 || method.value.params.length !== 0 || method.value.body.body.length !== 1 || method.value.returnType?.typeAnnotation.type !== import_utils34.AST_NODE_TYPES.TSVoidKeyword)
     return false;
   const statement = method.value.body.body[0];
-  const call = statement?.type === import_utils33.AST_NODE_TYPES.ExpressionStatement ? statement.expression : null;
-  return call?.type === import_utils33.AST_NODE_TYPES.CallExpression && !call.optional && call.typeArguments === void 0 && call.arguments.length === 0 && forwardedMember(call.callee, field, operation2);
+  const call = statement?.type === import_utils34.AST_NODE_TYPES.ExpressionStatement ? statement.expression : null;
+  return call?.type === import_utils34.AST_NODE_TYPES.CallExpression && !call.optional && call.typeArguments === void 0 && call.arguments.length === 0 && forwardedMember(call.callee, field, operation2);
 }
 function forwardedMember(node, field, operation2) {
-  if (node.type !== import_utils33.AST_NODE_TYPES.MemberExpression || node.computed || node.optional || node.property.type !== import_utils33.AST_NODE_TYPES.Identifier || node.property.name !== operation2)
+  if (node.type !== import_utils34.AST_NODE_TYPES.MemberExpression || node.computed || node.optional || node.property.type !== import_utils34.AST_NODE_TYPES.Identifier || node.property.name !== operation2)
     return false;
   const receiver = node.object;
-  return receiver.type === import_utils33.AST_NODE_TYPES.MemberExpression && !receiver.computed && !receiver.optional && receiver.object.type === import_utils33.AST_NODE_TYPES.ThisExpression && receiver.property.type === import_utils33.AST_NODE_TYPES.Identifier && receiver.property.name === field;
+  return receiver.type === import_utils34.AST_NODE_TYPES.MemberExpression && !receiver.computed && !receiver.optional && receiver.object.type === import_utils34.AST_NODE_TYPES.ThisExpression && receiver.property.type === import_utils34.AST_NODE_TYPES.Identifier && receiver.property.name === field;
 }
 function factoryAuthority(sourceCode, factory, contract, worker, implementation) {
   const parameter = factory.params[0];
-  if (parameter?.type !== import_utils33.AST_NODE_TYPES.Identifier || parameter.optional || !typeReference(sourceCode, parameter.typeAnnotation, worker) || !typeReference(sourceCode, factory.returnType, contract))
+  if (parameter?.type !== import_utils34.AST_NODE_TYPES.Identifier || parameter.optional || !typeReference(sourceCode, parameter.typeAnnotation, worker) || !typeReference(sourceCode, factory.returnType, contract))
     return false;
   const statement = factory.body.body[0];
-  const constructed = statement?.type === import_utils33.AST_NODE_TYPES.ReturnStatement ? statement.argument : null;
-  if (constructed?.type !== import_utils33.AST_NODE_TYPES.NewExpression || constructed.typeArguments !== void 0 || constructed.callee.type !== import_utils33.AST_NODE_TYPES.Identifier || !sameBinding(sourceCode, constructed.callee, implementation) || constructed.arguments.length !== 1)
+  const constructed = statement?.type === import_utils34.AST_NODE_TYPES.ReturnStatement ? statement.argument : null;
+  if (constructed?.type !== import_utils34.AST_NODE_TYPES.NewExpression || constructed.typeArguments !== void 0 || constructed.callee.type !== import_utils34.AST_NODE_TYPES.Identifier || !sameBinding(sourceCode, constructed.callee, implementation) || constructed.arguments.length !== 1)
     return false;
   const argument = constructed.arguments[0];
-  return argument?.type === import_utils33.AST_NODE_TYPES.Identifier && argument.name === parameter.name && sameBinding(sourceCode, argument, factory);
+  return argument?.type === import_utils34.AST_NODE_TYPES.Identifier && argument.name === parameter.name && sameBinding(sourceCode, argument, factory);
 }
 
 // src/rules/require-port-for-service.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 var REQUIRE_PORT_FOR_SERVICE_DOCUMENTATION = {
   summary: "Advise when an exported service with injected collaborators has public methods not covered by its declared ports.",
   rationale: "A declared port keeps consumers coupled to the service capability instead of its concrete implementation.",
@@ -4834,50 +5018,50 @@ var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
   "||="
 ]);
 var staticMemberName = (member3) => {
-  if (member3.property.type === import_utils34.AST_NODE_TYPES.PrivateIdentifier)
+  if (member3.property.type === import_utils35.AST_NODE_TYPES.PrivateIdentifier)
     return `#${member3.property.name}`;
-  return import_utils34.ASTUtils.getPropertyName(member3);
+  return import_utils35.ASTUtils.getPropertyName(member3);
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
         if (specifier.exportKind !== "type") names.add(specifier.local.name);
       }
-    } else if (statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils34.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils35.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils34.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils34.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils35.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils35.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass = (node, detached) => node.parent.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass = (node, detached) => node.parent.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var createExportedServiceClassResolver = (program) => {
   const detached = detachedValueExports(program);
   return (node) => isExportedClass(node, detached);
 };
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils34.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils35.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member3) => member3.type !== import_utils34.AST_NODE_TYPES.TSUndefinedKeyword && member3.type !== import_utils34.AST_NODE_TYPES.TSNullKeyword
+      (member3) => member3.type !== import_utils35.AST_NODE_TYPES.TSUndefinedKeyword && member3.type !== import_utils35.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils34.AST_NODE_TYPES.TSTypeReference)
+  if (annotation === void 0 || annotation.type !== import_utils35.AST_NODE_TYPES.TSTypeReference)
     return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils34.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils34.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils35.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils35.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === import_utils34.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils34.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils35.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils35.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member3 of members) {
-    if (member3.type !== import_utils34.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member3.computed || member3.key.type !== import_utils34.AST_NODE_TYPES.Identifier)
+    if (member3.type !== import_utils35.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member3.computed || member3.key.type !== import_utils35.AST_NODE_TYPES.Identifier)
       continue;
     const reference = readTypeReference(member3.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
@@ -4889,18 +5073,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = localFunctionAliases(program);
   function collectDeclaredType(statement) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils34.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(
         declaration.id.name,
         propertySignatureTypes(declaration.body.body)
       );
       return;
     }
-    if (declaration?.type !== import_utils34.AST_NODE_TYPES.TSTypeAliasDeclaration) return;
+    if (declaration?.type !== import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) return;
     const aliased = declaration.typeAnnotation;
-    const literals = aliased.type === import_utils34.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils34.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter(
-      (part) => part.type === import_utils34.AST_NODE_TYPES.TSTypeLiteral
+    const literals = aliased.type === import_utils35.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils35.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter(
+      (part) => part.type === import_utils35.AST_NODE_TYPES.TSTypeLiteral
     ) : [];
     if (literals.length === 0) return;
     const merged = /* @__PURE__ */ new Map();
@@ -4920,12 +5104,12 @@ function localFunctionAliases(program) {
   const names = /* @__PURE__ */ new Set();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type !== import_utils34.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type !== import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const annotation = declaration.typeAnnotation;
-    if (annotation.type === import_utils34.AST_NODE_TYPES.TSFunctionType || annotation.type === import_utils34.AST_NODE_TYPES.TSConstructorType)
+    if (annotation.type === import_utils35.AST_NODE_TYPES.TSFunctionType || annotation.type === import_utils35.AST_NODE_TYPES.TSConstructorType)
       names.add(declaration.id.name);
-    if (annotation.type === import_utils34.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils34.AST_NODE_TYPES.Identifier)
+    if (annotation.type === import_utils35.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils35.AST_NODE_TYPES.Identifier)
       parents.set(declaration.id.name, annotation.typeName.name);
   }
   for (let pass = 0; pass < parents.size; pass += 1) {
@@ -4961,32 +5145,32 @@ var readConstructor = (ctor, declared, typeParameters) => {
   function scanStoredFields(body4) {
     const pending = [...body4.body];
     function recordStoredField(current) {
-      if (current.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils34.AST_NODE_TYPES.FunctionExpression || current.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils34.AST_NODE_TYPES.ClassExpression || current.type === import_utils34.AST_NODE_TYPES.ClassDeclaration)
+      if (current.type === import_utils35.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils35.AST_NODE_TYPES.FunctionExpression || current.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils35.AST_NODE_TYPES.ClassExpression || current.type === import_utils35.AST_NODE_TYPES.ClassDeclaration)
         return;
-      if (current.type === import_utils34.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils34.AST_NODE_TYPES.Identifier)
+      if (current.type === import_utils35.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils35.AST_NODE_TYPES.Identifier)
         localBindings2.add(current.id.name);
-      const expression = current.type === import_utils34.AST_NODE_TYPES.AssignmentExpression ? current : null;
+      const expression = current.type === import_utils35.AST_NODE_TYPES.AssignmentExpression ? current : null;
       const storedField = writtenInstanceField(current);
       if (storedField !== null) {
         if (writtenFieldNames.has(storedField))
           unstableFieldNames.add(storedField);
         writtenFieldNames.add(storedField);
-        if (expression?.operator !== "=" || expression.parent.type !== import_utils34.AST_NODE_TYPES.ExpressionStatement || expression.parent.parent !== body4)
+        if (expression?.operator !== "=" || expression.parent.type !== import_utils35.AST_NODE_TYPES.ExpressionStatement || expression.parent.parent !== body4)
           unstableFieldNames.add(storedField);
       }
-      if (expression?.type !== import_utils34.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils34.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils34.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (expression?.type !== import_utils35.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils35.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils35.AST_NODE_TYPES.ThisExpression || storedField === null) {
         enqueueChildren(current);
         return;
       }
       const source = unwrapExpression(expression.right);
-      if (source.type === import_utils34.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils35.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
         constructedFieldNames.add(storedField);
-      } else if (source.type === import_utils34.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils35.AST_NODE_TYPES.Identifier) {
         const fields2 = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields2.add(storedField);
         storedFieldsFrom.set(source.name, fields2);
-      } else if (source.type === import_utils34.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils34.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils35.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils35.AST_NODE_TYPES.Identifier) {
         const fields2 = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields2.add(storedField);
         storedFieldsFrom.set(source.object.name, fields2);
@@ -5021,7 +5205,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
     )) {
       if (localBindings2.has(reference.name)) continue;
       let fields2 = reference.fields;
-      if (parameter.type === import_utils34.AST_NODE_TYPES.TSParameterProperty) {
+      if (parameter.type === import_utils35.AST_NODE_TYPES.TSParameterProperty) {
         if (writtenFieldNames.has(reference.name)) continue;
         fields2 = [reference.name];
       } else if (fields2.length === 0)
@@ -5044,8 +5228,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils34.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils34.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils35.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named3 = namedParameterCollaborator(parameter);
@@ -5055,10 +5239,10 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils34.AST_NODE_TYPES.TSParameterProperty)
+  if (target.type === import_utils35.AST_NODE_TYPES.TSParameterProperty)
     target = target.parameter;
-  if (target.type === import_utils34.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils34.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils35.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(
     target.typeAnnotation?.typeAnnotation,
     declared
@@ -5077,10 +5261,10 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils34.AST_NODE_TYPES.TSParameterProperty)
+  if (target.type === import_utils35.AST_NODE_TYPES.TSParameterProperty)
     target = target.parameter;
-  if (target.type === import_utils34.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils34.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils35.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -5092,12 +5276,12 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils34.AST_NODE_TYPES.Property || property.computed)
+    if (property.type !== import_utils35.AST_NODE_TYPES.Property || property.computed)
       continue;
-    if (property.key.type !== import_utils34.AST_NODE_TYPES.Identifier) continue;
+    if (property.key.type !== import_utils35.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils34.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils34.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils35.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils35.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -5107,22 +5291,22 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils34.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils35.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils34.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils34.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils35.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils35.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body3) => subtreeHas(body3, (node) => {
-  if (node.type === import_utils34.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils35.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils34.AST_NODE_TYPES.Identifier)
+    if (callee.type === import_utils35.AST_NODE_TYPES.Identifier)
       return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils34.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils35.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils35.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils34.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils34.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils35.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils35.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -5142,26 +5326,26 @@ var subtreeHas = (root, found) => {
 };
 var invokedInstanceField = (call) => {
   let callee = unwrapExpression(call.callee);
-  while (callee.type === import_utils34.AST_NODE_TYPES.ChainExpression)
+  while (callee.type === import_utils35.AST_NODE_TYPES.ChainExpression)
     callee = unwrapExpression(callee.expression);
   const direct = instanceField(callee);
   if (direct !== null) return direct;
-  return callee.type === import_utils34.AST_NODE_TYPES.MemberExpression ? instanceField(unwrapExpression(callee.object)) : null;
+  return callee.type === import_utils35.AST_NODE_TYPES.MemberExpression ? instanceField(unwrapExpression(callee.object)) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === import_utils34.AST_NODE_TYPES.ChainExpression || node.type === import_utils34.AST_NODE_TYPES.TSAsExpression || node.type === import_utils34.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils34.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils34.AST_NODE_TYPES.TSTypeAssertion)
+  while (node.type === import_utils35.AST_NODE_TYPES.ChainExpression || node.type === import_utils35.AST_NODE_TYPES.TSAsExpression || node.type === import_utils35.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils35.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils35.AST_NODE_TYPES.TSTypeAssertion)
     node = node.expression;
-  return node.type === import_utils34.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils34.AST_NODE_TYPES.ThisExpression ? staticMemberName(node) : null;
+  return node.type === import_utils35.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils35.AST_NODE_TYPES.ThisExpression ? staticMemberName(node) : null;
 };
 function writtenInstanceField(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.AssignmentExpression || node.type === import_utils34.AST_NODE_TYPES.ForOfStatement || node.type === import_utils34.AST_NODE_TYPES.ForInStatement)
+  if (node.type === import_utils35.AST_NODE_TYPES.AssignmentExpression || node.type === import_utils35.AST_NODE_TYPES.ForOfStatement || node.type === import_utils35.AST_NODE_TYPES.ForInStatement)
     return instanceField(node.left);
-  if (node.type === import_utils34.AST_NODE_TYPES.UpdateExpression)
+  if (node.type === import_utils35.AST_NODE_TYPES.UpdateExpression)
     return instanceField(node.argument);
-  if (node.type === import_utils34.AST_NODE_TYPES.UnaryExpression && node.operator === "delete")
+  if (node.type === import_utils35.AST_NODE_TYPES.UnaryExpression && node.operator === "delete")
     return instanceField(node.argument);
-  if (node.type === import_utils34.AST_NODE_TYPES.MemberExpression && isDestructuredWriteTarget(node))
+  if (node.type === import_utils35.AST_NODE_TYPES.MemberExpression && isDestructuredWriteTarget(node))
     return instanceField(node);
   return null;
 }
@@ -5170,39 +5354,39 @@ function isDestructuredWriteTarget(node) {
   let target = access;
   for (; ; ) {
     const parent = target.parent;
-    if (parent.type === import_utils34.AST_NODE_TYPES.Property && parent.value === target && parent.parent.type === import_utils34.AST_NODE_TYPES.ObjectPattern) {
+    if (parent.type === import_utils35.AST_NODE_TYPES.Property && parent.value === target && parent.parent.type === import_utils35.AST_NODE_TYPES.ObjectPattern) {
       target = parent.parent;
       continue;
     }
-    if (parent.type === import_utils34.AST_NODE_TYPES.ArrayPattern || parent.type === import_utils34.AST_NODE_TYPES.ObjectPattern || parent.type === import_utils34.AST_NODE_TYPES.RestElement && parent.argument === target || parent.type === import_utils34.AST_NODE_TYPES.AssignmentPattern && parent.left === target) {
+    if (parent.type === import_utils35.AST_NODE_TYPES.ArrayPattern || parent.type === import_utils35.AST_NODE_TYPES.ObjectPattern || parent.type === import_utils35.AST_NODE_TYPES.RestElement && parent.argument === target || parent.type === import_utils35.AST_NODE_TYPES.AssignmentPattern && parent.left === target) {
       target = parent;
       continue;
     }
-    return target !== access && (parent.type === import_utils34.AST_NODE_TYPES.AssignmentExpression || parent.type === import_utils34.AST_NODE_TYPES.ForOfStatement || parent.type === import_utils34.AST_NODE_TYPES.ForInStatement) && parent.left === target;
+    return target !== access && (parent.type === import_utils35.AST_NODE_TYPES.AssignmentExpression || parent.type === import_utils35.AST_NODE_TYPES.ForOfStatement || parent.type === import_utils35.AST_NODE_TYPES.ForInStatement) && parent.left === target;
   }
 }
 var behaviorallyInvokedFields = (body3) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils34.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils34.AST_NODE_TYPES.ClassExpression || current.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils34.AST_NODE_TYPES.FunctionExpression)
+    if (current.type === import_utils35.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils35.AST_NODE_TYPES.ClassExpression || current.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils35.AST_NODE_TYPES.FunctionExpression)
       return;
-    if (current.type === import_utils34.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils35.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
     forEachOwnAstChild(current, visit);
   };
   for (const member3 of body3.body) {
-    if (member3.type === import_utils34.AST_NODE_TYPES.StaticBlock || member3.static) continue;
-    if (member3.type === import_utils34.AST_NODE_TYPES.MethodDefinition) {
+    if (member3.type === import_utils35.AST_NODE_TYPES.StaticBlock || member3.static) continue;
+    if (member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition) {
       if (member3.value.body !== null && member3.value.body !== void 0)
         visit(member3.value.body);
       continue;
     }
-    if (member3.type !== import_utils34.AST_NODE_TYPES.PropertyDefinition || member3.value === null)
+    if (member3.type !== import_utils35.AST_NODE_TYPES.PropertyDefinition || member3.value === null)
       continue;
     visit(
-      member3.value.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression ? member3.value.body : member3.value
+      member3.value.type === import_utils35.AST_NODE_TYPES.ArrowFunctionExpression ? member3.value.body : member3.value
     );
   }
   return invoked;
@@ -5222,8 +5406,8 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils34.AST_NODE_TYPES.TSInterfaceDeclaration)
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration)
       names.push(declaration.id.name);
   }
   return names;
@@ -5231,22 +5415,22 @@ var fileInterfaceNames = (program) => {
 var publicMethodNames = (body3, functionAliases) => {
   const names = [];
   function collectPublicCallable(member3) {
-    if (member3.type === import_utils34.AST_NODE_TYPES.PropertyDefinition) {
+    if (member3.type === import_utils35.AST_NODE_TYPES.PropertyDefinition) {
       if (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")
         return;
-      if (member3.key.type === import_utils34.AST_NODE_TYPES.PrivateIdentifier) return;
-      if (member3.value?.type !== import_utils34.AST_NODE_TYPES.ArrowFunctionExpression && member3.value?.type !== import_utils34.AST_NODE_TYPES.FunctionExpression && member3.typeAnnotation?.typeAnnotation.type !== import_utils34.AST_NODE_TYPES.TSFunctionType && !(member3.typeAnnotation?.typeAnnotation.type === import_utils34.AST_NODE_TYPES.TSTypeReference && member3.typeAnnotation.typeAnnotation.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && functionAliases.has(
+      if (member3.key.type === import_utils35.AST_NODE_TYPES.PrivateIdentifier) return;
+      if (member3.value?.type !== import_utils35.AST_NODE_TYPES.ArrowFunctionExpression && member3.value?.type !== import_utils35.AST_NODE_TYPES.FunctionExpression && member3.typeAnnotation?.typeAnnotation.type !== import_utils35.AST_NODE_TYPES.TSFunctionType && !(member3.typeAnnotation?.typeAnnotation.type === import_utils35.AST_NODE_TYPES.TSTypeReference && member3.typeAnnotation.typeAnnotation.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && functionAliases.has(
         member3.typeAnnotation.typeAnnotation.typeName.name
       )))
         return;
       names.push(declaredMemberName(member3) ?? "\u2026");
       return;
     }
-    if (member3.type !== import_utils34.AST_NODE_TYPES.MethodDefinition) return;
+    if (member3.type !== import_utils35.AST_NODE_TYPES.MethodDefinition) return;
     if (member3.kind !== "method" || member3.static) return;
     if (member3.accessibility === "private" || member3.accessibility === "protected")
       return;
-    if (member3.key.type === import_utils34.AST_NODE_TYPES.PrivateIdentifier) return;
+    if (member3.key.type === import_utils35.AST_NODE_TYPES.PrivateIdentifier) return;
     names.push(declaredMemberName(member3) ?? "\u2026");
   }
   for (const member3 of body3.body) {
@@ -5257,13 +5441,13 @@ var publicMethodNames = (body3, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member3) => member3.type === import_utils34.AST_NODE_TYPES.MethodDefinition && member3.kind === "method" && !member3.static && member3.accessibility !== "private" && member3.accessibility !== "protected" && member3.value.body !== null
+    (member3) => member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "method" && !member3.static && member3.accessibility !== "private" && member3.accessibility !== "protected" && member3.value.body !== null
   );
   if (methods.length === 0) return false;
   return methods.every((member3) => {
     const result = member3.value.returnType?.typeAnnotation;
     if (result === void 0) return false;
-    const returnsOwnType = result.type === import_utils34.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils35.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -5271,10 +5455,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils34.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils35.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils34.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils35.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -5292,9 +5476,9 @@ function localClassAbstractness(program) {
   return classes;
 }
 function declaredMemberName(member3) {
-  if (!member3.computed && member3.key.type === import_utils34.AST_NODE_TYPES.Identifier)
+  if (!member3.computed && member3.key.type === import_utils35.AST_NODE_TYPES.Identifier)
     return member3.key.name;
-  if (member3.key.type === import_utils34.AST_NODE_TYPES.Literal && typeof member3.key.value === "string")
+  if (member3.key.type === import_utils35.AST_NODE_TYPES.Literal && typeof member3.key.value === "string")
     return member3.key.value;
   return null;
 }
@@ -5303,35 +5487,35 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = localFunctionAliases(program);
   function collectInterfaceSurface(statement) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils34.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils34.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils35.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === import_utils34.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils34.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils35.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils35.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type === import_utils34.AST_NODE_TYPES.TSTypeReference) {
+        if (part.type === import_utils35.AST_NODE_TYPES.TSTypeReference) {
           inherited.push("*");
           continue;
         }
-        if (part.type !== import_utils34.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils35.AST_NODE_TYPES.TSTypeLiteral) continue;
         addCallableMembers(part.members, callables2);
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       return;
     }
-    if (declaration?.type !== import_utils34.AST_NODE_TYPES.TSInterfaceDeclaration) return;
+    if (declaration?.type !== import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration) return;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     addCallableMembers(declaration.body.body, callables);
     interfaces.set(declaration.id.name, callables);
     parents.set(declaration.id.name, [
       ...parents.get(declaration.id.name) ?? [],
       ...declaration.extends.flatMap(
-        (heritage) => heritage.expression.type === import_utils34.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+        (heritage) => heritage.expression.type === import_utils35.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
       )
     ]);
   }
@@ -5340,17 +5524,17 @@ function localInterfaceSurfaces(program) {
   }
   function addCallableMembers(members, callables) {
     for (const member3 of members) {
-      if (member3.type !== import_utils34.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils34.AST_NODE_TYPES.TSPropertySignature)
+      if (member3.type !== import_utils35.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils35.AST_NODE_TYPES.TSPropertySignature)
         continue;
       const name = declaredMemberName(member3);
       if (name === null) continue;
-      if (member3.type === import_utils34.AST_NODE_TYPES.TSMethodSignature) {
+      if (member3.type === import_utils35.AST_NODE_TYPES.TSMethodSignature) {
         callables.add(name);
         continue;
       }
-      if (member3.type !== import_utils34.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member3.type !== import_utils35.AST_NODE_TYPES.TSPropertySignature) continue;
       const annotation = member3.typeAnnotation?.typeAnnotation;
-      if (annotation?.type === import_utils34.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils34.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name))
+      if (annotation?.type === import_utils35.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils35.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name))
         callables.add(name);
     }
   }
@@ -5380,7 +5564,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils34.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils35.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -5419,7 +5603,7 @@ var require_port_for_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member3) => member3.type === import_utils34.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null && member3.value.body !== void 0
+          (member3) => member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null && member3.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -5469,7 +5653,7 @@ var require_port_for_service_default = createRule({
 function implementedSurfaceCovers(node, methods, classes, interfaces) {
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== import_utils34.AST_NODE_TYPES.Identifier)
+    if (implementation.expression.type !== import_utils35.AST_NODE_TYPES.Identifier)
       return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
@@ -5486,7 +5670,7 @@ function createServiceOperationResolver(program) {
   let declaredTypes = null;
   return (node) => {
     const ctor = node.body.body.find(
-      (member3) => member3.type === import_utils34.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null
+      (member3) => member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null
     );
     if (ctor === void 0) return [];
     const declared = () => declaredTypes ??= fileTypeIndex(program);
@@ -5504,7 +5688,7 @@ function createServiceOperationResolver(program) {
     for (const [name, body3] of serviceOperationBodies(node)) {
       forEachServiceCall(body3, (call) => {
         if (retained.has(invokedInstanceField(call) ?? "")) active.add(name);
-        if (call.callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && call.callee.object.type === import_utils34.AST_NODE_TYPES.ThisExpression) {
+        if (call.callee.type === import_utils35.AST_NODE_TYPES.MemberExpression && call.callee.object.type === import_utils35.AST_NODE_TYPES.ThisExpression) {
           const callee = staticMemberName(call.callee);
           if (callee !== null) {
             const linked = callers.get(callee) ?? /* @__PURE__ */ new Set();
@@ -5543,11 +5727,11 @@ function serviceOperationBodies(node) {
     });
   }
   for (const member3 of node.body.body) {
-    if (member3.type !== import_utils34.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils34.AST_NODE_TYPES.PropertyDefinition)
+    if (member3.type !== import_utils35.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils35.AST_NODE_TYPES.PropertyDefinition)
       continue;
-    if (member3.static || member3.decorators.length > 0 || member3.type === import_utils34.AST_NODE_TYPES.MethodDefinition && member3.kind !== "method")
+    if (member3.static || member3.decorators.length > 0 || member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind !== "method")
       continue;
-    if (member3.value?.type !== import_utils34.AST_NODE_TYPES.FunctionExpression && member3.value?.type !== import_utils34.AST_NODE_TYPES.ArrowFunctionExpression)
+    if (member3.value?.type !== import_utils35.AST_NODE_TYPES.FunctionExpression && member3.value?.type !== import_utils35.AST_NODE_TYPES.ArrowFunctionExpression)
       continue;
     const name = declaredMemberName(member3);
     if (name !== null && !written.has(name) && member3.value.body !== null)
@@ -5556,9 +5740,9 @@ function serviceOperationBodies(node) {
   return bodies;
 }
 function forEachServiceCall(node, onCall) {
-  if (node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils34.AST_NODE_TYPES.FunctionExpression || node.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils34.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils34.AST_NODE_TYPES.ClassExpression)
+  if (node.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils35.AST_NODE_TYPES.FunctionExpression || node.type === import_utils35.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils35.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils35.AST_NODE_TYPES.ClassExpression)
     return;
-  if (node.type === import_utils34.AST_NODE_TYPES.BlockStatement) {
+  if (node.type === import_utils35.AST_NODE_TYPES.BlockStatement) {
     for (const statement of node.body) {
       forEachServiceCall(statement, onCall);
       if (terminatesOperation(statement)) break;
@@ -5570,29 +5754,29 @@ function forEachServiceCall(node, onCall) {
     forEachServiceCall(branch, onCall);
     return;
   }
-  if (node.type === import_utils34.AST_NODE_TYPES.CallExpression) onCall(node);
+  if (node.type === import_utils35.AST_NODE_TYPES.CallExpression) onCall(node);
   forEachOwnAstChild(node, (child) => {
     forEachServiceCall(child, onCall);
   });
 }
 function literalExecutionBranch(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.WhileStatement && node.test.type === import_utils34.AST_NODE_TYPES.Literal && node.test.value === false)
+  if (node.type === import_utils35.AST_NODE_TYPES.WhileStatement && node.test.type === import_utils35.AST_NODE_TYPES.Literal && node.test.value === false)
     return node.test;
-  if ((node.type === import_utils34.AST_NODE_TYPES.IfStatement || node.type === import_utils34.AST_NODE_TYPES.ConditionalExpression) && node.test.type === import_utils34.AST_NODE_TYPES.Literal && typeof node.test.value === "boolean") {
+  if ((node.type === import_utils35.AST_NODE_TYPES.IfStatement || node.type === import_utils35.AST_NODE_TYPES.ConditionalExpression) && node.test.type === import_utils35.AST_NODE_TYPES.Literal && typeof node.test.value === "boolean") {
     return node.test.value ? node.consequent : node.alternate ?? node.test;
   }
-  if (node.type !== import_utils34.AST_NODE_TYPES.LogicalExpression || node.left.type !== import_utils34.AST_NODE_TYPES.Literal || typeof node.left.value !== "boolean")
+  if (node.type !== import_utils35.AST_NODE_TYPES.LogicalExpression || node.left.type !== import_utils35.AST_NODE_TYPES.Literal || typeof node.left.value !== "boolean")
     return null;
   if (node.operator === "&&") return node.left.value ? node.right : node.left;
   if (node.operator === "||") return node.left.value ? node.left : node.right;
   return node.left;
 }
 function terminatesOperation(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.ReturnStatement || node.type === import_utils34.AST_NODE_TYPES.ThrowStatement)
+  if (node.type === import_utils35.AST_NODE_TYPES.ReturnStatement || node.type === import_utils35.AST_NODE_TYPES.ThrowStatement)
     return true;
-  if (node.type === import_utils34.AST_NODE_TYPES.BlockStatement)
+  if (node.type === import_utils35.AST_NODE_TYPES.BlockStatement)
     return node.body.some(terminatesOperation);
-  if (node.type !== import_utils34.AST_NODE_TYPES.IfStatement) return false;
+  if (node.type !== import_utils35.AST_NODE_TYPES.IfStatement) return false;
   const branch = literalExecutionBranch(node);
   if (branch !== null) return terminatesOperation(branch);
   return node.alternate !== null && terminatesOperation(node.consequent) && terminatesOperation(node.alternate);
@@ -5606,7 +5790,7 @@ function hasDeclaredServiceContract(node, operations, program) {
   const seen = /* @__PURE__ */ new Set();
   function addImplementedContracts(current) {
     for (const implementation of current.implements) {
-      if (implementation.expression.type !== import_utils34.AST_NODE_TYPES.Identifier)
+      if (implementation.expression.type !== import_utils35.AST_NODE_TYPES.Identifier)
         return false;
       const name = implementation.expression.name;
       const surface = interfaces.get(name);
@@ -5629,7 +5813,7 @@ function hasDeclaredServiceContract(node, operations, program) {
     }
     if (!addImplementedContracts(current)) return null;
     if (current.superClass === null) continue;
-    if (current.superClass.type !== import_utils34.AST_NODE_TYPES.Identifier) return null;
+    if (current.superClass.type !== import_utils35.AST_NODE_TYPES.Identifier) return null;
     const base = classes.get(current.superClass.name);
     if (base === void 0) return null;
     pending.push(base);
@@ -5639,8 +5823,8 @@ function hasDeclaredServiceContract(node, operations, program) {
 function localClassDeclarations(program) {
   const classes = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils34.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null)
+    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils35.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null)
       classes.set(declaration.id.name, declaration);
   }
   return classes;
@@ -5648,13 +5832,13 @@ function localClassDeclarations(program) {
 function abstractContractOperations(node, functionAliases) {
   const methods = new Set(publicMethodNames(node.body, functionAliases));
   for (const member3 of node.body.body) {
-    if (member3.type !== import_utils34.AST_NODE_TYPES.TSAbstractMethodDefinition && member3.type !== import_utils34.AST_NODE_TYPES.TSAbstractPropertyDefinition)
+    if (member3.type !== import_utils35.AST_NODE_TYPES.TSAbstractMethodDefinition && member3.type !== import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition)
       continue;
     if (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")
       continue;
-    if (member3.type === import_utils34.AST_NODE_TYPES.TSAbstractPropertyDefinition) {
+    if (member3.type === import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition) {
       const annotation = member3.typeAnnotation?.typeAnnotation;
-      if (annotation?.type !== import_utils34.AST_NODE_TYPES.TSFunctionType && !(annotation?.type === import_utils34.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)))
+      if (annotation?.type !== import_utils35.AST_NODE_TYPES.TSFunctionType && !(annotation?.type === import_utils35.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)))
         continue;
     }
     const name = declaredMemberName(member3);
@@ -5790,7 +5974,7 @@ function isServiceRole(name, filename) {
 }
 
 // src/rules/no-conditional-empty-object-spread.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var NO_CONDITIONAL_EMPTY_OBJECT_SPREAD_DOCUMENTATION = {
   summary: "Build conditional properties explicitly instead of spreading an empty-object branch.",
   rationale: "An empty-object conditional spread hides whether a property is omitted, which differs from assigning undefined.",
@@ -5842,7 +6026,7 @@ var NO_CONDITIONAL_EMPTY_OBJECT_SPREAD_DOCUMENTATION = {
   ]
 };
 function isEmptyObject(node) {
-  return node.type === import_utils36.AST_NODE_TYPES.ObjectExpression && node.properties.length === 0;
+  return node.type === import_utils37.AST_NODE_TYPES.ObjectExpression && node.properties.length === 0;
 }
 var no_conditional_empty_object_spread_default = createRule({
   name: "no-conditional-empty-object-spread",
@@ -5863,13 +6047,13 @@ var no_conditional_empty_object_spread_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     return {
       SpreadElement(node) {
-        if (node.parent.type !== import_utils36.AST_NODE_TYPES.ObjectExpression || node.argument.type !== import_utils36.AST_NODE_TYPES.ConditionalExpression)
+        if (node.parent.type !== import_utils37.AST_NODE_TYPES.ObjectExpression || node.argument.type !== import_utils37.AST_NODE_TYPES.ConditionalExpression)
           return;
         if (isEmptyObject(node.argument.consequent) || isEmptyObject(node.argument.alternate)) {
           const conditional = node.argument;
           const emptyConsequent = isEmptyObject(conditional.consequent);
           const populated = emptyConsequent ? conditional.alternate : conditional.consequent;
-          const canFix = populated.type === import_utils36.AST_NODE_TYPES.ObjectExpression && populated.properties.length > 0 && context.sourceCode.getCommentsInside(conditional).length === 0;
+          const canFix = populated.type === import_utils37.AST_NODE_TYPES.ObjectExpression && populated.properties.length > 0 && context.sourceCode.getCommentsInside(conditional).length === 0;
           context.report({
             node,
             messageId: "avoid",
@@ -5885,7 +6069,7 @@ var no_conditional_empty_object_spread_default = createRule({
 });
 
 // src/rules/prefer-typed-reflection.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 var import_typescript12 = __toESM(require("typescript"), 1);
 var PREFER_TYPED_REFLECTION_DOCUMENTATION = {
   summary: "Prefer typed access when Reflect.get or Reflect.apply discards a known contract.",
@@ -5958,20 +6142,20 @@ var prefer_typed_reflection_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap)
       return {};
-    const services = import_utils37.ESLintUtils.getParserServices(context);
+    const services = import_utils38.ESLintUtils.getParserServices(context);
     if (!services.program) return {};
     const checker = services.program.getTypeChecker();
-    const isReflect = (node) => globalName(node, "Reflect") || node.type === import_utils37.AST_NODE_TYPES.MemberExpression && import_utils37.ASTUtils.getPropertyName(node) === "Reflect" && globalName(node.object, "globalThis");
-    const globalName = (node, name) => node.type === import_utils37.AST_NODE_TYPES.Identifier && node.name === name && !import_utils37.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
+    const isReflect = (node) => globalName(node, "Reflect") || node.type === import_utils38.AST_NODE_TYPES.MemberExpression && import_utils38.ASTUtils.getPropertyName(node) === "Reflect" && globalName(node.object, "globalThis");
+    const globalName = (node, name) => node.type === import_utils38.AST_NODE_TYPES.Identifier && node.name === name && !import_utils38.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
     const closedObject = (type) => {
       if (type.isUnion()) return type.types.every(closedObject);
       return knownType(type) && type.getProperties().length > 0 && checker.getIndexInfosOfType(type).length === 0;
     };
     const inspectGet = (node, type) => {
       const key = node.arguments[1] === void 0 ? void 0 : unwrapExpression(node.arguments[1]);
-      return node.arguments.length === 2 && (staticString(key) !== null || key?.type === import_utils37.AST_NODE_TYPES.Literal && typeof key.value === "number") && closedObject(type);
+      return node.arguments.length === 2 && (staticString(key) !== null || key?.type === import_utils38.AST_NODE_TYPES.Literal && typeof key.value === "number") && closedObject(type);
     };
-    const inspectApply = (node, type) => node.arguments.length === 3 && node.arguments[2]?.type === import_utils37.AST_NODE_TYPES.ArrayExpression && knownType(type) && type.getCallSignatures().some(
+    const inspectApply = (node, type) => node.arguments.length === 3 && node.arguments[2]?.type === import_utils38.AST_NODE_TYPES.ArrayExpression && knownType(type) && type.getCallSignatures().some(
       (signature) => signature.typeParameters === void 0 && signature.parameters.every(
         (parameter) => knownType(
           checker.getTypeOfSymbolAtLocation(
@@ -5982,25 +6166,25 @@ var prefer_typed_reflection_default = createRule({
       )
     );
     const getReplacement = (node, type, target) => {
-      if (node.optional || node.callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || node.callee.optional || context.sourceCode.getCommentsInside(node).length > 0) return null;
+      if (node.optional || node.callee.type !== import_utils38.AST_NODE_TYPES.MemberExpression || node.callee.optional || context.sourceCode.getCommentsInside(node).length > 0) return null;
       let outer = node;
-      while (outer.parent.type === import_utils37.AST_NODE_TYPES.TSAsExpression || outer.parent.type === import_utils37.AST_NODE_TYPES.TSTypeAssertion || outer.parent.type === import_utils37.AST_NODE_TYPES.TSSatisfiesExpression || outer.parent.type === import_utils37.AST_NODE_TYPES.TSNonNullExpression || outer.parent.type === import_utils37.AST_NODE_TYPES.ChainExpression) outer = outer.parent;
-      if (outer.parent.type === import_utils37.AST_NODE_TYPES.UnaryExpression && outer.parent.operator === "delete" || outer.parent.type === import_utils37.AST_NODE_TYPES.CallExpression && outer.parent.callee === outer || outer.parent.type === import_utils37.AST_NODE_TYPES.TaggedTemplateExpression && outer.parent.tag === outer) return null;
+      while (outer.parent.type === import_utils38.AST_NODE_TYPES.TSAsExpression || outer.parent.type === import_utils38.AST_NODE_TYPES.TSTypeAssertion || outer.parent.type === import_utils38.AST_NODE_TYPES.TSSatisfiesExpression || outer.parent.type === import_utils38.AST_NODE_TYPES.TSNonNullExpression || outer.parent.type === import_utils38.AST_NODE_TYPES.ChainExpression) outer = outer.parent;
+      if (outer.parent.type === import_utils38.AST_NODE_TYPES.UnaryExpression && outer.parent.operator === "delete" || outer.parent.type === import_utils38.AST_NODE_TYPES.CallExpression && outer.parent.callee === outer || outer.parent.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression && outer.parent.tag === outer) return null;
       const writtenKey = node.arguments[1];
-      if (writtenKey === void 0 || writtenKey.type === import_utils37.AST_NODE_TYPES.SpreadElement) return null;
+      if (writtenKey === void 0 || writtenKey.type === import_utils38.AST_NODE_TYPES.SpreadElement) return null;
       const key = unwrapExpression(writtenKey);
-      const name = staticString(key) ?? (key.type === import_utils37.AST_NODE_TYPES.Literal && typeof key.value === "number" ? String(key.value) : null);
+      const name = staticString(key) ?? (key.type === import_utils38.AST_NODE_TYPES.Literal && typeof key.value === "number" ? String(key.value) : null);
       const members = type.isUnion() ? type.types : [type];
       if (name === null || !members.every((member3) => (member3.flags & import_typescript12.default.TypeFlags.Object) !== 0 && checker.getPropertyOfType(member3, name) !== void 0)) return null;
       return `(${context.sourceCode.getText(target)})[${context.sourceCode.getText(writtenKey)}]`;
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || !isReflect(node.callee.object))
+        if (node.callee.type !== import_utils38.AST_NODE_TYPES.MemberExpression || !isReflect(node.callee.object))
           return;
-        const method = import_utils37.ASTUtils.getPropertyName(node.callee);
+        const method = import_utils38.ASTUtils.getPropertyName(node.callee);
         const target = node.arguments[0];
-        if (!target || target.type === import_utils37.AST_NODE_TYPES.SpreadElement || method !== "get" && method !== "apply")
+        if (!target || target.type === import_utils38.AST_NODE_TYPES.SpreadElement || method !== "get" && method !== "apply")
           return;
         const type = checker.getTypeAtLocation(
           services.esTreeNodeToTSNodeMap.get(target)
@@ -6015,28 +6199,28 @@ var prefer_typed_reflection_default = createRule({
 });
 
 // src/rules/no-broad-return-type.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils40 = require("@typescript-eslint/utils");
 var import_typescript13 = __toESM(require("typescript"), 1);
 
 // src/rules/_unused-private-binding.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 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_utils38.AST_NODE_TYPES.VariableDeclarator ? declaration.parent : declaration;
-  if (statement.parent.type === import_utils38.AST_NODE_TYPES.ExportNamedDeclaration || statement.parent.type === import_utils38.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
-  if (statement.parent.type !== import_utils38.AST_NODE_TYPES.Program) return statement.parent.type === import_utils38.AST_NODE_TYPES.BlockStatement;
-  return sourceCode.ast.body.some((node) => node.type === import_utils38.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils38.AST_NODE_TYPES.ExportNamedDeclaration || node.type === import_utils38.AST_NODE_TYPES.ExportDefaultDeclaration || node.type === import_utils38.AST_NODE_TYPES.ExportAllDeclaration);
+  const statement = declaration.type === import_utils39.AST_NODE_TYPES.VariableDeclarator ? declaration.parent : declaration;
+  if (statement.parent.type === import_utils39.AST_NODE_TYPES.ExportNamedDeclaration || statement.parent.type === import_utils39.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  if (statement.parent.type !== import_utils39.AST_NODE_TYPES.Program) return statement.parent.type === import_utils39.AST_NODE_TYPES.BlockStatement;
+  return sourceCode.ast.body.some((node) => node.type === import_utils39.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils39.AST_NODE_TYPES.ExportNamedDeclaration || node.type === import_utils39.AST_NODE_TYPES.ExportDefaultDeclaration || node.type === import_utils39.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_utils38.AST_NODE_TYPES.CallExpression && parent.callee === identifier) return true;
-    return parent.type === import_utils38.AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.parent.type === import_utils38.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
+    if (parent.type === import_utils39.AST_NODE_TYPES.CallExpression && parent.callee === identifier) return true;
+    return parent.type === import_utils39.AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.parent.type === import_utils39.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
   });
 }
 var IDENTIFIER_NAMES = /* @__PURE__ */ new WeakMap();
@@ -6050,7 +6234,7 @@ function hasIdentifierNamed(node, name) {
       const current = pending.pop();
       if (current === void 0 || seen.has(current)) continue;
       seen.add(current);
-      if (current.type === import_utils38.AST_NODE_TYPES.Identifier || current.type === import_utils38.AST_NODE_TYPES.JSXIdentifier) collected.add(current.name);
+      if (current.type === import_utils39.AST_NODE_TYPES.Identifier || current.type === import_utils39.AST_NODE_TYPES.JSXIdentifier) collected.add(current.name);
       forEachOwnAstChild(current, (child) => {
         pending.push(child);
       }, (key) => key !== "tokens" && key !== "comments");
@@ -6061,7 +6245,7 @@ function hasIdentifierNamed(node, name) {
   return names.has(name);
 }
 function privatePredicateBooleanFix(sourceCode, node, annotation, filename) {
-  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_utils38.AST_NODE_TYPES.FunctionDeclaration || node.id === null || !isUnusedPrivateBinding(sourceCode, node, node.id, filename) || sourceCode.getCommentsInside(annotation).length > 0) return null;
+  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_utils39.AST_NODE_TYPES.FunctionDeclaration || node.id === null || !isUnusedPrivateBinding(sourceCode, node, node.id, filename) || sourceCode.getCommentsInside(annotation).length > 0) return null;
   return (fixer) => fixer.replaceText(annotation, `boolean${sourceCode.getText(annotation).replace(/[^\r\n]/gu, "")}`);
 }
 
@@ -6150,7 +6334,7 @@ var no_broad_return_type_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap)
       return {};
-    const services = import_utils39.ESLintUtils.getParserServices(context);
+    const services = import_utils40.ESLintUtils.getParserServices(context);
     if (!services.program) return {};
     const checker = services.program.getTypeChecker();
     const frames = [];
@@ -6175,7 +6359,7 @@ var no_broad_return_type_default = createRule({
         known: false,
         opaque: false
       });
-      if (node.body && node.body.type !== import_utils39.AST_NODE_TYPES.BlockStatement)
+      if (node.body && node.body.type !== import_utils40.AST_NODE_TYPES.BlockStatement)
         inspectReturn(node.body);
     };
     const leave = () => {
@@ -6183,7 +6367,7 @@ var no_broad_return_type_default = createRule({
       if (frame?.annotation && frame.known && !frame.opaque) {
         const annotation = frame.annotation;
         const node = frame.node;
-        const canFix = node.type === import_utils39.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && isUnusedPrivateBinding(context.sourceCode, node, node.id, context.filename) && context.sourceCode.getCommentsInside(annotation).length === 0 && retainsNamedTypeUses(context.sourceCode, annotation);
+        const canFix = node.type === import_utils40.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && isUnusedPrivateBinding(context.sourceCode, node, node.id, context.filename) && context.sourceCode.getCommentsInside(annotation).length === 0 && retainsNamedTypeUses(context.sourceCode, annotation);
         context.report({ node: annotation, messageId: "avoid", fix: canFix ? (fixer) => fixer.replaceText(annotation, context.sourceCode.getText(annotation).replace(/[^\r\n]/gu, "")) : null });
       }
     };
@@ -6202,43 +6386,43 @@ var no_broad_return_type_default = createRule({
 });
 
 // src/rules/no-reduce-accumulator-copy.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 var import_typescript14 = __toESM(require("typescript"), 1);
 
 // src/rules/_literal-identity-reduce-fix.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 function literalIdentityReduceFix(sourceCode, node) {
-  if (sourceCode.ast.body.length !== 1 || sourceCode.getAllComments().length > 0 || node.optional || node.arguments.length !== 2 || node.callee.type !== import_utils40.AST_NODE_TYPES.MemberExpression || node.callee.optional || import_utils40.ASTUtils.getPropertyName(node.callee) !== "reduce")
+  if (sourceCode.ast.body.length !== 1 || sourceCode.getAllComments().length > 0 || node.optional || node.arguments.length !== 2 || node.callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || node.callee.optional || import_utils41.ASTUtils.getPropertyName(node.callee) !== "reduce")
     return null;
   const values = node.callee.object;
-  if (values.type !== import_utils40.AST_NODE_TYPES.ArrayExpression || values.elements.length === 0 || !values.elements.every(
-    (element) => element?.type === import_utils40.AST_NODE_TYPES.Literal && typeof element.value === "string"
+  if (values.type !== import_utils41.AST_NODE_TYPES.ArrayExpression || values.elements.length === 0 || !values.elements.every(
+    (element) => element?.type === import_utils41.AST_NODE_TYPES.Literal && typeof element.value === "string"
   ))
     return null;
   const statement = sourceCode.ast.body[0];
-  if (statement?.type !== import_utils40.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration?.type !== import_utils40.AST_NODE_TYPES.FunctionDeclaration)
+  if (statement?.type !== import_utils41.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration?.type !== import_utils41.AST_NODE_TYPES.FunctionDeclaration)
     return null;
   const owner = statement.declaration;
   if (owner.async || owner.declare || owner.generator || owner.typeParameters !== void 0 || owner.params.length !== 0 || owner.body.body.length !== 1 || !stringArray(owner.returnType?.typeAnnotation))
     return null;
   const returned2 = owner.body.body[0];
-  if (returned2?.type !== import_utils40.AST_NODE_TYPES.ReturnStatement || returned2.argument !== node || node.typeArguments?.params.length !== 1 || !stringArray(node.typeArguments.params[0]))
+  if (returned2?.type !== import_utils41.AST_NODE_TYPES.ReturnStatement || returned2.argument !== node || node.typeArguments?.params.length !== 1 || !stringArray(node.typeArguments.params[0]))
     return null;
   const [callback, seed] = node.arguments;
-  if (seed?.type !== import_utils40.AST_NODE_TYPES.ArrayExpression || seed.elements.length !== 0 || callback?.type !== import_utils40.AST_NODE_TYPES.ArrowFunctionExpression || callback.async || callback.typeParameters !== void 0 || callback.returnType !== void 0 || callback.params.length !== 2 || callback.body.type !== import_utils40.AST_NODE_TYPES.ArrayExpression || callback.body.elements.length !== 2)
+  if (seed?.type !== import_utils41.AST_NODE_TYPES.ArrayExpression || seed.elements.length !== 0 || callback?.type !== import_utils41.AST_NODE_TYPES.ArrowFunctionExpression || callback.async || callback.typeParameters !== void 0 || callback.returnType !== void 0 || callback.params.length !== 2 || callback.body.type !== import_utils41.AST_NODE_TYPES.ArrayExpression || callback.body.elements.length !== 2)
     return null;
   if (!identitySpread(sourceCode, callback)) return null;
   return (fixer) => fixer.replaceText(node, sourceCode.getText(values));
 }
 function stringArray(node) {
-  return node?.type === import_utils40.AST_NODE_TYPES.TSArrayType && node.elementType.type === import_utils40.AST_NODE_TYPES.TSStringKeyword;
+  return node?.type === import_utils41.AST_NODE_TYPES.TSArrayType && node.elementType.type === import_utils41.AST_NODE_TYPES.TSStringKeyword;
 }
 function identitySpread(sourceCode, callback) {
   const [accumulator, item] = callback.params;
-  if (accumulator?.type !== import_utils40.AST_NODE_TYPES.Identifier || item?.type !== import_utils40.AST_NODE_TYPES.Identifier || accumulator.name === item.name || accumulator.optional || item.optional || accumulator.typeAnnotation !== void 0 || item.typeAnnotation !== void 0 || callback.body.type !== import_utils40.AST_NODE_TYPES.ArrayExpression)
+  if (accumulator?.type !== import_utils41.AST_NODE_TYPES.Identifier || item?.type !== import_utils41.AST_NODE_TYPES.Identifier || accumulator.name === item.name || accumulator.optional || item.optional || accumulator.typeAnnotation !== void 0 || item.typeAnnotation !== void 0 || callback.body.type !== import_utils41.AST_NODE_TYPES.ArrayExpression)
     return false;
   const [spread, appended] = callback.body.elements;
-  if (spread?.type !== import_utils40.AST_NODE_TYPES.SpreadElement || spread.argument.type !== import_utils40.AST_NODE_TYPES.Identifier || appended?.type !== import_utils40.AST_NODE_TYPES.Identifier || spread.argument.name !== accumulator.name || appended.name !== item.name)
+  if (spread?.type !== import_utils41.AST_NODE_TYPES.SpreadElement || spread.argument.type !== import_utils41.AST_NODE_TYPES.Identifier || appended?.type !== import_utils41.AST_NODE_TYPES.Identifier || spread.argument.name !== accumulator.name || appended.name !== item.name)
     return false;
   const bindings = sourceCode.getDeclaredVariables(callback);
   const left = bindings.find(
@@ -6247,10 +6431,10 @@ function identitySpread(sourceCode, callback) {
   const right = bindings.find(
     (variable) => variable.identifiers.includes(item)
   );
-  return left !== void 0 && right !== void 0 && import_utils40.ASTUtils.findVariable(
+  return left !== void 0 && right !== void 0 && import_utils41.ASTUtils.findVariable(
     sourceCode.getScope(spread.argument),
     spread.argument.name
-  ) === left && import_utils40.ASTUtils.findVariable(sourceCode.getScope(appended), appended.name) === right;
+  ) === left && import_utils41.ASTUtils.findVariable(sourceCode.getScope(appended), appended.name) === right;
 }
 
 // src/rules/no-reduce-accumulator-copy.ts
@@ -6340,25 +6524,25 @@ var no_reduce_accumulator_copy_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap)
       return {};
-    const services = import_utils41.ESLintUtils.getParserServices(context);
+    const services = import_utils42.ESLintUtils.getParserServices(context);
     const program = services.program;
     if (program === null) return {};
     const checker = program.getTypeChecker();
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || !["reduce", "reduceRight"].includes(
-          import_utils41.ASTUtils.getPropertyName(node.callee) ?? ""
+        if (node.callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || !["reduce", "reduceRight"].includes(
+          import_utils42.ASTUtils.getPropertyName(node.callee) ?? ""
         ) || node.arguments.length !== 2)
           return;
         const seed = node.arguments[1];
-        const arraySeed = seed?.type === import_utils41.AST_NODE_TYPES.ArrayExpression && seed.elements.length === 0;
-        const objectSeed = seed?.type === import_utils41.AST_NODE_TYPES.ObjectExpression && seed.properties.length === 0;
+        const arraySeed = seed?.type === import_utils42.AST_NODE_TYPES.ArrayExpression && seed.elements.length === 0;
+        const objectSeed = seed?.type === import_utils42.AST_NODE_TYPES.ObjectExpression && seed.properties.length === 0;
         if (!arraySeed && !objectSeed) return;
         const callback = node.arguments[0];
-        if (!callback || callback.type !== import_utils41.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils41.AST_NODE_TYPES.FunctionExpression)
+        if (!callback || callback.type !== import_utils42.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils42.AST_NODE_TYPES.FunctionExpression)
           return;
         const parameter = callback.params[0];
-        if (parameter?.type !== import_utils41.AST_NODE_TYPES.Identifier) return;
+        if (parameter?.type !== import_utils42.AST_NODE_TYPES.Identifier) return;
         const signature = checker.getResolvedSignature(
           services.esTreeNodeToTSNodeMap.get(node)
         );
@@ -6369,51 +6553,51 @@ var no_reduce_accumulator_copy_default = createRule({
         if (!accumulator || accumulator.references.some((reference) => reference.isWrite()))
           return;
         const fix = literalIdentityReduceFix(context.sourceCode, node);
-        const referencesAccumulator = (value) => value.type === import_utils41.AST_NODE_TYPES.Identifier && import_utils41.ASTUtils.findVariable(
+        const referencesAccumulator = (value) => value.type === import_utils42.AST_NODE_TYPES.Identifier && import_utils42.ASTUtils.findVariable(
           context.sourceCode.getScope(value),
           value.name
         ) === accumulator;
         const inspect = (current) => {
           if (current !== callback.body && [
-            import_utils41.AST_NODE_TYPES.ArrowFunctionExpression,
-            import_utils41.AST_NODE_TYPES.FunctionExpression,
-            import_utils41.AST_NODE_TYPES.FunctionDeclaration,
-            import_utils41.AST_NODE_TYPES.ClassDeclaration,
-            import_utils41.AST_NODE_TYPES.ClassExpression,
-            import_utils41.AST_NODE_TYPES.ForStatement,
-            import_utils41.AST_NODE_TYPES.ForInStatement,
-            import_utils41.AST_NODE_TYPES.ForOfStatement,
-            import_utils41.AST_NODE_TYPES.WhileStatement,
-            import_utils41.AST_NODE_TYPES.DoWhileStatement
+            import_utils42.AST_NODE_TYPES.ArrowFunctionExpression,
+            import_utils42.AST_NODE_TYPES.FunctionExpression,
+            import_utils42.AST_NODE_TYPES.FunctionDeclaration,
+            import_utils42.AST_NODE_TYPES.ClassDeclaration,
+            import_utils42.AST_NODE_TYPES.ClassExpression,
+            import_utils42.AST_NODE_TYPES.ForStatement,
+            import_utils42.AST_NODE_TYPES.ForInStatement,
+            import_utils42.AST_NODE_TYPES.ForOfStatement,
+            import_utils42.AST_NODE_TYPES.WhileStatement,
+            import_utils42.AST_NODE_TYPES.DoWhileStatement
           ].some((kind) => kind === current.type))
             return;
-          if (current.type === import_utils41.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils41.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils41.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
+          if (current.type === import_utils42.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils42.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils42.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
             context.report({
               node: current,
               messageId: "copy",
               fix
             });
           }
-          if (current.type === import_utils41.AST_NODE_TYPES.CallExpression)
+          if (current.type === import_utils42.AST_NODE_TYPES.CallExpression)
             inspectCall(current);
           forEachAstChild(current, context.sourceCode.visitorKeys, inspect);
         };
         const inspectCall = (current) => {
-          if (current.callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression) return;
+          if (current.callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression) return;
           const member3 = current.callee;
-          const name = import_utils41.ASTUtils.getPropertyName(member3);
+          const name = import_utils42.ASTUtils.getPropertyName(member3);
           const directCopy = arraySeed && name !== null && COPY_METHODS.has(name) && referencesAccumulator(member3.object);
-          const globalArray = member3.object.type === import_utils41.AST_NODE_TYPES.Identifier && member3.object.name === "Array" && !import_utils41.ASTUtils.findVariable(
+          const globalArray = member3.object.type === import_utils42.AST_NODE_TYPES.Identifier && member3.object.name === "Array" && !import_utils42.ASTUtils.findVariable(
             context.sourceCode.getScope(member3.object),
             "Array"
           )?.defs.length;
           const fromCopy = arraySeed && name === "from" && globalArray && current.arguments[0] !== void 0 && referencesAccumulator(current.arguments[0]);
-          const globalObject = member3.object.type === import_utils41.AST_NODE_TYPES.Identifier && member3.object.name === "Object" && !import_utils41.ASTUtils.findVariable(
+          const globalObject = member3.object.type === import_utils42.AST_NODE_TYPES.Identifier && member3.object.name === "Object" && !import_utils42.ASTUtils.findVariable(
             context.sourceCode.getScope(member3.object),
             "Object"
           )?.defs.length;
           const target = current.arguments[0];
-          const assignCopy = objectSeed && name === "assign" && globalObject && target?.type === import_utils41.AST_NODE_TYPES.ObjectExpression && current.arguments.slice(1).some(referencesAccumulator);
+          const assignCopy = objectSeed && name === "assign" && globalObject && target?.type === import_utils42.AST_NODE_TYPES.ObjectExpression && current.arguments.slice(1).some(referencesAccumulator);
           if (directCopy || fromCopy || assignCopy)
             context.report({ node: current, messageId: "copy" });
         };
@@ -6424,7 +6608,7 @@ var no_reduce_accumulator_copy_default = createRule({
 });
 
 // src/rules/no-known-value-widening.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var import_typescript15 = __toESM(require("typescript"), 1);
 var NO_KNOWN_VALUE_WIDENING_DOCUMENTATION = {
   summary: "Preserve a known value's contract instead of widening a local binding to unknown, object, or an unknown-valued dictionary.",
@@ -6474,12 +6658,12 @@ var no_known_value_widening_default = createRule({
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     if (!context.sourceCode.parserServices?.program || !context.sourceCode.parserServices.esTreeNodeToTSNodeMap) return {};
-    const services = import_utils42.ESLintUtils.getParserServices(context);
+    const services = import_utils43.ESLintUtils.getParserServices(context);
     if (services.program === null) return {};
     const checker = services.program.getTypeChecker();
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils42.AST_NODE_TYPES.Identifier || !node.id.typeAnnotation || node.init?.type !== import_utils42.AST_NODE_TYPES.Identifier || node.parent.kind !== "const" || node.parent.parent.type === import_utils42.AST_NODE_TYPES.ExportNamedDeclaration) return;
+        if (node.id.type !== import_utils43.AST_NODE_TYPES.Identifier || !node.id.typeAnnotation || node.init?.type !== import_utils43.AST_NODE_TYPES.Identifier || node.parent.kind !== "const" || node.parent.parent.type === import_utils43.AST_NODE_TYPES.ExportNamedDeclaration) return;
         const source = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node.init));
         if (hasUnknownContract(source, checker)) return;
         const target = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node.id.typeAnnotation.typeAnnotation));
@@ -6498,7 +6682,7 @@ var no_known_value_widening_default = createRule({
 });
 
 // src/rules/no-invalid-typed-mutation.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var import_ts_api_utils = require("ts-api-utils");
 var import_typescript16 = __toESM(require("typescript"), 1);
 var NO_INVALID_TYPED_MUTATION_DOCUMENTATION = {
@@ -6535,7 +6719,7 @@ var no_invalid_typed_mutation_default = createRule({
   defaultOptions: [],
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text) || !context.sourceCode.parserServices?.program) return {};
-    const services = import_utils43.ESLintUtils.getParserServices(context);
+    const services = import_utils44.ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
     const candidates = [];
     const replaced = /* @__PURE__ */ new Set();
@@ -6606,7 +6790,7 @@ var no_invalid_typed_mutation_default = createRule({
         const target = node.arguments[0];
         if (target === void 0) return;
         invalidateNamespace(target);
-        if (target.type !== import_utils43.AST_NODE_TYPES.Identifier) return;
+        if (target.type !== import_utils44.AST_NODE_TYPES.Identifier) return;
         const writes = mutationWrites(node, method.namespace, method.method);
         if (writes !== void 0) candidates.push({ call: node, ...method, target, writes });
       },
@@ -6617,9 +6801,9 @@ var no_invalid_typed_mutation_default = createRule({
   }
 });
 function localDataTarget(target, sourceCode) {
-  const binding3 = import_utils43.ASTUtils.findVariable(sourceCode.getScope(target), target.name);
+  const binding3 = import_utils44.ASTUtils.findVariable(sourceCode.getScope(target), target.name);
   const definition = binding3?.defs.length === 1 ? binding3.defs[0] : void 0;
-  if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.id.type !== import_utils43.AST_NODE_TYPES.Identifier || definition.node.id.typeAnnotation === void 0 || definition.node.init?.type !== import_utils43.AST_NODE_TYPES.ObjectExpression || definition.parent.parent.type === import_utils43.AST_NODE_TYPES.ExportNamedDeclaration) return void 0;
+  if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.id.type !== import_utils44.AST_NODE_TYPES.Identifier || definition.node.id.typeAnnotation === void 0 || definition.node.init?.type !== import_utils44.AST_NODE_TYPES.ObjectExpression || definition.parent.parent.type === import_utils44.AST_NODE_TYPES.ExportNamedDeclaration) return void 0;
   const properties = plainProperties(definition.node.init);
   if (properties === void 0) return void 0;
   const scope = sourceCode.getScope(definition.node).variableScope;
@@ -6630,29 +6814,29 @@ function localDataTarget(target, sourceCode) {
   return new Set(properties.map((property) => property.key));
 }
 function safeTargetUse(identifier, sourceCode) {
-  if (identifier.type !== import_utils43.AST_NODE_TYPES.Identifier) return false;
+  if (identifier.type !== import_utils44.AST_NODE_TYPES.Identifier) return false;
   const parent = identifier.parent;
-  if (parent.type === import_utils43.AST_NODE_TYPES.MemberExpression && parent.object === identifier) {
-    const key = import_utils43.ASTUtils.getPropertyName(parent);
+  if (parent.type === import_utils44.AST_NODE_TYPES.MemberExpression && parent.object === identifier) {
+    const key = import_utils44.ASTUtils.getPropertyName(parent);
     const use = outerExpression(parent);
-    if (parent.optional || use.parent.type === import_utils43.AST_NODE_TYPES.UnaryExpression && use.parent.operator === "delete") return false;
-    return key !== null && key !== "__proto__" && !(use.parent.type === import_utils43.AST_NODE_TYPES.CallExpression && use.parent.callee === use);
+    if (parent.optional || use.parent.type === import_utils44.AST_NODE_TYPES.UnaryExpression && use.parent.operator === "delete") return false;
+    return key !== null && key !== "__proto__" && !(use.parent.type === import_utils44.AST_NODE_TYPES.CallExpression && use.parent.callee === use);
   }
-  if (parent.type !== import_utils43.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== identifier) return false;
+  if (parent.type !== import_utils44.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== identifier) return false;
   const method = nativeMember(parent.callee, sourceCode);
   if (method === void 0) return false;
   const writes = mutationWrites(parent, method.namespace, method.method);
-  return writes !== void 0 && writes.every((write) => write.key !== "__proto__") && keepsMutableDescriptor(parent, method.method) && (method.method === "set" || parent.parent.type === import_utils43.AST_NODE_TYPES.ExpressionStatement);
+  return writes !== void 0 && writes.every((write) => write.key !== "__proto__") && keepsMutableDescriptor(parent, method.method) && (method.method === "set" || parent.parent.type === import_utils44.AST_NODE_TYPES.ExpressionStatement);
 }
 function keepsMutableDescriptor(call, method) {
   if (method !== "defineProperty") return true;
   const descriptor = call.arguments[2];
-  if (descriptor?.type !== import_utils43.AST_NODE_TYPES.ObjectExpression) return false;
+  if (descriptor?.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) return false;
   const properties = plainProperties(descriptor);
   return properties !== void 0 && properties.every((property) => {
     if (property.key !== "writable" && property.key !== "configurable") return true;
     const value = unwrapExpression(property.value);
-    return value.type === import_utils43.AST_NODE_TYPES.Literal && value.value === true;
+    return value.type === import_utils44.AST_NODE_TYPES.Literal && value.value === true;
   });
 }
 function declaredTargetType(node, checker) {
@@ -6702,9 +6886,9 @@ function definiteSignatures(type, checker, seen) {
 }
 function nativeMember(node, sourceCode) {
   const member3 = unwrapExpression(node);
-  if (member3.type !== import_utils43.AST_NODE_TYPES.MemberExpression || member3.optional) return void 0;
+  if (member3.type !== import_utils44.AST_NODE_TYPES.MemberExpression || member3.optional) return void 0;
   const namespace = nativeNamespace(member3.object, sourceCode);
-  const method = import_utils43.ASTUtils.getPropertyName(member3);
+  const method = import_utils44.ASTUtils.getPropertyName(member3);
   if (namespace === void 0 || method === null) return void 0;
   const supported2 = namespace === "Object" ? ["assign", "defineProperty", "defineProperties", "setPrototypeOf"] : ["set", "defineProperty", "setPrototypeOf"];
   return supported2.includes(method) ? { namespace, method } : void 0;
@@ -6713,43 +6897,43 @@ function ordinaryNamespaceUse(node) {
   const value = outerExpression(node);
   const parent = value.parent;
   if (parent === void 0) return false;
-  return parent.type === import_utils43.AST_NODE_TYPES.MemberExpression && parent.object === value || parent.type === import_utils43.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" || parent.type === import_utils43.AST_NODE_TYPES.TSTypeQuery || parent.type === import_utils43.AST_NODE_TYPES.TSQualifiedName;
+  return parent.type === import_utils44.AST_NODE_TYPES.MemberExpression && parent.object === value || parent.type === import_utils44.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" || parent.type === import_utils44.AST_NODE_TYPES.TSTypeQuery || parent.type === import_utils44.AST_NODE_TYPES.TSQualifiedName;
 }
 function replacementNamespace(node, sourceCode) {
   const value = unwrapExpression(node);
   if (nativeObjectPrototype(value, sourceCode)) return "ObjectPrototype";
-  return nativeNamespace(value, sourceCode) ?? (value.type === import_utils43.AST_NODE_TYPES.MemberExpression ? replacementNamespace(value.object, sourceCode) : void 0);
+  return nativeNamespace(value, sourceCode) ?? (value.type === import_utils44.AST_NODE_TYPES.MemberExpression ? replacementNamespace(value.object, sourceCode) : void 0);
 }
 function nativeObjectPrototype(node, sourceCode) {
   const value = unwrapExpression(node);
-  return value.type === import_utils43.AST_NODE_TYPES.MemberExpression && import_utils43.ASTUtils.getPropertyName(value) === "prototype" && nativeNamespace(value.object, sourceCode) === "Object";
+  return value.type === import_utils44.AST_NODE_TYPES.MemberExpression && import_utils44.ASTUtils.getPropertyName(value) === "prototype" && nativeNamespace(value.object, sourceCode) === "Object";
 }
 function nativeNamespace(node, sourceCode) {
   const value = unwrapExpression(node);
-  if (value.type === import_utils43.AST_NODE_TYPES.MemberExpression && !value.optional && nativeGlobalReceiver(value.object, sourceCode)) {
-    const key = import_utils43.ASTUtils.getPropertyName(value);
+  if (value.type === import_utils44.AST_NODE_TYPES.MemberExpression && !value.optional && nativeGlobalReceiver(value.object, sourceCode)) {
+    const key = import_utils44.ASTUtils.getPropertyName(value);
     if (key === "Object" || key === "Reflect") return key;
   }
-  if (value.type !== import_utils43.AST_NODE_TYPES.Identifier || value.name !== "Object" && value.name !== "Reflect") return void 0;
-  const binding3 = import_utils43.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+  if (value.type !== import_utils44.AST_NODE_TYPES.Identifier || value.name !== "Object" && value.name !== "Reflect") return void 0;
+  const binding3 = import_utils44.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
   return binding3 === null || binding3.defs.length === 0 ? value.name : void 0;
 }
 function nativeGlobalReceiver(node, sourceCode) {
-  if (node.type !== import_utils43.AST_NODE_TYPES.Identifier || !["globalThis", "window", "self"].includes(node.name)) return false;
-  const binding3 = import_utils43.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  if (node.type !== import_utils44.AST_NODE_TYPES.Identifier || !["globalThis", "window", "self"].includes(node.name)) return false;
+  const binding3 = import_utils44.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
   return binding3 === null || binding3.defs.length === 0;
 }
 function mutationWrites(node, namespace, method) {
   if (namespace === "Object" && method === "assign") {
     const source = node.arguments[1];
-    return node.arguments.length === 2 && source?.type === import_utils43.AST_NODE_TYPES.ObjectExpression ? plainProperties(source) : void 0;
+    return node.arguments.length === 2 && source?.type === import_utils44.AST_NODE_TYPES.ObjectExpression ? plainProperties(source) : void 0;
   }
   if (node.arguments.length !== 3 || method !== "set" && method !== "defineProperty") return void 0;
   const key = staticString(node.arguments[1]);
   const value = node.arguments[2];
-  if (key === null || value === void 0 || value.type === import_utils43.AST_NODE_TYPES.SpreadElement) return void 0;
+  if (key === null || value === void 0 || value.type === import_utils44.AST_NODE_TYPES.SpreadElement) return void 0;
   if (method === "set") return [{ key, value }];
-  if (value.type !== import_utils43.AST_NODE_TYPES.ObjectExpression) return void 0;
+  if (value.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) return void 0;
   const properties = plainProperties(value);
   if (properties === void 0 || properties.some((property) => !["value", "configurable", "enumerable", "writable"].includes(property.key))) return void 0;
   const payload = properties.find((property) => property.key === "value");
@@ -6759,8 +6943,8 @@ function plainProperties(node) {
   const writes = [];
   const names = /* @__PURE__ */ new Set();
   for (const property of node.properties) {
-    if (property.type !== import_utils43.AST_NODE_TYPES.Property || property.kind !== "init" || property.method) return void 0;
-    const key = import_utils43.ASTUtils.getPropertyName(property);
+    if (property.type !== import_utils44.AST_NODE_TYPES.Property || property.kind !== "init" || property.method) return void 0;
+    const key = import_utils44.ASTUtils.getPropertyName(property);
     if (key === null || key === "__proto__" || names.has(key)) return void 0;
     names.add(key);
     writes.push({ key, value: property.value });
@@ -6769,7 +6953,7 @@ function plainProperties(node) {
 }
 
 // src/rules/no-contradictory-type-predicate.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var import_typescript19 = __toESM(require("typescript"), 1);
 
 // src/rules/_has-separate-predicate-contract.ts
@@ -6785,7 +6969,7 @@ function hasSeparatePredicateContract(node, checker) {
 }
 
 // src/rules/_contradictory-array-predicate.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var import_typescript18 = __toESM(require("typescript"), 1);
 var import_ts_api_utils2 = require("ts-api-utils");
 var HOST_GLOBALS = ["globalThis", "window", "self", "global"];
@@ -6798,12 +6982,12 @@ function contradictoryArrayPredicate(sourceCode, services) {
   function matches(expression, parameter, input, target) {
     if ((input.flags & import_typescript18.default.TypeFlags.Unknown) === 0 || !plainPrimitiveArray(target, checker)) return false;
     const call = unwrapExpression(expression);
-    if (call.type !== import_utils44.AST_NODE_TYPES.CallExpression || call.optional || call.arguments.length !== 1) return false;
+    if (call.type !== import_utils45.AST_NODE_TYPES.CallExpression || call.optional || call.arguments.length !== 1) return false;
     const argument = call.arguments[0];
     const callee = unwrapExpression(call.callee);
-    if (argument?.type !== import_utils44.AST_NODE_TYPES.Identifier || callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.optional || import_utils44.ASTUtils.getPropertyName(callee) !== "isArray" || callee.object.type !== import_utils44.AST_NODE_TYPES.Identifier || callee.object.name !== "Array") return false;
-    const declared = import_utils44.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name);
-    if (declared === null || declared !== import_utils44.ASTUtils.findVariable(sourceCode.getScope(argument), argument.name)) return false;
+    if (argument?.type !== import_utils45.AST_NODE_TYPES.Identifier || callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.optional || import_utils45.ASTUtils.getPropertyName(callee) !== "isArray" || callee.object.type !== import_utils45.AST_NODE_TYPES.Identifier || callee.object.name !== "Array") return false;
+    const declared = import_utils45.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name);
+    if (declared === null || declared !== import_utils45.ASTUtils.findVariable(sourceCode.getScope(argument), argument.name)) return false;
     const binding3 = nativeBinding(callee.object, sourceCode);
     if (binding3 === void 0 || !stableArray(binding3, sourceCode, stable2)) return false;
     const signature = checker.getResolvedSignature(services.esTreeNodeToTSNodeMap.get(call));
@@ -6813,7 +6997,7 @@ function contradictoryArrayPredicate(sourceCode, services) {
   return {
     matches,
     observeConstructor(member3) {
-      const name = import_utils44.ASTUtils.getPropertyName(member3, sourceCode.getScope(member3));
+      const name = import_utils45.ASTUtils.getPropertyName(member3, sourceCode.getScope(member3));
       if (name === "constructor" || name === null && member3.computed) constructorCapability = true;
     },
     stable() {
@@ -6827,7 +7011,7 @@ function plainPrimitiveArray(target, checker) {
   return element !== void 0 && (element.flags & PRIMITIVE_ELEMENTS) !== 0 && (element.flags & (import_typescript18.default.TypeFlags.Enum | import_typescript18.default.TypeFlags.EnumLiteral | import_typescript18.default.TypeFlags.Intersection)) === 0;
 }
 function nativeBinding(identifier, sourceCode) {
-  const binding3 = import_utils44.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+  const binding3 = import_utils45.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
   return binding3 !== null && binding3.defs.length === 0 ? binding3 : void 0;
 }
 function stableArray(binding3, sourceCode, cache) {
@@ -6854,8 +7038,8 @@ function typeOnlyReference2(reference) {
 }
 function ordinaryObjectUse(node) {
   const member3 = node.parent;
-  if (member3?.type !== import_utils44.AST_NODE_TYPES.MemberExpression || member3.object !== node) return false;
-  const name = import_utils44.ASTUtils.getPropertyName(member3);
+  if (member3?.type !== import_utils45.AST_NODE_TYPES.MemberExpression || member3.object !== node) return false;
+  const name = import_utils45.ASTUtils.getPropertyName(member3);
   return name !== null && !OBJECT_REFLECTION2.has(name);
 }
 function ordinaryArrayReference(reference) {
@@ -6865,17 +7049,17 @@ function ordinaryArrayReference(reference) {
 }
 function ordinaryArrayUse(node) {
   const member3 = node.parent;
-  if (member3?.type === import_utils44.AST_NODE_TYPES.TSTypeQuery) return true;
-  if (member3?.type !== import_utils44.AST_NODE_TYPES.MemberExpression || member3.object !== node || member3.optional || import_utils44.ASTUtils.getPropertyName(member3) !== "isArray") return false;
-  return member3.parent.type === import_utils44.AST_NODE_TYPES.CallExpression && member3.parent.callee === member3 && !member3.parent.optional;
+  if (member3?.type === import_utils45.AST_NODE_TYPES.TSTypeQuery) return true;
+  if (member3?.type !== import_utils45.AST_NODE_TYPES.MemberExpression || member3.object !== node || member3.optional || import_utils45.ASTUtils.getPropertyName(member3) !== "isArray") return false;
+  return member3.parent.type === import_utils45.AST_NODE_TYPES.CallExpression && member3.parent.callee === member3 && !member3.parent.optional;
 }
 function ordinaryHostReference(reference) {
   if (reference.isWrite()) return false;
   if (reference.isTypeReference && !reference.isValueReference) return true;
   let node = reference.identifier;
-  while (node.parent?.type === import_utils44.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
+  while (node.parent?.type === import_utils45.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
     const member3 = node.parent;
-    const name = import_utils44.ASTUtils.getPropertyName(member3);
+    const name = import_utils45.ASTUtils.getPropertyName(member3);
     if (name === null) return false;
     if (name === "Array") return ordinaryArrayUse(member3);
     if (name === "Reflect") return false;
@@ -6955,16 +7139,16 @@ var no_contradictory_type_predicate_default = createRule({
   defaultOptions: [],
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text) || !context.sourceCode.parserServices?.program) return {};
-    const services = import_utils45.ESLintUtils.getParserServices(context);
+    const services = import_utils46.ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
     const uncheckedArray = contradictoryArrayPredicate(context.sourceCode, services);
     const pendingArrays = [];
     function inspect(node) {
       const annotation = node.returnType?.typeAnnotation;
-      if (node.async || node.generator || node.typeParameters !== void 0 || annotation?.type !== import_utils45.AST_NODE_TYPES.TSTypePredicate || annotation.asserts || annotation.parameterName.type !== import_utils45.AST_NODE_TYPES.Identifier || annotation.typeAnnotation === void 0) return;
+      if (node.async || node.generator || node.typeParameters !== void 0 || annotation?.type !== import_utils46.AST_NODE_TYPES.TSTypePredicate || annotation.asserts || annotation.parameterName.type !== import_utils46.AST_NODE_TYPES.Identifier || annotation.typeAnnotation === void 0) return;
       const name = annotation.parameterName.name;
       if (hasSeparatePredicateContract(services.esTreeNodeToTSNodeMap.get(node), checker)) return;
-      const parameter = node.params.find((candidate2) => candidate2.type === import_utils45.AST_NODE_TYPES.Identifier && candidate2.name === name);
+      const parameter = node.params.find((candidate2) => candidate2.type === import_utils46.AST_NODE_TYPES.Identifier && candidate2.name === name);
       const expression = singleReturn(node);
       if (parameter?.typeAnnotation === void 0 || expression === void 0) return;
       const check = typeofCheck(expression);
@@ -7009,13 +7193,13 @@ function shallowRecordCheck(expression, parameter, input, target, sourceCode, ch
   const value = unwrapExpression(expression);
   const direct = typeofCheck(value);
   if (direct !== void 0) return direct.kind === "object" && sameParameter(parameter, direct.parameter, sourceCode);
-  if (value.type !== import_utils45.AST_NODE_TYPES.LogicalExpression || value.operator !== "&&") return false;
+  if (value.type !== import_utils46.AST_NODE_TYPES.LogicalExpression || value.operator !== "&&") return false;
   for (const [left, right] of [[value.left, value.right], [value.right, value.left]]) {
     const check = typeofCheck(left);
     const excluded = unwrapExpression(right);
-    if (check?.kind !== "object" || !sameParameter(parameter, check.parameter, sourceCode) || excluded.type !== import_utils45.AST_NODE_TYPES.BinaryExpression || excluded.operator !== "!==" && excluded.operator !== "!=") continue;
+    if (check?.kind !== "object" || !sameParameter(parameter, check.parameter, sourceCode) || excluded.type !== import_utils46.AST_NODE_TYPES.BinaryExpression || excluded.operator !== "!==" && excluded.operator !== "!=") continue;
     for (const [tested, sentinel] of [[excluded.left, excluded.right], [excluded.right, excluded.left]]) {
-      if (tested.type === import_utils45.AST_NODE_TYPES.Identifier && sentinel.type === import_utils45.AST_NODE_TYPES.Literal && sentinel.value === null && sameParameter(parameter, tested, sourceCode)) return true;
+      if (tested.type === import_utils46.AST_NODE_TYPES.Identifier && sentinel.type === import_utils46.AST_NODE_TYPES.Literal && sentinel.value === null && sameParameter(parameter, tested, sourceCode)) return true;
     }
   }
   return false;
@@ -7048,17 +7232,17 @@ function literalKind(type, checker) {
 }
 function singleReturn(node) {
   if (node.body === void 0) return void 0;
-  if (node.body.type !== import_utils45.AST_NODE_TYPES.BlockStatement) return node.body;
+  if (node.body.type !== import_utils46.AST_NODE_TYPES.BlockStatement) return node.body;
   const statement = node.body.body[0];
-  return node.body.body.length === 1 && statement?.type === import_utils45.AST_NODE_TYPES.ReturnStatement && statement.argument !== null ? statement.argument : void 0;
+  return node.body.body.length === 1 && statement?.type === import_utils46.AST_NODE_TYPES.ReturnStatement && statement.argument !== null ? statement.argument : void 0;
 }
 function typeofCheck(expression) {
   const value = unwrapExpression(expression);
-  if (value.type !== import_utils45.AST_NODE_TYPES.BinaryExpression || value.operator !== "===" && value.operator !== "==") return void 0;
+  if (value.type !== import_utils46.AST_NODE_TYPES.BinaryExpression || value.operator !== "===" && value.operator !== "==") return void 0;
   for (const [tested, expected] of [[value.left, value.right], [value.right, value.left]]) {
     const operand = unwrapExpression(tested);
     const kind = staticString(expected);
-    if (operand.type !== import_utils45.AST_NODE_TYPES.UnaryExpression || operand.operator !== "typeof" || operand.argument.type !== import_utils45.AST_NODE_TYPES.Identifier || kind === null || !isRuntimeKind(kind)) continue;
+    if (operand.type !== import_utils46.AST_NODE_TYPES.UnaryExpression || operand.operator !== "typeof" || operand.argument.type !== import_utils46.AST_NODE_TYPES.Identifier || kind === null || !isRuntimeKind(kind)) continue;
     return { parameter: operand.argument, kind };
   }
   return void 0;
@@ -7067,8 +7251,8 @@ function isRuntimeKind(value) {
   return RUNTIME_KINDS.has(value);
 }
 function sameParameter(declared, tested, sourceCode) {
-  const parameter = import_utils45.ASTUtils.findVariable(sourceCode.getScope(declared), declared.name);
-  return parameter !== null && parameter === import_utils45.ASTUtils.findVariable(sourceCode.getScope(tested), tested.name);
+  const parameter = import_utils46.ASTUtils.findVariable(sourceCode.getScope(declared), declared.name);
+  return parameter !== null && parameter === import_utils46.ASTUtils.findVariable(sourceCode.getScope(tested), tested.name);
 }
 function inputKinds(type, checker) {
   if ((type.flags & import_typescript19.default.TypeFlags.Unknown) !== 0) return /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"]);
@@ -7112,62 +7296,6 @@ var import_typescript21 = __toESM(require("typescript"), 1);
 // src/rules/_uuid-predicate-witness.ts
 var import_utils47 = require("@typescript-eslint/utils");
 var import_typescript20 = __toESM(require("typescript"), 1);
-
-// src/rules/_native-runtime-unchanged.ts
-var import_utils46 = require("@typescript-eslint/utils");
-var INDEXES = /* @__PURE__ */ new WeakMap();
-var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set(["globalThis", "global", "window", "self"]);
-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_utils46.AST_NODE_TYPES.MemberExpression && staticPropertyName(node, sourceCode) === "constructor" || name === "RegExp" && node.type === import_utils46.AST_NODE_TYPES.Literal && "regex" in node) || index.references.some((node) => unsafeReference(node, sourceCode, name));
-  index.results.set(name, !changed);
-  return !changed;
-}
-function runtimeIndex(sourceCode) {
-  const cached = INDEXES.get(sourceCode);
-  if (cached !== void 0) return cached;
-  const references = sourceCode.scopeManager?.scopes.flatMap((scope) => scope.references.filter((reference) => reference.isValueReference !== false).map((reference) => reference.identifier)) ?? [];
-  const nodes = [];
-  const pending = [sourceCode.ast];
-  while (pending.length > 0) {
-    const node = pending.pop();
-    if (node === void 0) continue;
-    nodes.push(node);
-    forEachAstChild(node, sourceCode.visitorKeys, (child) => {
-      pending.push(child);
-    });
-  }
-  const index = { references, nodes, results: /* @__PURE__ */ new Map() };
-  INDEXES.set(sourceCode, index);
-  return index;
-}
-function unsafeReference(node, sourceCode, name) {
-  if (!ambient(node, sourceCode)) return false;
-  if (node.name === "eval" || node.name === "Function") return true;
-  if (node.name === name) return !nativeRead(node, name);
-  if (!GLOBAL_OBJECTS2.has(node.name)) return false;
-  const value = outerExpression(node);
-  const property = value.parent;
-  if (property?.type !== import_utils46.AST_NODE_TYPES.MemberExpression || property.object !== value) return true;
-  const key = staticPropertyName(property, sourceCode);
-  if (key === null || key === "eval" || key === "Function" || key === "constructor") return true;
-  return key === name && !nativeRead(property, name);
-}
-function ambient(node, sourceCode) {
-  const variable = import_utils46.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
-  return variable === null || variable.defs.length === 0;
-}
-function nativeRead(node, name) {
-  const value = outerExpression(node);
-  const parent = value.parent;
-  if (parent?.type === import_utils46.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") return true;
-  if (name !== "Error") return false;
-  return parent?.type === import_utils46.AST_NODE_TYPES.NewExpression && parent.callee === value || parent?.type === import_utils46.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.right === value;
-}
-
-// src/rules/_uuid-predicate-witness.ts
 function uuidPredicateWitness(expression, parameter, sourceCode, services) {
   const success = unwrapExpression(expression);
   if (!member(success, "success")) return void 0;
@@ -11392,14 +11520,21 @@ function canAutofixNextConfigLiteral(sourceCode) {
 // src/rules/no-dangerously-allow-svg.ts
 var NEXT_CONFIG_RE = /(?:^|\/)next\.config\.[cm]?[jt]s$/;
 var NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION = {
-  summary: "Next.js image configuration enables SVG rendering without the required response hardening",
-  rationale: "SVG files can contain scripts and other active content; enabling dangerouslyAllowSVG makes the image optimizer serve that content from the application origin.",
-  remediation: "Keep dangerouslyAllowSVG disabled. If SVG optimization is required, retain attachment disposition and set the image Content-Security-Policy to `script-src 'none'; sandbox;`.",
+  summary: "Require an explicit hardening policy for Next Image SVG delivery",
+  rationale: "SVG can contain scripts and other active content. This organizational rule requires a recognized explicit script-blocking sandbox CSP when SVG delivery is enabled, with attachment disposition. It does not establish that framework defaults are missing or that a reported configuration is exploitable.",
+  remediation: "Disable dangerouslyAllowSVG, or configure an explicit literal image contentSecurityPolicy such as `script-src 'none'; sandbox;` and keep attachment disposition. Verify effective headers and defaults against the application's pinned Next version.",
   category: "security",
   autofix: "safe",
+  references: [
+    "https://www.w3.org/TR/2026/WD-CSP3-20261027/#parse-serialized-policy",
+    "https://github.com/vercel/next.js/blob/v16.4.3/packages/next/src/shared/lib/image-config.ts#L255"
+  ],
   limitations: [
     "Automatic boolean changes are withheld when the module contains explicit TypeScript or JSDoc contracts; those contracts can constrain an aliased property to literal true. Plain objects and as const inference remain fixable.",
-    "Automatic fixes disable the unsafe SVG opt-in; already hardened configurations are preserved. Only literal effective properties of a directly exported object, unescaped const alias, or isolated module.exports object are analyzed. Wrappers, factories, spreads, dynamic computed keys, dynamic policies and mutations are not inferred."
+    "This rule does not resolve the installed Next version or evaluate effective response headers. The inspected Next 16.4.3 defaults already block scripts, apply sandbox, and use attachment disposition. A report for omitted explicit CSP is a policy finding, not proof of XSS.",
+    "Omitted contentDispositionType is treated as attachment. Older or customized runtime defaults are not established by this source-only check.",
+    "Only a bounded literal CSP subset is recognized: the first script-src must contain only 'none', and the first sandbox must have no tokens. Directive names and separators use CSP ASCII syntax. Valid policy lists, default-src fallbacks and other equivalent policies are not proved; omitted, dynamic or unrecognized explicit policies can still report. This is not a general CSP validator or proof of runtime security.",
+    "Automatic fixes disable SVG opt-in to satisfy this policy; recognized hardened configurations are preserved. Only literal effective properties of a directly exported object, unescaped const alias, or isolated module.exports object are analyzed. Wrappers, factories, spreads, dynamic computed keys and mutations are not inferred."
   ],
   examples: [
     {
@@ -11413,7 +11548,7 @@ var NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION = {
     },
     {
       id: "svg-enabled",
-      title: "Do not enable active SVG delivery",
+      title: "SVG opt-in requires explicit hardening under this policy",
       outcome: "match",
       files: [{ path: "next.config.mjs", source: "export default { images: { dangerouslyAllowSVG: true } };\n" }],
       focusPath: "next.config.mjs",
@@ -11422,12 +11557,34 @@ var NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION = {
     },
     {
       id: "safe-autofix",
-      title: "Apply the proven automatic correction",
+      title: "Disable SVG delivery to satisfy this policy",
       outcome: "match",
       files: [{ path: "next.config.ts", source: "export default { images: { dangerouslyAllowSVG: true } };" }],
       fixedFiles: [{ path: "next.config.ts", source: "export default { images: { dangerouslyAllowSVG: false } };" }],
       focusPath: "next.config.ts",
       expectedCount: 1
+    },
+    {
+      id: "svg-explicit-hardening",
+      scenarioId: "explicit-hardening",
+      title: "Allow SVG delivery with explicit hardening",
+      outcome: "no-match",
+      files: [{ path: "next.config.mjs", source: `export default { images: { dangerouslyAllowSVG: true, contentDispositionType: "attachment", contentSecurityPolicy: "script-src 'none'; sandbox;" } };
+` }],
+      focusPath: "next.config.mjs",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "svg-unsafe-first-directive",
+      scenarioId: "explicit-hardening",
+      title: "A later duplicate cannot replace the effective policy",
+      outcome: "match",
+      files: [{ path: "next.config.mjs", source: `export default { images: { dangerouslyAllowSVG: true, contentDispositionType: "attachment", contentSecurityPolicy: "script-src 'unsafe-inline'; script-src 'none'; sandbox;" } };
+` }],
+      focusPath: "next.config.mjs",
+      expectedCount: 1,
+      public: true
     }
   ]
 };
@@ -11437,12 +11594,16 @@ function literalString2(node) {
   return null;
 }
 function hasHardenedSvgPolicy(policy) {
-  const directives = policy.split(";").map((part) => part.trim().split(/\s+/u).filter(Boolean)).filter((parts) => parts.length > 0);
-  const scriptSources = directives.filter(([name]) => name?.toLowerCase() === "script-src");
-  const sandboxes = directives.filter(([name]) => name?.toLowerCase() === "sandbox");
-  const scriptSource = scriptSources[0];
-  const sandbox = sandboxes[0];
-  return scriptSources.length === 1 && sandboxes.length === 1 && scriptSource?.length === 2 && scriptSource[1]?.toLowerCase() === "'none'" && sandbox?.length === 1;
+  const directives = /* @__PURE__ */ new Map();
+  for (const part of policy.split(";")) {
+    const [name, ...values] = part.split(/[\t\n\f\r ]+/u).filter(Boolean);
+    if (name === void 0 || !/^[A-Za-z0-9-]+$/u.test(name)) continue;
+    const key = name.toLowerCase();
+    if (!directives.has(key)) directives.set(key, values);
+  }
+  const scriptSource = directives.get("script-src");
+  const sandbox = directives.get("sandbox");
+  return scriptSource?.length === 1 && scriptSource[0]?.toLowerCase() === "'none'" && sandbox?.length === 0;
 }
 var no_dangerously_allow_svg_default = createRule({
   name: "no-dangerously-allow-svg",
@@ -11453,7 +11614,7 @@ var no_dangerously_allow_svg_default = createRule({
     docs: { description: NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION.summary },
     schema: [],
     messages: {
-      noDangerouslyAllowSvg: "Do not enable dangerouslyAllowSVG without a script-blocking sandbox policy and attachment disposition. SVG can carry active content served from the application origin."
+      noDangerouslyAllowSvg: "SVG opt-in requires a recognized explicit script-blocking sandbox CSP and attachment disposition under this policy."
     }
   },
   defaultOptions: [],
@@ -17749,7 +17910,7 @@ var NO_RAW_FETCH_OUTSIDE_CLIENTS_DOCUMENTATION = {
   rationale: "Scattered fetch calls bypass shared transport policy and are harder to stub and observe consistently.",
   remediation: "Move the request into a client module and call that abstraction from application code.",
   category: "architecture",
-  limitations: ["Tests, client-layer paths, constructed handoffs, and pre-signed URL transfers are excluded. Configure the same literal Next.js basePath here and on prefer-server-actions so one rule owns each internal mutation.", "Effect and pre-signed-transfer exemptions use recognized syntax and naming conventions, not complete React or URL provenance. Those conservative exclusions are recall limitations, not evidence that every excluded request satisfies transport policy."],
+  limitations: ["Tests, client-layer paths, constructed handoffs, and pre-signed URL transfers are excluded. Configure the same literal Next.js basePath here and on prefer-server-actions so one rule owns each internal mutation.", "Effect and pre-signed-transfer exemptions use recognized syntax and naming conventions, not complete React or URL provenance. Those conservative exclusions are recall limitations, not evidence that every excluded request satisfies transport policy.", "Unshadowed native members and bounded stable const aliases or single-property destructuring are recognized. Visible writes, callable escapes, whole-global escapes and mutation capabilities anywhere in the file invalidate that proof, including earlier captures. Known unrelated global member writes and typeof global checks do not. Static constructor members and destructuring projections invalidate the proof; indirect reflection, external monkeypatches and arbitrary forwarding functions are not inferred."],
   examples: [
     { id: "client-call", title: "Use a client abstraction", outcome: "no-match", files: [{ path: "src/routes/handler.ts", source: "const response = await billingClient.getInvoice(id);" }], focusPath: "src/routes/handler.ts", expectedCount: 0, public: true },
     { id: "raw-fetch", title: "Do not call global fetch here", outcome: "match", files: [{ path: "src/routes/handler.ts", source: "const response = await fetch('/api/invoices');" }], focusPath: "src/routes/handler.ts", expectedCount: 1, public: true }
@@ -17770,11 +17931,6 @@ var DEFAULT_ALLOW = [
   "[\\\\/][^\\\\/]*(?:Client|client)\\.[cm]?[jt]sx?$"
 ];
 var NON_PRODUCTION_TREE_RE = /[\\/](playwright|cypress|__testfixtures__)[\\/]/;
-var GLOBAL_RECEIVERS3 = /* @__PURE__ */ new Set([
-  "globalThis",
-  "window",
-  "self"
-]);
 var PRESIGNED_URL_NAME_RE = /(?:pre-?signed|signed|upload|download)Url$/i;
 var INTERNAL_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "POST",
@@ -17798,23 +17954,13 @@ var BASE_PATH_RE = /^\/(?!$)(?!.*[?#])(?:[^/]+\/)*[^/]+$/u;
 function isValidBasePath(basePath) {
   return BASE_PATH_RE.test(basePath) && !basePath.split("/").some((segment) => segment === "." || segment === "..");
 }
-function isGlobalFetchCall(node, resolvesToGlobal) {
-  const callee = unwrapExpression(node.callee);
-  if (callee.type === "Identifier") {
-    return callee.name === "fetch" && resolvesToGlobal(callee);
-  }
-  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "fetch" && callee.object.type === "Identifier") {
-    return GLOBAL_RECEIVERS3.has(callee.object.name) && resolvesToGlobal(callee.object);
-  }
-  return false;
-}
 function isConstructedArgumentHandoff(node, resolvesToGlobal) {
   const [first] = node.arguments;
   return node.arguments.length === 1 && first !== void 0 && first.type === import_utils108.AST_NODE_TYPES.NewExpression && first.callee.type === import_utils108.AST_NODE_TYPES.Identifier && (first.callee.name === "URL" || first.callee.name === "Request") && resolvesToGlobal(first.callee);
 }
 function effectOwns(node) {
   const unwrappedNodeCallee = unwrapExpression(node.callee);
-  if (unwrappedNodeCallee.type !== import_utils108.AST_NODE_TYPES.Identifier) return false;
+  if (unwrappedNodeCallee.type !== import_utils108.AST_NODE_TYPES.Identifier || unwrappedNodeCallee.name !== "fetch") return false;
   const method = readDirectMethod(node);
   if (method !== null && method !== "GET") return false;
   const first = node.arguments[0];
@@ -17951,7 +18097,7 @@ var no_raw_fetch_outside_clients_default = createRule({
     }
     function serverActionOwns(node) {
       const unwrappedNodeCallee = unwrapExpression(node.callee);
-      if (unwrappedNodeCallee.type !== import_utils108.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective2 || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+      if (unwrappedNodeCallee.type !== import_utils108.AST_NODE_TYPES.Identifier || unwrappedNodeCallee.name !== "fetch" || !resolvesToGlobal(unwrappedNodeCallee) || !hasUseClientDirective || hasUseServerDirective2 || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
         return false;
       }
       const url = node.arguments[0];
@@ -18008,7 +18154,7 @@ var no_raw_fetch_outside_clients_default = createRule({
     }
     return {
       CallExpression(node) {
-        if (!isGlobalFetchCall(node, resolvesToGlobal)) {
+        if (!nativeFetchReference(unwrapExpression(node.callee), context.sourceCode)) {
           return;
         }
         if (isPresignedUrlTransfer(node) || isConstructedArgumentHandoff(node, resolvesToGlobal) || effectOwns(node) || serverActionOwns(node)) {
@@ -32630,6 +32776,7 @@ var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   limitations: [
     "Signal presence establishes an explicit cancellation path, not a guaranteed timeout. Literal null, global undefined, and void 0 do not provide a signal. Erased TypeScript wrappers preserve the same analysis. Unknown spreads and dynamic values are not inferred. Forwarded Request objects retain their signal unless an init explicitly resets it to null.",
     "Unshadowed native fetch members and bounded stable const aliases or destructuring are recognized. Reassigned, defaulted and unknown aliases and arbitrary forwarding functions are excluded.",
+    "Visible writes, callable escapes, whole-global escapes and mutation capabilities anywhere in the file invalidate native fetch identity, including earlier captures. Known unrelated global member writes and typeof global checks do not. Static constructor members and destructuring projections invalidate the proof; indirect reflection and external monkeypatches are not inferred.",
     "Accessors and unproved prototypes are excluded because native option conversion can attach or replace a signal before it is read."
   ],
   examples: [
@@ -32676,7 +32823,7 @@ function emptySignal(expression, resolvesToGlobal) {
   }
   return null;
 }
-function initSignalState(init, resolvesToGlobal) {
+function initSignalState(init, resolvesToGlobal, sourceCode) {
   init = unwrapExpression(init);
   if (init.type !== import_utils176.AST_NODE_TYPES.ObjectExpression) return "unknown";
   let state = "absent";
@@ -32686,12 +32833,12 @@ function initSignalState(init, resolvesToGlobal) {
       continue;
     }
     if (prop.kind !== "init" || hasUnprovedPrototype(prop)) return "unknown";
-    const isSignal = !prop.computed && prop.key.type === import_utils176.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils176.AST_NODE_TYPES.Literal && prop.key.value === "signal";
-    if (isSignal) {
+    const name = staticPropertyName(prop, sourceCode);
+    if (name === "signal") {
       state = !prop.method ? emptySignal(prop.value, resolvesToGlobal) ?? "unknown" : "unknown";
-    } else if (!prop.computed && import_utils176.ASTUtils.getPropertyName(prop) === "__proto__" && state === "absent") {
+    } else if (!prop.computed && name === "__proto__" && state === "absent") {
       state = "unknown";
-    } else if (prop.computed && prop.key.type !== import_utils176.AST_NODE_TYPES.Literal) {
+    } else if (prop.computed && name === null) {
       state = "unknown";
     }
   }
@@ -32769,7 +32916,7 @@ var require_fetch_timeout_default = createRule({
           return "unknown";
         }
       }
-      return initSignalState(definition.node.init, resolvesToGlobal);
+      return initSignalState(definition.node.init, resolvesToGlobal, context.sourceCode);
     }
     function isForwardedRequest(argument) {
       let value = unwrapExpression(argument);
@@ -32797,7 +32944,7 @@ var require_fetch_timeout_default = createRule({
         }
         const [first, rawInit] = node.arguments;
         const init = rawInit === void 0 ? void 0 : unwrapExpression(rawInit);
-        const state = init === void 0 ? "unknown" : init.type === import_utils176.AST_NODE_TYPES.Identifier ? localConstInitSignalState(init) : initSignalState(init, resolvesToGlobal);
+        const state = init === void 0 ? "unknown" : init.type === import_utils176.AST_NODE_TYPES.Identifier ? localConstInitSignalState(init) : initSignalState(init, resolvesToGlobal, context.sourceCode);
         if (first !== void 0 && (node.arguments.length === 1 && !isInlineUrl(first, resolvesToGlobal) || isForwardedRequest(first) && state !== "null")) {
           return;
         }