@sarj/eslint-plugin 16.38.55 → 16.39.1

package/dist/index.cjs

@@ -1814,32 +1814,215 @@ var no_generic_json_parser_default = createRule({
 });
 
 // src/rules/no-redundant-local-alias.ts
+var import_utils20 = require("@typescript-eslint/utils");
+
+// src/rules/_unused-private-binding.ts
+var import_utils19 = require("@typescript-eslint/utils");
+
+// src/rules/_type-binding.ts
 var import_utils18 = require("@typescript-eslint/utils");
+function typeBinding(source, identifier) {
+  let scope = source.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== void 0 && (variable.isTypeVariable || variable.defs.some((definition) => definition.isTypeDefinition))) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return null;
+}
+var REFERENCE_INDEXES = /* @__PURE__ */ new WeakMap();
+function retainsNamedTypeUses(source, removed) {
+  const manager = source.scopeManager;
+  if (manager === null) return false;
+  const index = referenceIndex(source, manager);
+  for (const reference of referencesWithin(index.references, removed)) {
+    if (!reference.isRead()) continue;
+    const binding3 = reference.resolved;
+    if (!binding3 || !reference.isTypeReference && !reference.isValueReference) return false;
+    if (binding3.defs.length === 0) continue;
+    const reads = publicReadExtents(index, binding3);
+    const extent = reference.isTypeReference ? reference.isValueReference ? reads.both : reads.type : reads.value;
+    if (extent === null || extent.minStart >= removed.range[0] && extent.maxEnd <= removed.range[1]) return false;
+  }
+  return true;
+}
+function referenceIndex(source, manager) {
+  const cached = REFERENCE_INDEXES.get(source);
+  if (cached?.manager === manager) return cached;
+  const references = manager.scopes.flatMap((scope) => scope.references);
+  references.sort((left, right) => left.identifier.range[0] - right.identifier.range[0]);
+  const index = { manager, references, publicReads: /* @__PURE__ */ new Map() };
+  REFERENCE_INDEXES.set(source, index);
+  return index;
+}
+function* referencesWithin(references, removed) {
+  let low = 0;
+  let high = references.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    const reference = references[middle];
+    if (reference === void 0 || reference.identifier.range[0] >= removed.range[0]) high = middle;
+    else low = middle + 1;
+  }
+  for (let index = low; index < references.length; index++) {
+    const reference = references[index];
+    if (reference === void 0) continue;
+    if (reference.identifier.range[0] > removed.range[1]) break;
+    if (insideTypeRange(reference.identifier, removed)) yield reference;
+  }
+}
+function publicReadExtents(index, binding3) {
+  const cached = index.publicReads.get(binding3);
+  if (cached !== void 0) return cached;
+  let type = null;
+  let value = null;
+  let both = null;
+  for (const retained of binding3.references) {
+    if (!retained.isRead() || !retained.isTypeReference && !retained.isValueReference || binding3.defs.some((definition) => insideTypeRange(retained.identifier, definition.node)) || !publicTypeUse(retained.identifier)) continue;
+    if (retained.isTypeReference) type = extendExtent(type, retained.identifier);
+    if (retained.isValueReference) value = extendExtent(value, retained.identifier);
+    if (retained.isTypeReference && retained.isValueReference) both = extendExtent(both, retained.identifier);
+  }
+  const result = { type, value, both };
+  index.publicReads.set(binding3, result);
+  return result;
+}
+function extendExtent(extent, identifier) {
+  return {
+    minStart: Math.min(extent?.minStart ?? identifier.range[0], identifier.range[0]),
+    maxEnd: Math.max(extent?.maxEnd ?? identifier.range[1], identifier.range[1])
+  };
+}
+function publicTypeUse(identifier) {
+  let node = identifier;
+  while (node.parent) {
+    if (node.type === import_utils18.AST_NODE_TYPES.TSTypeAnnotation || node.type === import_utils18.AST_NODE_TYPES.TSTypePredicate || node.type === import_utils18.AST_NODE_TYPES.TSAsExpression || node.type === import_utils18.AST_NODE_TYPES.TSTypeAssertion) return false;
+    if (node.type === import_utils18.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      return node.parent.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.declaration === node && node.parent.parent.type === import_utils18.AST_NODE_TYPES.Program;
+    }
+    if (node.type === import_utils18.AST_NODE_TYPES.ExportSpecifier) {
+      return node.parent.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.source === null && node.parent.parent.type === import_utils18.AST_NODE_TYPES.Program;
+    }
+    node = node.parent;
+  }
+  return false;
+}
+function insideTypeRange(node, range) {
+  return node.range[0] >= range.range[0] && node.range[1] <= range.range[1];
+}
+
+// src/rules/_unused-private-binding.ts
+function isUnusedPrivateBinding(sourceCode, declaration, identifier, filename, allowedDeclarations = [declaration]) {
+  if (/\.d\.[cm]?ts$/u.test(filename)) return false;
+  const bindings = sourceCode.getDeclaredVariables(declaration).filter((binding3) => binding3.name === identifier.name);
+  if (bindings.length === 0 || bindings.some((binding3) => binding3.defs.length !== allowedDeclarations.length || binding3.defs.some((definition) => !allowedDeclarations.includes(definition.node)) || binding3.eslintUsed || binding3.references.some((reference) => reference.isRead() || reference.init !== true))) return false;
+  if (hasIdentifierNamed(sourceCode.ast, "eval")) return false;
+  const statement = declaration.type === import_utils19.AST_NODE_TYPES.VariableDeclarator ? declaration.parent : declaration;
+  if (statement.parent.type === import_utils19.AST_NODE_TYPES.ExportNamedDeclaration || statement.parent.type === import_utils19.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  if (statement.parent.type !== import_utils19.AST_NODE_TYPES.Program) return statement.parent.type === import_utils19.AST_NODE_TYPES.BlockStatement;
+  return sourceCode.ast.body.some((node) => node.type === import_utils19.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils19.AST_NODE_TYPES.ExportNamedDeclaration || node.type === import_utils19.AST_NODE_TYPES.ExportDefaultDeclaration || node.type === import_utils19.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_utils19.AST_NODE_TYPES.CallExpression && parent.callee === identifier) return true;
+    return parent.type === import_utils19.AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.parent.type === import_utils19.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
+  });
+}
+var IDENTIFIER_NAMES = /* @__PURE__ */ new WeakMap();
+function hasIdentifierNamed(node, name) {
+  let names = IDENTIFIER_NAMES.get(node);
+  if (names === void 0) {
+    const collected = /* @__PURE__ */ new Set();
+    const pending = [node];
+    const seen = /* @__PURE__ */ new WeakSet();
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (current === void 0 || seen.has(current)) continue;
+      seen.add(current);
+      if (current.type === import_utils19.AST_NODE_TYPES.Identifier || current.type === import_utils19.AST_NODE_TYPES.JSXIdentifier) collected.add(current.name);
+      forEachOwnAstChild(current, (child) => {
+        pending.push(child);
+      }, (key) => key !== "tokens" && key !== "comments");
+    }
+    names = collected;
+    IDENTIFIER_NAMES.set(node, names);
+  }
+  return names.has(name);
+}
+function privatePredicateBooleanFix(sourceCode, node, annotation, filename) {
+  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_utils19.AST_NODE_TYPES.FunctionDeclaration || node.id === null || !isUnusedPrivateBinding(sourceCode, node, node.id, filename) || sourceCode.getCommentsInside(annotation).length > 0) return null;
+  const text = `boolean${sourceCode.getText(annotation).replace(/[^\r\n\u2028\u2029]/gu, "")}`;
+  const neighbor = Math.max(0, annotation.range[0] - 1);
+  const before = sourceCode.text.slice(neighbor, annotation.range[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  const after = (sourceCode.text.slice(neighbor, annotation.range[0]) + text + sourceCode.text.slice(annotation.range[1], annotation.range[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  if (before.length !== after.length || before.some((ending, index) => ending !== after[index])) return null;
+  return (fixer) => fixer.replaceText(annotation, text);
+}
+
+// src/rules/no-redundant-local-alias.ts
 var NO_REDUNDANT_LOCAL_ALIAS_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Pass the original local into an object field instead of creating a single-use rename.",
   rationale: "An unannotated alias used only by its matching object field adds a second name without adding a contract.",
   remediation: "Write the object property with the original binding, then remove the redundant alias. Keep annotations, captured snapshots and independently useful names.",
   category: "maintainability",
+  autofix: "safe",
   limitations: [
     "Checks an unannotated local const alias of a stable parameter or earlier const. Its single read must be a shorthand property in the same function scope. Module exports, imported bindings, captures, reassignment, positional uses and typed aliases are preserved.",
-    "A diagnostic requires review; no automatic rewrite changes inferred narrowing, shorthand source text or observable binding names."
+    "Safe fixes are limited to a plain module-scope function with one explicitly intrinsic-primitive parameter and exactly a const alias followed by a returned object containing that sole shorthand field. The source binding must remain the same at the returned field. Generics, return annotations, optional/default parameters, destructuring, overloads, comments, eval, async/generator functions and the special __proto__ key remain manual. Other diagnostics require review."
   ],
   examples: [
     { id: "redundant-alias", title: "The property already supplies the name", outcome: "match", files: [{ path: "src/request.ts", source: "function request(value: string) { const accountId = value; return { accountId }; }" }], focusPath: "src/request.ts", expectedCount: 1, public: true },
-    { id: "direct-property", title: "Use the original binding", outcome: "no-match", files: [{ path: "src/request.ts", source: "function request(value: string) { return { accountId: value }; }" }], focusPath: "src/request.ts", expectedCount: 0, public: true }
+    { id: "direct-property", title: "Use the original binding", outcome: "no-match", files: [{ path: "src/request.ts", source: "function request(value: string) { return { accountId: value }; }" }], focusPath: "src/request.ts", expectedCount: 0, public: true },
+    { id: "closed-primitive-parameter-alias", scenarioId: "closed-primitive-parameter-alias", title: "The closed primitive return preserves the data-field contract", outcome: "match", files: [{ path: "src/request.ts", source: "export {};\nfunction request(value: string) {\n  const accountId = value;\n  return { accountId };\n}\n" }], fixedFiles: [{ path: "src/request.ts", source: "export {};\nfunction request(value: string) {\n\n  return { accountId: value };\n}\n" }], focusPath: "src/request.ts", expectedCount: 1, public: true },
+    { id: "closed-primitive-parameter-alias-fixed", scenarioId: "closed-primitive-parameter-alias", title: "The direct data field needs no local alias", outcome: "no-match", files: [{ path: "src/request.ts", source: "export {};\nfunction request(value: string) {\n\n  return { accountId: value };\n}\n" }], focusPath: "src/request.ts", expectedCount: 0, public: true }
   ]
 };
 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_utils18.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_utils20.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.kind === "const" && definition.node.init !== null && definition.node.range[1] < alias.range[0];
+}
+var PRIMITIVE_PARAMETERS = /* @__PURE__ */ new Set([
+  import_utils20.AST_NODE_TYPES.TSStringKeyword,
+  import_utils20.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils20.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils20.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils20.AST_NODE_TYPES.TSSymbolKeyword
+]);
+function closedPrimitiveReturnFix(sourceCode, node, property, source, target) {
+  const statement = node.parent;
+  const body3 = statement.parent;
+  if (body3.type !== import_utils20.AST_NODE_TYPES.BlockStatement) return null;
+  const owner = body3.parent;
+  if (owner.type !== import_utils20.AST_NODE_TYPES.FunctionDeclaration || owner.parent.type !== import_utils20.AST_NODE_TYPES.Program || owner.id === null || owner.async || owner.generator || owner.typeParameters !== void 0 || owner.returnType !== void 0 || owner.params.length !== 1 || body3.body.length !== 2 || body3.body[0] !== statement || node.id.type !== import_utils20.AST_NODE_TYPES.Identifier || node.id.name === "__proto__" || node.init?.type !== import_utils20.AST_NODE_TYPES.Identifier || sourceCode.getCommentsInside(owner).length !== 0 || hasIdentifierNamed(sourceCode.ast, "eval")) return null;
+  const parameter = owner.params[0];
+  const returned2 = body3.body[1];
+  if (parameter?.type !== import_utils20.AST_NODE_TYPES.Identifier || parameter.optional === true || parameter.typeAnnotation === void 0 || !PRIMITIVE_PARAMETERS.has(parameter.typeAnnotation.typeAnnotation.type) || returned2?.type !== import_utils20.AST_NODE_TYPES.ReturnStatement || returned2.argument !== property.parent || property.parent.type !== import_utils20.AST_NODE_TYPES.ObjectExpression || property.parent.properties.length !== 1 || import_utils20.ASTUtils.findVariable(sourceCode.getScope(parameter), parameter.name) !== source || import_utils20.ASTUtils.findVariable(sourceCode.getScope(property), node.init.name) !== source || source.references.some((reference) => reference.isTypeReference) || target.references.some((reference) => reference.isTypeReference)) return null;
+  const name = owner.id.name;
+  const bindings = sourceCode.getDeclaredVariables(owner).filter((binding3) => binding3.name === name);
+  if (bindings.length !== 1 || bindings[0]?.defs.length !== 1 || bindings[0].defs[0]?.node !== owner || bindings[0].references.some((reference) => reference.isTypeReference)) return null;
+  const span = [body3.range[0] + 1, statement.range[1]];
+  const boundaries = sourceCode.text.slice(...span).replace(/[^\r\n\u2028\u2029]/gu, "");
+  const neighbor = Math.max(0, span[0] - 1);
+  const before = sourceCode.text.slice(neighbor, span[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  const after = (sourceCode.text.slice(neighbor, span[0]) + boundaries + sourceCode.text.slice(span[1], span[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  if (before.length !== after.length || before.some((ending, index) => ending !== after[index])) return null;
+  const key = sourceCode.getText(property.key);
+  const value = sourceCode.getText(node.init);
+  return (fixer) => [fixer.replaceTextRange(span, boundaries), fixer.replaceText(property, `${key}: ${value}`)];
 }
 var no_redundant_local_alias_default = createRule({
   name: "no-redundant-local-alias",
   documentation: NO_REDUNDANT_LOCAL_ALIAS_DOCUMENTATION,
   meta: {
     type: "suggestion",
+    fixable: "code",
     docs: { description: NO_REDUNDANT_LOCAL_ALIAS_DOCUMENTATION.summary },
     schema: [],
     messages: { redundantAlias: "This alias is read only by its matching object field; pass `{{source}}` directly as `{{target}}: {{source}}`." }
@@ -1847,31 +2030,32 @@ var no_redundant_local_alias_default = createRule({
   defaultOptions: [],
   create(context) {
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
+    const hasModuleSyntax = context.sourceCode.ast.body.some((candidate2) => candidate2.type === import_utils20.AST_NODE_TYPES.ImportDeclaration || candidate2.type === import_utils20.AST_NODE_TYPES.ExportNamedDeclaration || candidate2.type === import_utils20.AST_NODE_TYPES.ExportDefaultDeclaration || candidate2.type === import_utils20.AST_NODE_TYPES.ExportAllDeclaration);
     return {
       VariableDeclarator(node) {
-        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;
+        if (node.parent.kind !== "const" || node.parent.declarations.length !== 1 || node.id.type !== import_utils20.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0 || node.init?.type !== import_utils20.AST_NODE_TYPES.Identifier) return;
         const scope = context.sourceCode.getScope(node);
         if (scope.variableScope.type !== "function") return;
-        const target = import_utils18.ASTUtils.findVariable(scope, node.id.name);
-        const source = import_utils18.ASTUtils.findVariable(scope, node.init.name);
+        const target = import_utils20.ASTUtils.findVariable(scope, node.id.name);
+        const source = import_utils20.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_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 } });
+        if (property.type !== import_utils20.AST_NODE_TYPES.Property || !property.shorthand || property.value !== read.identifier || property.parent.type !== import_utils20.AST_NODE_TYPES.ObjectExpression || property.computed || property.method || property.kind !== "init") return;
+        context.report({ node, messageId: "redundantAlias", fix: hasModuleSyntax ? closedPrimitiveReturnFix(context.sourceCode, node, property, source, target) : null, data: { source: node.init.name, target: node.id.name } });
       }
     };
   }
 });
 
 // src/rules/no-test-comments.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 
 // src/rules/_comments.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils21 = 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/;
@@ -1957,10 +2141,10 @@ var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
 var TOKEN_PLURAL_MIN = 4;
 var RESTATABLE_STATEMENTS = /* @__PURE__ */ new Set([
-  import_utils19.AST_NODE_TYPES.ExpressionStatement,
-  import_utils19.AST_NODE_TYPES.ReturnStatement,
-  import_utils19.AST_NODE_TYPES.ThrowStatement,
-  import_utils19.AST_NODE_TYPES.VariableDeclaration
+  import_utils21.AST_NODE_TYPES.ExpressionStatement,
+  import_utils21.AST_NODE_TYPES.ReturnStatement,
+  import_utils21.AST_NODE_TYPES.ThrowStatement,
+  import_utils21.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([
@@ -2019,12 +2203,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_utils19.AST_NODE_TYPES.Program; node = node.parent) {
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils21.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_utils19.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
+    if (node.type === import_utils21.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
       return null;
     }
     return node;
@@ -2034,8 +2218,8 @@ function restatableStatementNodeBelow(comment, sourceCode) {
 function isTrivialInitializer(node) {
   return node.declarations.every((declarator) => {
     const init = declarator.init;
-    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;
+    if (init == null || init.type === import_utils21.AST_NODE_TYPES.Literal) return true;
+    return init.type === import_utils21.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils21.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
   });
 }
 function restatesStatementHead(body3, statement) {
@@ -2062,7 +2246,7 @@ function headTokens(source) {
 }
 
 // src/rules/_comment-edits.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 function physicalLineEnd(text, offset) {
   const newline = text.indexOf("\n", offset);
   return newline < 0 ? text.length : newline;
@@ -2096,7 +2280,11 @@ function trailingCommentRemovalRange(text, comment) {
   return { range: [start, contentEnd] };
 }
 function commentLineEndings(text, removal) {
-  return text.slice(...removal.range).replace(/[^\r\n]/gu, "");
+  const replacement = text.slice(...removal.range).replace(/[^\r\n\u2028\u2029]/gu, "");
+  const neighbor = Math.max(0, removal.range[0] - 1);
+  const original = text.slice(neighbor, removal.range[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  const rendered = (text.slice(neighbor, removal.range[0]) + replacement + text.slice(removal.range[1], removal.range[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+  return original.length === rendered.length && original.every((ending, index) => ending === rendered[index]) ? replacement : null;
 }
 function exactMemberCommentRemovalRange(text, comment, key) {
   if (key.type !== "Identifier") return null;
@@ -2126,6 +2314,7 @@ var NO_TEST_COMMENTS_DOCUMENTATION = {
   ]
 };
 var DIRECTIVE = /^(?:eslint(?:-\S+)?\b|(?:biome|oxlint|jshint|jslint|c8|v8|istanbul|vitest|prettier|dprint)\b|@(?:ts-(?:check|nocheck|expect-error|ignore)|vitest-environment|jest-environment|jsx\w*|license|preserve)\b|[#!]\s*__(?:PURE|NO_SIDE_EFFECTS)__|\/\s*<(?:reference|amd-module|amd-dependency)\b)/u;
+var BEHAVIORAL_DIRECTIVE = /(?:[@#]__(?:PURE|NO_SIDE_EFFECTS)__|@vite-ignore\b|\bwebpack(?:ChunkName|Mode|Exports|FetchPriority|Include|Exclude|Prefetch|Preload|Ignore)\s*:)/u;
 var LEGAL = /(?:^|\n)\s*\*?\s*(?:Copyright\b|SPDX-License-Identifier:|Licensed under\b|@license\b|@preserve\b)/iu;
 var TYPE_CONTRACT = /@(?:type|typedef|template|param|returns?|satisfies|callback|overload|implements|extends|augments|enum|this|import)\b/u;
 var DETECT_SECRETS_COMMENT_MARKERS = [
@@ -2145,12 +2334,13 @@ var PYTHON_EXTRA_WHITESPACE = /* @__PURE__ */ new Set(["", "", "", ""]);
 function hasDetectSecretsPragma(comment, text) {
   if (!comment.value.includes("pragma:")) return false;
   let lineStart = Math.max(text.lastIndexOf("\r", comment.range[0] - 1), text.lastIndexOf("\n", comment.range[0] - 1)) + 1;
+  const readerLineEndings = /\r\n?|\n/gu;
+  readerLineEndings.lastIndex = lineStart;
   while (lineStart < comment.range[1]) {
-    const nextCr = text.indexOf("\r", lineStart);
-    const nextLf = text.indexOf("\n", lineStart);
-    const lineEnd = Math.min(nextCr < 0 ? text.length : nextCr, nextLf < 0 ? text.length : nextLf);
+    const ending = readerLineEndings.exec(text);
+    const lineEnd = ending?.index ?? text.length;
     if (hasPragmaInReaderLine(comment, text.slice(lineStart, lineEnd), lineStart)) return true;
-    lineStart = lineEnd + (text[lineEnd] === "\r" && text[lineEnd + 1] === "\n" ? 2 : 1);
+    lineStart = lineEnd + (ending?.[0].length ?? 1);
   }
   return false;
 }
@@ -2189,7 +2379,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_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));
+    const framework = context.sourceCode.ast.body.some((statement) => statement.type === import_utils23.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils23.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() {
@@ -2210,26 +2400,35 @@ var no_test_comments_default = createRule({
         }
         for (const [index, comment] of comments.entries()) {
           const body3 = comment.value.trim().replace(/^\*\s*/u, "");
-          if (DIRECTIVE.test(body3) || LEGAL.test(comment.value) || legalLines.has(index) || TYPE_CONTRACT.test(comment.value) || hasDetectSecretsPragma(comment, context.sourceCode.text)) continue;
+          if (DIRECTIVE.test(body3) || BEHAVIORAL_DIRECTIVE.test(comment.value) || LEGAL.test(comment.value) || legalLines.has(index) || TYPE_CONTRACT.test(comment.value) || hasDetectSecretsPragma(comment, context.sourceCode.text)) continue;
           context.report({
             node: comment,
             messageId: "testComment",
             fix: (fixer) => {
               const text = context.sourceCode.text;
+              const preserveLineTerminators = (edit) => {
+                const neighbor = Math.max(0, edit.range[0] - 1);
+                const original = text.slice(neighbor, edit.range[1] + 1).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+                const rendered = (text.slice(neighbor, edit.range[0]) + edit.text + text.slice(edit.range[1], edit.range[1] + 1)).match(/\r\n|[\r\n\u2028\u2029]/gu) ?? [];
+                return original.length === rendered.length && original.every((ending, position) => ending === rendered[position]) ? edit : null;
+              };
               const own = ownLineCommentRemovalRange(text, comment);
-              if (own !== null) return fixer.replaceTextRange(own.range, commentLineEndings(text, own));
+              if (own !== null) {
+                const ownEndings = commentLineEndings(text, own);
+                return ownEndings === null ? null : preserveLineTerminators(fixer.replaceTextRange(own.range, ownEndings));
+              }
               const trailing = trailingCommentRemovalRange(text, comment);
-              if (trailing !== null) return fixer.replaceTextRange(trailing.range, "");
+              if (trailing !== null) return preserveLineTerminators(fixer.replaceTextRange(trailing.range, ""));
               const endings = context.sourceCode.getText(comment).replace(/[^\r\n\u2028\u2029]/gu, "");
               if (endings.length > 0) {
                 let start = comment.range[0];
                 while (start > 0 && /[\t ]/u.test(text[start - 1] ?? "")) start--;
-                return fixer.replaceTextRange([start, comment.range[1]], endings);
+                return preserveLineTerminators(fixer.replaceTextRange([start, comment.range[1]], endings));
               }
               const before = text[comment.range[0] - 1] ?? "";
               const after = text[comment.range[1]] ?? "";
               const separator = before.length > 0 && after.length > 0 && !/\s/u.test(before + after) ? " " : "";
-              return fixer.replaceText(comment, separator);
+              return preserveLineTerminators(fixer.replaceText(comment, separator));
             }
           });
         }
@@ -2239,14 +2438,14 @@ var no_test_comments_default = createRule({
 });
 
 // src/rules/no-mutating-container-transform.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var MUTATORS = /* @__PURE__ */ new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"]);
 var PRIMITIVES = /* @__PURE__ */ new Set([
-  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
+  import_utils24.AST_NODE_TYPES.TSStringKeyword,
+  import_utils24.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils24.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils24.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils24.AST_NODE_TYPES.TSSymbolKeyword
 ]);
 var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -2265,27 +2464,27 @@ var NO_MUTATING_CONTAINER_TRANSFORM_DOCUMENTATION = {
   ]
 };
 function arrayElement(node, sourceCode) {
-  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;
+  if (node.type === import_utils24.AST_NODE_TYPES.TSArrayType) return node.elementType;
+  if (node.type === import_utils24.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray") && (import_utils24.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_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];
+  if (annotation?.type === import_utils24.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && annotation.typeName.name === "Promise" && (import_utils24.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_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:
+      case import_utils24.AST_NODE_TYPES.ExpressionStatement:
+      case import_utils24.AST_NODE_TYPES.VariableDeclaration:
+      case import_utils24.AST_NODE_TYPES.ReturnStatement:
+      case import_utils24.AST_NODE_TYPES.ThrowStatement:
+      case import_utils24.AST_NODE_TYPES.EmptyStatement:
         return true;
-      case import_utils22.AST_NODE_TYPES.BlockStatement:
+      case import_utils24.AST_NODE_TYPES.BlockStatement:
         return supported(statement.body);
-      case import_utils22.AST_NODE_TYPES.IfStatement:
+      case import_utils24.AST_NODE_TYPES.IfStatement:
         return supported([statement.consequent]) && (statement.alternate === null || supported([statement.alternate]));
       default:
         return false;
@@ -2306,13 +2505,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_utils22.AST_NODE_TYPES.Identifier ? import_utils22.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
+      return node.type === import_utils24.AST_NODE_TYPES.Identifier ? import_utils24.ASTUtils.findVariable(sourceCode.getScope(node), node.name) : null;
     }
     function inspect(node) {
-      if (node.body?.type !== import_utils22.AST_NODE_TYPES.BlockStatement || !returnsArray(node, sourceCode) || !supported(node.body.body)) return;
+      if (node.body?.type !== import_utils24.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_utils22.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0) continue;
+        if (parameter.type !== import_utils24.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);
@@ -2325,26 +2524,26 @@ var no_mutating_container_transform_default = createRule({
       }
       function expression(current, state) {
         switch (current.type) {
-          case import_utils22.AST_NODE_TYPES.FunctionExpression:
-          case import_utils22.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils22.AST_NODE_TYPES.ClassExpression:
+          case import_utils24.AST_NODE_TYPES.FunctionExpression:
+          case import_utils24.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils24.AST_NODE_TYPES.ClassExpression:
             return;
-          case import_utils22.AST_NODE_TYPES.AssignmentExpression:
+          case import_utils24.AST_NODE_TYPES.AssignmentExpression:
             assignment(current, state);
             return;
-          case import_utils22.AST_NODE_TYPES.LogicalExpression:
+          case import_utils24.AST_NODE_TYPES.LogicalExpression:
             logical(current, state);
             return;
-          case import_utils22.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils24.AST_NODE_TYPES.ConditionalExpression:
             conditional(current, state);
             return;
-          case import_utils22.AST_NODE_TYPES.UpdateExpression:
+          case import_utils24.AST_NODE_TYPES.UpdateExpression:
             write(current.argument, state);
             break;
-          case import_utils22.AST_NODE_TYPES.UnaryExpression:
+          case import_utils24.AST_NODE_TYPES.UnaryExpression:
             if (current.operator === "delete") write(current.argument, state);
             break;
-          case import_utils22.AST_NODE_TYPES.CallExpression:
+          case import_utils24.AST_NODE_TYPES.CallExpression:
             mutationCall(current, state);
             break;
           default:
@@ -2364,13 +2563,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_utils22.AST_NODE_TYPES.Literal && (current.operator === "&&" && !left.value || current.operator === "||" && !!left.value || current.operator === "??" && left.value !== null)) return;
+        if (left.type === import_utils24.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_utils22.AST_NODE_TYPES.Literal) {
+        if (test.type === import_utils24.AST_NODE_TYPES.Literal) {
           expression(test.value ? current.consequent : current.alternate, state);
           return;
         }
@@ -2378,13 +2577,13 @@ var no_mutating_container_transform_default = createRule({
         expression(current.alternate, state);
       }
       function mutationCall(current, state) {
-        if (current.callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils22.ASTUtils.getPropertyName(current.callee) ?? "")) return;
+        if (current.callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression || !MUTATORS.has(import_utils24.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_utils22.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils22.ASTUtils.getPropertyName(target) !== "length") return;
+        if (target.type !== import_utils24.AST_NODE_TYPES.MemberExpression || !target.computed && import_utils24.ASTUtils.getPropertyName(target) !== "length") return;
         const parameter = origin(target.object, state);
         if (parameter !== void 0 && first === null) first = { node: target, parameter };
       }
@@ -2394,18 +2593,18 @@ var no_mutating_container_transform_default = createRule({
       }
       function statement(current, state) {
         switch (current.type) {
-          case import_utils22.AST_NODE_TYPES.BlockStatement:
+          case import_utils24.AST_NODE_TYPES.BlockStatement:
             return statements(current.body, state);
-          case import_utils22.AST_NODE_TYPES.IfStatement:
+          case import_utils24.AST_NODE_TYPES.IfStatement:
             return branch(current, state);
-          case import_utils22.AST_NODE_TYPES.VariableDeclaration:
+          case import_utils24.AST_NODE_TYPES.VariableDeclaration:
             declarations(current, state);
             return false;
-          case import_utils22.AST_NODE_TYPES.ReturnStatement:
-          case import_utils22.AST_NODE_TYPES.ThrowStatement:
+          case import_utils24.AST_NODE_TYPES.ReturnStatement:
+          case import_utils24.AST_NODE_TYPES.ThrowStatement:
             if (current.argument !== null) expression(current.argument, state);
             return true;
-          case import_utils22.AST_NODE_TYPES.ExpressionStatement:
+          case import_utils24.AST_NODE_TYPES.ExpressionStatement:
             expression(current.expression, state);
             return false;
           default:
@@ -2414,7 +2613,7 @@ var no_mutating_container_transform_default = createRule({
       }
       function branch(current, state) {
         expression(current.test, 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);
+        if (current.test.type === import_utils24.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);
@@ -2446,7 +2645,7 @@ var no_mutating_container_transform_default = createRule({
 });
 
 // src/rules/no-redundant-consumer-union.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var import_typescript7 = __toESM(require("typescript"), 1);
 
 // src/rules/_checked-native-source.ts
@@ -2557,109 +2756,13 @@ function finiteMember(member3, checker) {
 }
 
 // src/rules/_private-consumer-fix.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var import_typescript3 = __toESM(require("typescript"), 1);
-
-// src/rules/_type-binding.ts
-var import_utils23 = require("@typescript-eslint/utils");
-function typeBinding(source, identifier) {
-  let scope = source.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== void 0 && (variable.isTypeVariable || variable.defs.some((definition) => definition.isTypeDefinition))) {
-      return variable;
-    }
-    scope = scope.upper;
-  }
-  return null;
-}
-var REFERENCE_INDEXES = /* @__PURE__ */ new WeakMap();
-function retainsNamedTypeUses(source, removed) {
-  const manager = source.scopeManager;
-  if (manager === null) return false;
-  const index = referenceIndex(source, manager);
-  for (const reference of referencesWithin(index.references, removed)) {
-    if (!reference.isRead()) continue;
-    const binding3 = reference.resolved;
-    if (!binding3 || !reference.isTypeReference && !reference.isValueReference) return false;
-    if (binding3.defs.length === 0) continue;
-    const reads = publicReadExtents(index, binding3);
-    const extent = reference.isTypeReference ? reference.isValueReference ? reads.both : reads.type : reads.value;
-    if (extent === null || extent.minStart >= removed.range[0] && extent.maxEnd <= removed.range[1]) return false;
-  }
-  return true;
-}
-function referenceIndex(source, manager) {
-  const cached = REFERENCE_INDEXES.get(source);
-  if (cached?.manager === manager) return cached;
-  const references = manager.scopes.flatMap((scope) => scope.references);
-  references.sort((left, right) => left.identifier.range[0] - right.identifier.range[0]);
-  const index = { manager, references, publicReads: /* @__PURE__ */ new Map() };
-  REFERENCE_INDEXES.set(source, index);
-  return index;
-}
-function* referencesWithin(references, removed) {
-  let low = 0;
-  let high = references.length;
-  while (low < high) {
-    const middle = low + Math.floor((high - low) / 2);
-    const reference = references[middle];
-    if (reference === void 0 || reference.identifier.range[0] >= removed.range[0]) high = middle;
-    else low = middle + 1;
-  }
-  for (let index = low; index < references.length; index++) {
-    const reference = references[index];
-    if (reference === void 0) continue;
-    if (reference.identifier.range[0] > removed.range[1]) break;
-    if (insideTypeRange(reference.identifier, removed)) yield reference;
-  }
-}
-function publicReadExtents(index, binding3) {
-  const cached = index.publicReads.get(binding3);
-  if (cached !== void 0) return cached;
-  let type = null;
-  let value = null;
-  let both = null;
-  for (const retained of binding3.references) {
-    if (!retained.isRead() || !retained.isTypeReference && !retained.isValueReference || binding3.defs.some((definition) => insideTypeRange(retained.identifier, definition.node)) || !publicTypeUse(retained.identifier)) continue;
-    if (retained.isTypeReference) type = extendExtent(type, retained.identifier);
-    if (retained.isValueReference) value = extendExtent(value, retained.identifier);
-    if (retained.isTypeReference && retained.isValueReference) both = extendExtent(both, retained.identifier);
-  }
-  const result = { type, value, both };
-  index.publicReads.set(binding3, result);
-  return result;
-}
-function extendExtent(extent, identifier) {
-  return {
-    minStart: Math.min(extent?.minStart ?? identifier.range[0], identifier.range[0]),
-    maxEnd: Math.max(extent?.maxEnd ?? identifier.range[1], identifier.range[1])
-  };
-}
-function publicTypeUse(identifier) {
-  let node = identifier;
-  while (node.parent) {
-    if (node.type === import_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_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;
-  }
-  return false;
-}
-function insideTypeRange(node, range) {
-  return node.range[0] >= range.range[0] && node.range[1] <= range.range[1];
-}
-
-// src/rules/_private-consumer-fix.ts
 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_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 owner = node.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration ? node : node.parent;
+  if (owner.type !== import_utils25.AST_NODE_TYPES.FunctionDeclaration && owner.type !== import_utils25.AST_NODE_TYPES.VariableDeclarator) return false;
   const binding3 = sourceCode.getDeclaredVariables(owner).find((variable) => variable.defs.some((definition) => definition.node === owner && (definition.type === "FunctionName" || definition.type === "Variable")));
   if (!binding3) return false;
   const declaration = services.esTreeNodeToTSNodeMap.get(node);
@@ -2695,7 +2798,7 @@ function validConsumerFixCalls(node, parameter, sourceCode, services) {
       continue;
     }
     const call = reference.identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils24.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== declaration.parameters.length || !call.arguments.every((argument) => argument.type === import_utils24.AST_NODE_TYPES.Identifier) || !validArguments(call)) return false;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils25.AST_NODE_TYPES.CallExpression || call.callee !== reference.identifier || call.optional || call.typeArguments || call.arguments.length !== declaration.parameters.length || !call.arguments.every((argument) => argument.type === import_utils25.AST_NODE_TYPES.Identifier) || !validArguments(call)) return false;
     calls += 1;
   }
   return calls > 0;
@@ -2747,7 +2850,7 @@ function minimalConsumerFix(sourceCode, annotation, removed) {
 }
 
 // src/rules/_private-scalar-consumer.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var import_typescript6 = __toESM(require("typescript"), 1);
 
 // src/rules/_scalar-parameter-view.ts
@@ -2897,8 +3000,8 @@ function intrinsicAttribute(attribute, view) {
 // src/rules/_private-scalar-consumer.ts
 function directEval(node) {
   let callee = unwrapExpression(node.callee);
-  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";
+  while (callee.type === import_utils26.AST_NODE_TYPES.TSInstantiationExpression) callee = unwrapExpression(callee.expression);
+  return callee.type === import_utils26.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);
@@ -2911,16 +3014,16 @@ function consumerAnnotation(node, auxiliaryScalars = false) {
     if (!auxiliaryScalars) return void 0;
     let annotation;
     for (const parameter2 of node.params) {
-      if (parameter2.type !== import_utils25.AST_NODE_TYPES.Identifier && parameter2.type !== import_utils25.AST_NODE_TYPES.ObjectPattern) continue;
+      if (parameter2.type !== import_utils26.AST_NODE_TYPES.Identifier && parameter2.type !== import_utils26.AST_NODE_TYPES.ObjectPattern) continue;
       const current = parameter2.typeAnnotation?.typeAnnotation;
-      if (current?.type !== import_utils25.AST_NODE_TYPES.TSTypeLiteral) continue;
+      if (current?.type !== import_utils26.AST_NODE_TYPES.TSTypeLiteral) continue;
       if (annotation) return void 0;
       annotation = current;
     }
     return annotation;
   }
   const parameter = node.params[0];
-  return parameter?.type === import_utils25.AST_NODE_TYPES.Identifier || parameter?.type === import_utils25.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
+  return parameter?.type === import_utils26.AST_NODE_TYPES.Identifier || parameter?.type === import_utils26.AST_NODE_TYPES.ObjectPattern ? parameter.typeAnnotation?.typeAnnotation : void 0;
 }
 function exportedSymbols(source, checker) {
   const symbol = checker.getSymbolAtLocation(source);
@@ -2970,12 +3073,12 @@ function auxiliaryBindings(native, selected, checker) {
   return bindings;
 }
 function callableBinding(node, sourceCode) {
-  if (node.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration) {
-    if (node.parent.type !== import_utils25.AST_NODE_TYPES.Program) return void 0;
+  if (node.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.parent.type !== import_utils26.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_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;
+  if (declaration.type !== import_utils26.AST_NODE_TYPES.VariableDeclarator || declaration.init !== node || declaration.id.type !== import_utils26.AST_NODE_TYPES.Identifier || declaration.id.typeAnnotation || declaration.parent.kind !== "const" || declaration.parent.parent.type !== import_utils26.AST_NODE_TYPES.Program) return void 0;
   return sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
 }
 function directCalls(binding3, arity) {
@@ -2983,7 +3086,7 @@ function directCalls(binding3, arity) {
   const stable2 = stableValueBinding(binding3, (reference) => {
     const identifier = reference.identifier;
     const call = identifier.parent;
-    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils25.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== arity || !call.arguments.every((argument) => argument.type === import_utils25.AST_NODE_TYPES.Identifier)) return false;
+    if (reference.isTypeReference || !reference.isReadOnly() || call.type !== import_utils26.AST_NODE_TYPES.CallExpression || call.callee !== identifier || call.optional || call.typeArguments || call.arguments.length !== arity || !call.arguments.every((argument) => argument.type === import_utils26.AST_NODE_TYPES.Identifier)) return false;
     calls += 1;
     return true;
   });
@@ -2995,6 +3098,8 @@ var CONFIG = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true
 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 SCALAR_HELPER_EXAMPLE = EXAMPLE.replace("return value.name;", "return formatName(value.name);").replace("function label", "function formatName(value: string): string {return '[' + value + ']';} function label");
+var WHOLE_OBJECT_HELPER_EXAMPLE = EXAMPLE.replace("return value.name;", "return formatAnimal(value);").replace("function label", "function formatAnimal(value: Animal): string {return value.name;} function label");
 var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Keep the covering object contract in a private scalar consumer union.",
@@ -3004,12 +3109,15 @@ var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
   autofix: "safe",
   limitations: [
     "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.",
+    "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 supported 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.",
+    "Scalar values may pass through one implemented same-file top-level function or raw const-arrow helper with an explicit scalar return annotation and the exact native resolved signature. Every argument must already satisfy the scalar read view; the containing source must pass the existing native checked-source proof. Imported, ambient, aliased, overloaded, generic or contextually typed helpers, member calls, optional calls, spread arguments and whole-object arguments remain unsupported. Helper permission does not add auxiliary consumer parameters or replace the required object-field read anchor. Helper bodies need not be pure because no call or body is rewritten.",
     "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 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."
+    "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, unproved helper calls, closures, reflection, serialization, dynamic reads, implicit Object capabilities and JSX prevent findings. Imported Python protocol assignability is not approximated by this rule."
   ],
   examples: [
+    { id: "local-scalar-helper", scenarioId: "local-scalar-helper", title: "A local helper receives only the required name", outcome: "match", files: [{ path: "src/case.ts", source: SCALAR_HELPER_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: SCALAR_HELPER_EXAMPLE.replace("Dog | Animal", "Animal") }] },
+    { id: "whole-object-helper", scenarioId: "local-scalar-helper", title: "Passing the whole object remains outside the scalar helper proof", outcome: "no-match", files: [{ path: "src/case.ts", source: WHOLE_OBJECT_HELPER_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
     { 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") }] },
@@ -3043,13 +3151,13 @@ function localContractBindings(roots, source, services) {
 }
 function localContractReferences(node, source, services) {
   switch (node.type) {
-    case import_utils26.AST_NODE_TYPES.TSTypeLiteral:
+    case import_utils27.AST_NODE_TYPES.TSTypeLiteral:
       return [];
-    case import_utils26.AST_NODE_TYPES.TSIntersectionType:
+    case import_utils27.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:
+    case import_utils27.AST_NODE_TYPES.TSTypeReference:
+      return !node.typeArguments && node.typeName.type === import_utils27.AST_NODE_TYPES.Identifier ? [node.typeName] : null;
+    case import_utils27.AST_NODE_TYPES.Identifier:
       return localBindingReferences(node, source, services);
     default:
       return null;
@@ -3059,8 +3167,8 @@ 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 (definitions2.length === 1 && first?.type === import_utils27.AST_NODE_TYPES.TSTypeAliasDeclaration && !first.typeParameters) return [first.typeAnnotation];
+  const interfaces = definitions2.filter((definition) => definition.type === import_utils27.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();
@@ -3068,13 +3176,13 @@ function localBindingReferences(identifier, source, services) {
     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;
+  return bases.every((base) => base.type === import_utils27.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;
+  if (parent?.type === import_utils27.AST_NODE_TYPES.Program) return true;
+  if (parent?.type !== import_utils27.AST_NODE_TYPES.ExportNamedDeclaration && parent?.type !== import_utils27.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  return parent.parent.type === import_utils27.AST_NODE_TYPES.Program;
 }
 function coveringAlternative(leftNode, rightNode, checker, fieldsOf, reads) {
   const left = checker.getTypeFromTypeNode(leftNode);
@@ -3109,7 +3217,7 @@ var no_redundant_consumer_union_default = createRule({
     let dynamic = false;
     const remember = (node) => {
       const annotation = consumerAnnotation(node);
-      if (annotation?.type === import_utils26.AST_NODE_TYPES.TSUnionType && annotation.types.length === 2) candidates.push(node);
+      if (annotation?.type === import_utils27.AST_NODE_TYPES.TSUnionType && annotation.types.length === 2) candidates.push(node);
     };
     return {
       FunctionDeclaration: remember,
@@ -3119,7 +3227,7 @@ var no_redundant_consumer_union_default = createRule({
       },
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
-        const services = import_utils26.ESLintUtils.getParserServices(context);
+        const services = import_utils27.ESLintUtils.getParserServices(context);
         const source = currentNativeSource(context.sourceCode, services);
         if (!source) return;
         const checker = services.program.getTypeChecker();
@@ -3134,7 +3242,7 @@ var no_redundant_consumer_union_default = createRule({
           return surfaces.get(type) ?? null;
         };
         for (const candidate2 of candidates) {
-          const consumer = privateScalarConsumer(candidate2, context.sourceCode, services, exports2);
+          const consumer = privateScalarConsumer(candidate2, context.sourceCode, services, exports2, { scalarCalls: true });
           const annotation = consumer?.parameter.type;
           if (!consumer || !annotation || !import_typescript7.default.isUnionTypeNode(annotation) || annotation.types.length !== 2) continue;
           const leftNode = annotation.types[0];
@@ -3143,7 +3251,7 @@ var no_redundant_consumer_union_default = createRule({
           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;
+          if (coverage.mutual && (reportNode.type !== import_utils27.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,
@@ -3161,7 +3269,7 @@ var no_redundant_consumer_union_default = createRule({
 });
 
 // src/rules/prefer-minimal-parameter-contract.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils28 = 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);';
@@ -3218,7 +3326,7 @@ var prefer_minimal_parameter_contract_default = createRule({
     const candidates = [];
     let dynamic = false;
     const remember = (node) => {
-      if (consumerAnnotation(node, true)?.type === import_utils27.AST_NODE_TYPES.TSTypeLiteral) candidates.push(node);
+      if (consumerAnnotation(node, true)?.type === import_utils28.AST_NODE_TYPES.TSTypeLiteral) candidates.push(node);
     };
     return {
       FunctionDeclaration: remember,
@@ -3228,7 +3336,7 @@ var prefer_minimal_parameter_contract_default = createRule({
       },
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
-        const services = import_utils27.ESLintUtils.getParserServices(context);
+        const services = import_utils28.ESLintUtils.getParserServices(context);
         const source = currentNativeSource(context.sourceCode, services);
         if (!source) return;
         const checker = services.program.getTypeChecker();
@@ -3252,7 +3360,7 @@ var prefer_minimal_parameter_contract_default = createRule({
 });
 
 // src/rules/no-excess-jsx-props.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 var import_typescript10 = __toESM(require("typescript"), 1);
 
 // src/rules/_ordinary-object-effects.ts
@@ -3594,11 +3702,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_utils28.AST_NODE_TYPES.Property || property.kind !== "init") return null;
+    if (property.type !== import_utils29.AST_NODE_TYPES.Property || property.kind !== "init") return null;
     const key = property.key;
     let name;
-    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);
+    if (!property.computed && key.type === import_utils29.AST_NODE_TYPES.Identifier) name = key.name;
+    else if (key.type === import_utils29.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);
@@ -3710,35 +3818,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_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;
+  if (declaration.type !== import_utils29.AST_NODE_TYPES.VariableDeclarator || declaration.parent.kind !== "const" || declaration.id.type !== import_utils29.AST_NODE_TYPES.Identifier || literal2.type !== import_utils29.AST_NODE_TYPES.ObjectExpression || declaration.parent.parent.type === import_utils29.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_utils28.AST_NODE_TYPES.MemberExpression && member3.object === reference.identifier && readonlyFieldValue(member3, fields2);
+    return member3.type === import_utils29.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_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;
+  return !member3.computed && property.type === import_utils29.AST_NODE_TYPES.Identifier ? property.name : property.type === import_utils29.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_utils28.AST_NODE_TYPES.Property && parent.value === member3 && parent.parent.type === import_utils28.AST_NODE_TYPES.ObjectExpression) {
+  if (parent.type === import_utils29.AST_NODE_TYPES.Property && parent.value === member3 && parent.parent.type === import_utils29.AST_NODE_TYPES.ObjectExpression) {
     const object = parent.parent;
     const owner = object.parent;
-    return owner.type === import_utils28.AST_NODE_TYPES.JSXSpreadAttribute && owner.argument === object || owner.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && owner.init === object;
+    return owner.type === import_utils29.AST_NODE_TYPES.JSXSpreadAttribute && owner.argument === object || owner.type === import_utils29.AST_NODE_TYPES.VariableDeclarator && owner.init === object;
   }
-  return parent.type === import_utils28.AST_NODE_TYPES.JSXExpressionContainer && parent.expression === member3 || parent.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && parent.init === member3;
+  return parent.type === import_utils29.AST_NODE_TYPES.JSXExpressionContainer && parent.expression === member3 || parent.type === import_utils29.AST_NODE_TYPES.VariableDeclarator && parent.init === member3;
 }
 function privateElementDeclaration(opening) {
   const value = outerExpression(opening.parent);
   const declaration = value.parent;
-  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;
+  return declaration.type === import_utils29.AST_NODE_TYPES.VariableDeclarator && declaration.init === value && declaration.id.type === import_utils29.AST_NODE_TYPES.Identifier && declaration.parent.kind === "const" && declaration.parent.parent.type !== import_utils29.AST_NODE_TYPES.ExportNamedDeclaration ? declaration : null;
 }
 function closedElementValue(opening, declaration, fields2, reads, proof) {
   if (!closedInvocation(opening, proof) || !constInitializer(proof.services.esTreeNodeToTSNodeMap.get(declaration))) return false;
@@ -3764,10 +3872,10 @@ function closedInvocation(node, proof) {
 }
 function independentInvocation(scope, proof) {
   const block = scope.block;
-  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.type !== import_utils29.AST_NODE_TYPES.ArrowFunctionExpression && block.type !== import_utils29.AST_NODE_TYPES.FunctionDeclaration && block.type !== import_utils29.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_utils28.AST_NODE_TYPES.Identifier || parameter.name === "this") return false;
+    if (parameter.type !== import_utils29.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;
   }
@@ -3775,16 +3883,16 @@ function independentInvocation(scope, proof) {
     if (typeOnlyReference(reference)) return true;
     const value = outerExpression(reference.identifier);
     const parent = value.parent;
-    const read = parent?.type === import_utils28.AST_NODE_TYPES.MemberExpression && parent.object === value ? parent : value;
+    const read = parent?.type === import_utils29.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_utils28.AST_NODE_TYPES.MemberExpression || props.object !== identifier || props.optional || staticMemberKey(props) !== "props") return false;
+  if (!props || props.type !== import_utils29.AST_NODE_TYPES.MemberExpression || props.object !== identifier || props.optional || staticMemberKey(props) !== "props") return false;
   const member3 = props.parent;
-  if (member3.type !== import_utils28.AST_NODE_TYPES.MemberExpression || member3.object !== props || member3.optional) return false;
+  if (member3.type !== import_utils29.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);
 }
@@ -3812,7 +3920,7 @@ var no_excess_jsx_props_default = createRule({
     const evaluate = (node, declaration, fields2) => {
       const keys = [...fields2.keys()];
       const opening = node.parent;
-      services ??= import_utils28.ESLintUtils.getParserServices(context);
+      services ??= import_utils29.ESLintUtils.getParserServices(context);
       standardJSX ??= supportedJSX(services.program.getCompilerOptions(), context.sourceCode.getAllComments());
       if (!standardJSX) return;
       const checker = services.program.getTypeChecker();
@@ -3844,9 +3952,9 @@ var no_excess_jsx_props_default = createRule({
     };
     return {
       JSXSpreadAttribute(node) {
-        if (node.argument.type !== import_utils28.AST_NODE_TYPES.ObjectExpression) return;
+        if (node.argument.type !== import_utils29.AST_NODE_TYPES.ObjectExpression) return;
         const opening = node.parent;
-        if (!opening.selfClosing || opening.attributes.length !== 1 || opening.name.type !== import_utils28.AST_NODE_TYPES.JSXIdentifier || /^[a-z]/u.test(opening.name.name)) return;
+        if (!opening.selfClosing || opening.attributes.length !== 1 || opening.name.type !== import_utils29.AST_NODE_TYPES.JSXIdentifier || /^[a-z]/u.test(opening.name.name)) return;
         const declaration = privateElementDeclaration(opening);
         if (!declaration) return;
         const fields2 = literalFields(node.argument);
@@ -3858,7 +3966,7 @@ var no_excess_jsx_props_default = createRule({
       },
       "Program:exit"() {
         if (!candidates.length || dynamic) return;
-        services = import_utils28.ESLintUtils.getParserServices(context);
+        services = import_utils29.ESLintUtils.getParserServices(context);
         if (!currentNativeSource(context.sourceCode, services)) return;
         for (const { node, declaration, fields: fields2 } of candidates) evaluate(node, declaration, fields2);
       }
@@ -3867,7 +3975,7 @@ var no_excess_jsx_props_default = createRule({
 });
 
 // src/rules/prefer-native-fetch-in-server-actions.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 var KY_MODULE = /^ky(?:\/.*)?$/u;
 var PREFER_NATIVE_FETCH_IN_SERVER_ACTIONS_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -3931,19 +4039,19 @@ var prefer_native_fetch_in_server_actions_default = createRule({
 });
 function hasUseServerDirective(program) {
   for (const statement of program.body) {
-    if (statement.type !== import_utils29.AST_NODE_TYPES.ExpressionStatement || statement.directive === void 0) return false;
+    if (statement.type !== import_utils30.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_utils29.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
+    (specifier) => specifier.type === import_utils30.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
   );
 }
 
 // src/rules/no-credential-in-browser-storage.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 
 // src/rules/_secret-names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -4148,7 +4256,7 @@ var no_credential_in_browser_storage_default = createRule({
     return {
       CallExpression(node) {
         const callee = unwrapExpression(node.callee);
-        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)) {
+        if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || callee.property.name !== "setItem" || !isStorage(sourceCode, callee.object)) {
           return;
         }
         const [key] = node.arguments;
@@ -4156,12 +4264,12 @@ var no_credential_in_browser_storage_default = createRule({
       },
       AssignmentExpression(node) {
         const target = node.left;
-        if (target.type !== import_utils30.AST_NODE_TYPES.MemberExpression) return;
+        if (target.type !== import_utils31.AST_NODE_TYPES.MemberExpression) return;
         if (isStorage(sourceCode, target.object)) {
           report2(node, storedPropertyKey(sourceCode, target));
           return;
         }
-        if (!target.computed && target.property.type === import_utils30.AST_NODE_TYPES.Identifier && target.property.name === "cookie" && globalMemberName(sourceCode, target.object) === "document") {
+        if (!target.computed && target.property.type === import_utils31.AST_NODE_TYPES.Identifier && target.property.name === "cookie" && globalMemberName(sourceCode, target.object) === "document") {
           report2(node, cookieName(node.right));
         }
       }
@@ -4174,34 +4282,34 @@ function isStorage(sourceCode, node) {
 }
 function globalMemberName(sourceCode, node) {
   const value = unwrapExpression(node);
-  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)) {
+  if (value.type === import_utils31.AST_NODE_TYPES.Identifier) return isUnshadowed(sourceCode, value) ? value.name : null;
+  if (value.type === import_utils31.AST_NODE_TYPES.MemberExpression && !value.computed && value.object.type === import_utils31.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(value.object.name) && value.property.type === import_utils31.AST_NODE_TYPES.Identifier && isUnshadowed(sourceCode, value.object)) {
     return value.property.name;
   }
   return null;
 }
 function isUnshadowed(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 storedPropertyKey(sourceCode, target) {
-  if (!target.computed) return target.property.type === import_utils30.AST_NODE_TYPES.Identifier ? target.property.name : null;
+  if (!target.computed) return target.property.type === import_utils31.AST_NODE_TYPES.Identifier ? target.property.name : null;
   return scopedStaticString(target.property, sourceCode);
 }
 function cookieName(value) {
   let expression = unwrapExpression(value);
-  while (expression.type === import_utils30.AST_NODE_TYPES.BinaryExpression && expression.operator === "+") {
+  while (expression.type === import_utils31.AST_NODE_TYPES.BinaryExpression && expression.operator === "+") {
     expression = unwrapExpression(expression.left);
   }
   let text = 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 (expression.type === import_utils31.AST_NODE_TYPES.Literal && typeof expression.value === "string") text = expression.value;
+  if (expression.type === import_utils31.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_utils31 = require("@typescript-eslint/utils");
+var import_utils32 = 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"]);
@@ -4258,7 +4366,7 @@ var no_numeric_search_param_coercion_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text) || isTestFile(context)) return {};
     let services;
     try {
-      services = import_utils31.ESLintUtils.getParserServices(context);
+      services = import_utils32.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -4280,27 +4388,27 @@ var no_numeric_search_param_coercion_default = createRule({
   }
 });
 function isNumericParser(sourceCode, callee) {
-  if (callee.type === import_utils31.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils32.AST_NODE_TYPES.Identifier) {
     return GLOBAL_PARSERS.has(callee.name) && isUnshadowedGlobal(sourceCode, callee);
   }
-  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);
+  return callee.type === import_utils32.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils32.AST_NODE_TYPES.Identifier && callee.object.name === "Number" && callee.property.type === import_utils32.AST_NODE_TYPES.Identifier && NUMBER_PARSERS.has(callee.property.name) && isUnshadowedGlobal(sourceCode, callee.object);
 }
 function isUnshadowedGlobal(sourceCode, node) {
-  const variable = import_utils31.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
+  const variable = import_utils32.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_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") {
+  if (value.type === import_utils32.AST_NODE_TYPES.AwaitExpression) value = unwrapExpression(value.argument);
+  if (value.type === import_utils32.AST_NODE_TYPES.LogicalExpression && value.operator === "??") value = unwrapExpression(value.left);
+  if (value.type === import_utils32.AST_NODE_TYPES.ChainExpression) value = value.expression;
+  if (value.type !== import_utils32.AST_NODE_TYPES.CallExpression || value.callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || value.callee.computed || value.callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier || value.callee.property.name !== "get") {
     return null;
   }
   return value;
 }
 function isSearchParamReceiver(call, services) {
-  if (call.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression) return false;
+  if (call.callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression) return false;
   const checker = services.program.getTypeChecker();
   const type = checker.getNonNullableType(
     checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(call.callee.object))
@@ -4312,7 +4420,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.38.55",
+  version: "16.39.1",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -4400,6 +4508,7 @@ var package_default = {
     "eslint-plugin-zod": "^5.2.2",
     globals: "17.13.0",
     jiti: "2.7.0",
+    prettier: "3.9.10",
     tsup: "9.0.0",
     typescript: "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "^8.72.0",
@@ -4434,11 +4543,11 @@ var package_default = {
 };
 
 // src/rules/require-explicit-contract-implementation.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 var ts12 = __toESM(require("typescript"), 1);
 
 // src/rules/_closed-nominal-inheritance-fix.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 var import_typescript11 = __toESM(require("typescript"), 1);
 function closedNominalInheritanceFix(sourceCode, call, consumer, implementation, contract) {
   const source = call.getSourceFile();
@@ -4512,7 +4621,7 @@ function exactRejection(sourceCode, statement) {
   const identifier = sourceCode.getNodeByRangeIndex(
     rejected.expression.expression.getStart()
   );
-  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;
+  return identifier?.type === import_utils33.AST_NODE_TYPES.Identifier && identifier.name === "TypeError" && (import_utils33.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)
@@ -4878,7 +4987,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_utils33.ESLintUtils.getParserServices(context);
+    const services = import_utils34.ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
     function inspect(node) {
       const tsNode = services.esTreeNodeToTSNodeMap.get(node);
@@ -4893,7 +5002,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_utils33.AST_NODE_TYPES.NewExpression) continue;
+        if (argument.type !== import_utils34.AST_NODE_TYPES.NewExpression) continue;
         const parameter = parameters[index];
         if (parameter === void 0) continue;
         const tsArgument = services.esTreeNodeToTSNodeMap.get(argument);
@@ -4940,18 +5049,18 @@ var require_explicit_contract_implementation_default = createRule({
 });
 
 // src/rules/require-explicit-service-contract.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 
 // src/rules/_existing-factory-contract-fix.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = 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_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))
+  const contract = contractStatement?.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? contractStatement.declaration : null;
+  const implementation = classStatement?.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? classStatement.declaration : classStatement;
+  const factory = factoryStatement?.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? factoryStatement.declaration : null;
+  if (contract?.type !== import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration || worker?.type !== import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration || implementation?.type !== import_utils35.AST_NODE_TYPES.ClassDeclaration || implementation !== candidate2 || !ordinaryClass(implementation) || !ordinaryFactory(factory))
     return null;
   const operation2 = contractOperation(contract);
   if (operation2 === null || interfaceOperation(worker) !== operation2)
@@ -4970,17 +5079,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_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;
+  return node?.type === import_utils35.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_utils34.AST_NODE_TYPES.TSTypeLiteral ? singletonOperation(node.typeAnnotation.members) : null;
+  return !node.declare && node.typeParameters === void 0 && node.typeAnnotation.type === import_utils35.AST_NODE_TYPES.TSTypeLiteral ? singletonOperation(node.typeAnnotation.members) : null;
 }
 function singletonOperation(members) {
   const member3 = members[0];
-  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;
+  return members.length === 1 && member3?.type === import_utils35.AST_NODE_TYPES.TSMethodSignature && member3.kind === "method" && !member3.computed && !member3.optional && member3.key.type === import_utils35.AST_NODE_TYPES.Identifier && member3.params.length === 0 && member3.typeParameters === void 0 && member3.returnType?.typeAnnotation.type === import_utils35.AST_NODE_TYPES.TSVoidKeyword ? member3.key.name : null;
 }
 function uniqueDeclarations(sourceCode, declarations) {
   const names = declarations.flatMap(
@@ -4991,7 +5100,7 @@ function uniqueDeclarations(sourceCode, declarations) {
   );
 }
 function sameBinding(sourceCode, reference, declaration) {
-  const binding3 = import_utils34.ASTUtils.findVariable(
+  const binding3 = import_utils35.ASTUtils.findVariable(
     sourceCode.getScope(reference),
     reference.name
   );
@@ -4999,45 +5108,45 @@ function sameBinding(sourceCode, reference, declaration) {
 }
 function retainedWorker(sourceCode, implementation, worker) {
   const constructor = implementation.body.body[0];
-  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)
+  if (constructor?.type !== import_utils35.AST_NODE_TYPES.MethodDefinition || constructor.value.type !== import_utils35.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_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))
+  if (property?.type !== import_utils35.AST_NODE_TYPES.TSParameterProperty || property.accessibility !== "private" || !property.readonly || property.override || property.decorators.length !== 0 || property.parameter.type !== import_utils35.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_utils34.AST_NODE_TYPES.TSTypeReference && type.typeArguments === void 0 && type.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && sameBinding(sourceCode, type.typeName, declaration);
+  return type?.type === import_utils35.AST_NODE_TYPES.TSTypeReference && type.typeArguments === void 0 && type.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && sameBinding(sourceCode, type.typeName, declaration);
 }
 function forwardsOperation(implementation, field, operation2) {
   const method = implementation.body.body[1];
-  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)
+  if (method?.type !== import_utils35.AST_NODE_TYPES.MethodDefinition || method.kind !== "method" || method.value.type !== import_utils35.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_utils35.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_utils35.AST_NODE_TYPES.TSVoidKeyword)
     return false;
   const statement = method.value.body.body[0];
-  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);
+  const call = statement?.type === import_utils35.AST_NODE_TYPES.ExpressionStatement ? statement.expression : null;
+  return call?.type === import_utils35.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_utils34.AST_NODE_TYPES.MemberExpression || node.computed || node.optional || node.property.type !== import_utils34.AST_NODE_TYPES.Identifier || node.property.name !== operation2)
+  if (node.type !== import_utils35.AST_NODE_TYPES.MemberExpression || node.computed || node.optional || node.property.type !== import_utils35.AST_NODE_TYPES.Identifier || node.property.name !== operation2)
     return false;
   const receiver = node.object;
-  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;
+  return receiver.type === import_utils35.AST_NODE_TYPES.MemberExpression && !receiver.computed && !receiver.optional && receiver.object.type === import_utils35.AST_NODE_TYPES.ThisExpression && receiver.property.type === import_utils35.AST_NODE_TYPES.Identifier && receiver.property.name === field;
 }
 function factoryAuthority(sourceCode, factory, contract, worker, implementation) {
   const parameter = factory.params[0];
-  if (parameter?.type !== import_utils34.AST_NODE_TYPES.Identifier || parameter.optional || !typeReference(sourceCode, parameter.typeAnnotation, worker) || !typeReference(sourceCode, factory.returnType, contract))
+  if (parameter?.type !== import_utils35.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_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)
+  const constructed = statement?.type === import_utils35.AST_NODE_TYPES.ReturnStatement ? statement.argument : null;
+  if (constructed?.type !== import_utils35.AST_NODE_TYPES.NewExpression || constructed.typeArguments !== void 0 || constructed.callee.type !== import_utils35.AST_NODE_TYPES.Identifier || !sameBinding(sourceCode, constructed.callee, implementation) || constructed.arguments.length !== 1)
     return false;
   const argument = constructed.arguments[0];
-  return argument?.type === import_utils34.AST_NODE_TYPES.Identifier && argument.name === parameter.name && sameBinding(sourceCode, argument, factory);
+  return argument?.type === import_utils35.AST_NODE_TYPES.Identifier && argument.name === parameter.name && sameBinding(sourceCode, argument, factory);
 }
 
 // src/rules/require-port-for-service.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils36 = 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.",
@@ -5121,50 +5230,50 @@ var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
   "||="
 ]);
 var staticMemberName = (member3) => {
-  if (member3.property.type === import_utils35.AST_NODE_TYPES.PrivateIdentifier)
+  if (member3.property.type === import_utils36.AST_NODE_TYPES.PrivateIdentifier)
     return `#${member3.property.name}`;
-  return import_utils35.ASTUtils.getPropertyName(member3);
+  return import_utils36.ASTUtils.getPropertyName(member3);
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils36.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_utils35.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils35.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils36.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils36.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils35.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils35.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils36.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils36.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-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 isExportedClass = (node, detached) => node.parent.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils36.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_utils35.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils36.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member3) => member3.type !== import_utils35.AST_NODE_TYPES.TSUndefinedKeyword && member3.type !== import_utils35.AST_NODE_TYPES.TSNullKeyword
+      (member3) => member3.type !== import_utils36.AST_NODE_TYPES.TSUndefinedKeyword && member3.type !== import_utils36.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils35.AST_NODE_TYPES.TSTypeReference)
+  if (annotation === void 0 || annotation.type !== import_utils36.AST_NODE_TYPES.TSTypeReference)
     return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils35.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils35.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils36.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils36.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_utils35.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils35.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils36.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils36.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_utils35.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member3.computed || member3.key.type !== import_utils35.AST_NODE_TYPES.Identifier)
+    if (member3.type !== import_utils36.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member3.computed || member3.key.type !== import_utils36.AST_NODE_TYPES.Identifier)
       continue;
     const reference = readTypeReference(member3.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
@@ -5176,18 +5285,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = localFunctionAliases(program);
   function collectDeclaredType(statement) {
-    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils36.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(
         declaration.id.name,
         propertySignatureTypes(declaration.body.body)
       );
       return;
     }
-    if (declaration?.type !== import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) return;
+    if (declaration?.type !== import_utils36.AST_NODE_TYPES.TSTypeAliasDeclaration) return;
     const aliased = declaration.typeAnnotation;
-    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
+    const literals = aliased.type === import_utils36.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils36.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter(
+      (part) => part.type === import_utils36.AST_NODE_TYPES.TSTypeLiteral
     ) : [];
     if (literals.length === 0) return;
     const merged = /* @__PURE__ */ new Map();
@@ -5207,12 +5316,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_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type !== import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type !== import_utils36.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const annotation = declaration.typeAnnotation;
-    if (annotation.type === import_utils35.AST_NODE_TYPES.TSFunctionType || annotation.type === import_utils35.AST_NODE_TYPES.TSConstructorType)
+    if (annotation.type === import_utils36.AST_NODE_TYPES.TSFunctionType || annotation.type === import_utils36.AST_NODE_TYPES.TSConstructorType)
       names.add(declaration.id.name);
-    if (annotation.type === import_utils35.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils35.AST_NODE_TYPES.Identifier)
+    if (annotation.type === import_utils36.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils36.AST_NODE_TYPES.Identifier)
       parents.set(declaration.id.name, annotation.typeName.name);
   }
   for (let pass = 0; pass < parents.size; pass += 1) {
@@ -5248,32 +5357,32 @@ var readConstructor = (ctor, declared, typeParameters) => {
   function scanStoredFields(body4) {
     const pending = [...body4.body];
     function recordStoredField(current) {
-      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)
+      if (current.type === import_utils36.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils36.AST_NODE_TYPES.FunctionExpression || current.type === import_utils36.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils36.AST_NODE_TYPES.ClassExpression || current.type === import_utils36.AST_NODE_TYPES.ClassDeclaration)
         return;
-      if (current.type === import_utils35.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils35.AST_NODE_TYPES.Identifier)
+      if (current.type === import_utils36.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils36.AST_NODE_TYPES.Identifier)
         localBindings2.add(current.id.name);
-      const expression = current.type === import_utils35.AST_NODE_TYPES.AssignmentExpression ? current : null;
+      const expression = current.type === import_utils36.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_utils35.AST_NODE_TYPES.ExpressionStatement || expression.parent.parent !== body4)
+        if (expression?.operator !== "=" || expression.parent.type !== import_utils36.AST_NODE_TYPES.ExpressionStatement || expression.parent.parent !== body4)
           unstableFieldNames.add(storedField);
       }
-      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) {
+      if (expression?.type !== import_utils36.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils36.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils36.AST_NODE_TYPES.ThisExpression || storedField === null) {
         enqueueChildren(current);
         return;
       }
       const source = unwrapExpression(expression.right);
-      if (source.type === import_utils35.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils36.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
         constructedFieldNames.add(storedField);
-      } else if (source.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils36.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_utils35.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils36.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils36.AST_NODE_TYPES.Identifier) {
         const fields2 = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields2.add(storedField);
         storedFieldsFrom.set(source.object.name, fields2);
@@ -5308,7 +5417,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
     )) {
       if (localBindings2.has(reference.name)) continue;
       let fields2 = reference.fields;
-      if (parameter.type === import_utils35.AST_NODE_TYPES.TSParameterProperty) {
+      if (parameter.type === import_utils36.AST_NODE_TYPES.TSParameterProperty) {
         if (writtenFieldNames.has(reference.name)) continue;
         fields2 = [reference.name];
       } else if (fields2.length === 0)
@@ -5331,8 +5440,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils35.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils36.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils36.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named3 = namedParameterCollaborator(parameter);
@@ -5342,10 +5451,10 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils35.AST_NODE_TYPES.TSParameterProperty)
+  if (target.type === import_utils36.AST_NODE_TYPES.TSParameterProperty)
     target = target.parameter;
-  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils35.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils36.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils36.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(
     target.typeAnnotation?.typeAnnotation,
     declared
@@ -5364,10 +5473,10 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils35.AST_NODE_TYPES.TSParameterProperty)
+  if (target.type === import_utils36.AST_NODE_TYPES.TSParameterProperty)
     target = target.parameter;
-  if (target.type === import_utils35.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils35.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils36.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils36.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -5379,12 +5488,12 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils35.AST_NODE_TYPES.Property || property.computed)
+    if (property.type !== import_utils36.AST_NODE_TYPES.Property || property.computed)
       continue;
-    if (property.key.type !== import_utils35.AST_NODE_TYPES.Identifier) continue;
+    if (property.key.type !== import_utils36.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    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;
+    const bound = property.value.type === import_utils36.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils36.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -5394,22 +5503,22 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils35.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils36.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils35.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils35.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils36.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils36.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body3) => subtreeHas(body3, (node) => {
-  if (node.type === import_utils35.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils36.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils35.AST_NODE_TYPES.Identifier)
+    if (callee.type === import_utils36.AST_NODE_TYPES.Identifier)
       return callee.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 callee.type === import_utils36.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils36.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_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);
+  return node.type === import_utils36.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils36.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -5429,26 +5538,26 @@ var subtreeHas = (root, found) => {
 };
 var invokedInstanceField = (call) => {
   let callee = unwrapExpression(call.callee);
-  while (callee.type === import_utils35.AST_NODE_TYPES.ChainExpression)
+  while (callee.type === import_utils36.AST_NODE_TYPES.ChainExpression)
     callee = unwrapExpression(callee.expression);
   const direct = instanceField(callee);
   if (direct !== null) return direct;
-  return callee.type === import_utils35.AST_NODE_TYPES.MemberExpression ? instanceField(unwrapExpression(callee.object)) : null;
+  return callee.type === import_utils36.AST_NODE_TYPES.MemberExpression ? instanceField(unwrapExpression(callee.object)) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  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)
+  while (node.type === import_utils36.AST_NODE_TYPES.ChainExpression || node.type === import_utils36.AST_NODE_TYPES.TSAsExpression || node.type === import_utils36.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils36.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils36.AST_NODE_TYPES.TSTypeAssertion)
     node = node.expression;
-  return node.type === import_utils35.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils35.AST_NODE_TYPES.ThisExpression ? staticMemberName(node) : null;
+  return node.type === import_utils36.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils36.AST_NODE_TYPES.ThisExpression ? staticMemberName(node) : null;
 };
 function writtenInstanceField(node) {
-  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)
+  if (node.type === import_utils36.AST_NODE_TYPES.AssignmentExpression || node.type === import_utils36.AST_NODE_TYPES.ForOfStatement || node.type === import_utils36.AST_NODE_TYPES.ForInStatement)
     return instanceField(node.left);
-  if (node.type === import_utils35.AST_NODE_TYPES.UpdateExpression)
+  if (node.type === import_utils36.AST_NODE_TYPES.UpdateExpression)
     return instanceField(node.argument);
-  if (node.type === import_utils35.AST_NODE_TYPES.UnaryExpression && node.operator === "delete")
+  if (node.type === import_utils36.AST_NODE_TYPES.UnaryExpression && node.operator === "delete")
     return instanceField(node.argument);
-  if (node.type === import_utils35.AST_NODE_TYPES.MemberExpression && isDestructuredWriteTarget(node))
+  if (node.type === import_utils36.AST_NODE_TYPES.MemberExpression && isDestructuredWriteTarget(node))
     return instanceField(node);
   return null;
 }
@@ -5457,39 +5566,39 @@ function isDestructuredWriteTarget(node) {
   let target = access;
   for (; ; ) {
     const parent = target.parent;
-    if (parent.type === import_utils35.AST_NODE_TYPES.Property && parent.value === target && parent.parent.type === import_utils35.AST_NODE_TYPES.ObjectPattern) {
+    if (parent.type === import_utils36.AST_NODE_TYPES.Property && parent.value === target && parent.parent.type === import_utils36.AST_NODE_TYPES.ObjectPattern) {
       target = parent.parent;
       continue;
     }
-    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) {
+    if (parent.type === import_utils36.AST_NODE_TYPES.ArrayPattern || parent.type === import_utils36.AST_NODE_TYPES.ObjectPattern || parent.type === import_utils36.AST_NODE_TYPES.RestElement && parent.argument === target || parent.type === import_utils36.AST_NODE_TYPES.AssignmentPattern && parent.left === target) {
       target = parent;
       continue;
     }
-    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;
+    return target !== access && (parent.type === import_utils36.AST_NODE_TYPES.AssignmentExpression || parent.type === import_utils36.AST_NODE_TYPES.ForOfStatement || parent.type === import_utils36.AST_NODE_TYPES.ForInStatement) && parent.left === target;
   }
 }
 var behaviorallyInvokedFields = (body3) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    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)
+    if (current.type === import_utils36.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils36.AST_NODE_TYPES.ClassExpression || current.type === import_utils36.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils36.AST_NODE_TYPES.FunctionExpression)
       return;
-    if (current.type === import_utils35.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils36.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_utils35.AST_NODE_TYPES.StaticBlock || member3.static) continue;
-    if (member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition) {
+    if (member3.type === import_utils36.AST_NODE_TYPES.StaticBlock || member3.static) continue;
+    if (member3.type === import_utils36.AST_NODE_TYPES.MethodDefinition) {
       if (member3.value.body !== null && member3.value.body !== void 0)
         visit(member3.value.body);
       continue;
     }
-    if (member3.type !== import_utils35.AST_NODE_TYPES.PropertyDefinition || member3.value === null)
+    if (member3.type !== import_utils36.AST_NODE_TYPES.PropertyDefinition || member3.value === null)
       continue;
     visit(
-      member3.value.type === import_utils35.AST_NODE_TYPES.ArrowFunctionExpression ? member3.value.body : member3.value
+      member3.value.type === import_utils36.AST_NODE_TYPES.ArrowFunctionExpression ? member3.value.body : member3.value
     );
   }
   return invoked;
@@ -5509,8 +5618,8 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSInterfaceDeclaration)
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils36.AST_NODE_TYPES.TSInterfaceDeclaration)
       names.push(declaration.id.name);
   }
   return names;
@@ -5518,22 +5627,22 @@ var fileInterfaceNames = (program) => {
 var publicMethodNames = (body3, functionAliases) => {
   const names = [];
   function collectPublicCallable(member3) {
-    if (member3.type === import_utils35.AST_NODE_TYPES.PropertyDefinition) {
+    if (member3.type === import_utils36.AST_NODE_TYPES.PropertyDefinition) {
       if (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")
         return;
-      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(
+      if (member3.key.type === import_utils36.AST_NODE_TYPES.PrivateIdentifier) return;
+      if (member3.value?.type !== import_utils36.AST_NODE_TYPES.ArrowFunctionExpression && member3.value?.type !== import_utils36.AST_NODE_TYPES.FunctionExpression && member3.typeAnnotation?.typeAnnotation.type !== import_utils36.AST_NODE_TYPES.TSFunctionType && !(member3.typeAnnotation?.typeAnnotation.type === import_utils36.AST_NODE_TYPES.TSTypeReference && member3.typeAnnotation.typeAnnotation.typeName.type === import_utils36.AST_NODE_TYPES.Identifier && functionAliases.has(
         member3.typeAnnotation.typeAnnotation.typeName.name
       )))
         return;
       names.push(declaredMemberName(member3) ?? "\u2026");
       return;
     }
-    if (member3.type !== import_utils35.AST_NODE_TYPES.MethodDefinition) return;
+    if (member3.type !== import_utils36.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_utils35.AST_NODE_TYPES.PrivateIdentifier) return;
+    if (member3.key.type === import_utils36.AST_NODE_TYPES.PrivateIdentifier) return;
     names.push(declaredMemberName(member3) ?? "\u2026");
   }
   for (const member3 of body3.body) {
@@ -5544,13 +5653,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_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "method" && !member3.static && member3.accessibility !== "private" && member3.accessibility !== "protected" && member3.value.body !== null
+    (member3) => member3.type === import_utils36.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_utils35.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils36.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils36.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));
   });
 };
@@ -5558,10 +5667,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_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) {
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils36.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils36.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils36.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -5579,9 +5688,9 @@ function localClassAbstractness(program) {
   return classes;
 }
 function declaredMemberName(member3) {
-  if (!member3.computed && member3.key.type === import_utils35.AST_NODE_TYPES.Identifier)
+  if (!member3.computed && member3.key.type === import_utils36.AST_NODE_TYPES.Identifier)
     return member3.key.name;
-  if (member3.key.type === import_utils35.AST_NODE_TYPES.Literal && typeof member3.key.value === "string")
+  if (member3.key.type === import_utils36.AST_NODE_TYPES.Literal && typeof member3.key.value === "string")
     return member3.key.value;
   return null;
 }
@@ -5590,35 +5699,35 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = localFunctionAliases(program);
   function collectInterfaceSurface(statement) {
-    const declaration = statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils35.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils36.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils35.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils36.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_utils35.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils35.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils36.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils36.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type === import_utils35.AST_NODE_TYPES.TSTypeReference) {
+        if (part.type === import_utils36.AST_NODE_TYPES.TSTypeReference) {
           inherited.push("*");
           continue;
         }
-        if (part.type !== import_utils35.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils36.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_utils35.AST_NODE_TYPES.TSInterfaceDeclaration) return;
+    if (declaration?.type !== import_utils36.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_utils35.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+        (heritage) => heritage.expression.type === import_utils36.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
       )
     ]);
   }
@@ -5627,17 +5736,17 @@ function localInterfaceSurfaces(program) {
   }
   function addCallableMembers(members, callables) {
     for (const member3 of members) {
-      if (member3.type !== import_utils35.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils35.AST_NODE_TYPES.TSPropertySignature)
+      if (member3.type !== import_utils36.AST_NODE_TYPES.TSMethodSignature && member3.type !== import_utils36.AST_NODE_TYPES.TSPropertySignature)
         continue;
       const name = declaredMemberName(member3);
       if (name === null) continue;
-      if (member3.type === import_utils35.AST_NODE_TYPES.TSMethodSignature) {
+      if (member3.type === import_utils36.AST_NODE_TYPES.TSMethodSignature) {
         callables.add(name);
         continue;
       }
-      if (member3.type !== import_utils35.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member3.type !== import_utils36.AST_NODE_TYPES.TSPropertySignature) continue;
       const annotation = member3.typeAnnotation?.typeAnnotation;
-      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))
+      if (annotation?.type === import_utils36.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils36.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils36.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name))
         callables.add(name);
     }
   }
@@ -5667,7 +5776,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils35.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils36.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -5706,7 +5815,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_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null && member3.value.body !== void 0
+          (member3) => member3.type === import_utils36.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null && member3.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -5756,7 +5865,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_utils35.AST_NODE_TYPES.Identifier)
+    if (implementation.expression.type !== import_utils36.AST_NODE_TYPES.Identifier)
       return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
@@ -5773,7 +5882,7 @@ function createServiceOperationResolver(program) {
   let declaredTypes = null;
   return (node) => {
     const ctor = node.body.body.find(
-      (member3) => member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null
+      (member3) => member3.type === import_utils36.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null
     );
     if (ctor === void 0) return [];
     const declared = () => declaredTypes ??= fileTypeIndex(program);
@@ -5791,7 +5900,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_utils35.AST_NODE_TYPES.MemberExpression && call.callee.object.type === import_utils35.AST_NODE_TYPES.ThisExpression) {
+        if (call.callee.type === import_utils36.AST_NODE_TYPES.MemberExpression && call.callee.object.type === import_utils36.AST_NODE_TYPES.ThisExpression) {
           const callee = staticMemberName(call.callee);
           if (callee !== null) {
             const linked = callers.get(callee) ?? /* @__PURE__ */ new Set();
@@ -5830,11 +5939,11 @@ function serviceOperationBodies(node) {
     });
   }
   for (const member3 of node.body.body) {
-    if (member3.type !== import_utils35.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils35.AST_NODE_TYPES.PropertyDefinition)
+    if (member3.type !== import_utils36.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils36.AST_NODE_TYPES.PropertyDefinition)
       continue;
-    if (member3.static || member3.decorators.length > 0 || member3.type === import_utils35.AST_NODE_TYPES.MethodDefinition && member3.kind !== "method")
+    if (member3.static || member3.decorators.length > 0 || member3.type === import_utils36.AST_NODE_TYPES.MethodDefinition && member3.kind !== "method")
       continue;
-    if (member3.value?.type !== import_utils35.AST_NODE_TYPES.FunctionExpression && member3.value?.type !== import_utils35.AST_NODE_TYPES.ArrowFunctionExpression)
+    if (member3.value?.type !== import_utils36.AST_NODE_TYPES.FunctionExpression && member3.value?.type !== import_utils36.AST_NODE_TYPES.ArrowFunctionExpression)
       continue;
     const name = declaredMemberName(member3);
     if (name !== null && !written.has(name) && member3.value.body !== null)
@@ -5843,9 +5952,9 @@ function serviceOperationBodies(node) {
   return bodies;
 }
 function forEachServiceCall(node, onCall) {
-  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)
+  if (node.type === import_utils36.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils36.AST_NODE_TYPES.FunctionExpression || node.type === import_utils36.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils36.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils36.AST_NODE_TYPES.ClassExpression)
     return;
-  if (node.type === import_utils35.AST_NODE_TYPES.BlockStatement) {
+  if (node.type === import_utils36.AST_NODE_TYPES.BlockStatement) {
     for (const statement of node.body) {
       forEachServiceCall(statement, onCall);
       if (terminatesOperation(statement)) break;
@@ -5857,29 +5966,29 @@ function forEachServiceCall(node, onCall) {
     forEachServiceCall(branch, onCall);
     return;
   }
-  if (node.type === import_utils35.AST_NODE_TYPES.CallExpression) onCall(node);
+  if (node.type === import_utils36.AST_NODE_TYPES.CallExpression) onCall(node);
   forEachOwnAstChild(node, (child) => {
     forEachServiceCall(child, onCall);
   });
 }
 function literalExecutionBranch(node) {
-  if (node.type === import_utils35.AST_NODE_TYPES.WhileStatement && node.test.type === import_utils35.AST_NODE_TYPES.Literal && node.test.value === false)
+  if (node.type === import_utils36.AST_NODE_TYPES.WhileStatement && node.test.type === import_utils36.AST_NODE_TYPES.Literal && node.test.value === false)
     return node.test;
-  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") {
+  if ((node.type === import_utils36.AST_NODE_TYPES.IfStatement || node.type === import_utils36.AST_NODE_TYPES.ConditionalExpression) && node.test.type === import_utils36.AST_NODE_TYPES.Literal && typeof node.test.value === "boolean") {
     return node.test.value ? node.consequent : node.alternate ?? node.test;
   }
-  if (node.type !== import_utils35.AST_NODE_TYPES.LogicalExpression || node.left.type !== import_utils35.AST_NODE_TYPES.Literal || typeof node.left.value !== "boolean")
+  if (node.type !== import_utils36.AST_NODE_TYPES.LogicalExpression || node.left.type !== import_utils36.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_utils35.AST_NODE_TYPES.ReturnStatement || node.type === import_utils35.AST_NODE_TYPES.ThrowStatement)
+  if (node.type === import_utils36.AST_NODE_TYPES.ReturnStatement || node.type === import_utils36.AST_NODE_TYPES.ThrowStatement)
     return true;
-  if (node.type === import_utils35.AST_NODE_TYPES.BlockStatement)
+  if (node.type === import_utils36.AST_NODE_TYPES.BlockStatement)
     return node.body.some(terminatesOperation);
-  if (node.type !== import_utils35.AST_NODE_TYPES.IfStatement) return false;
+  if (node.type !== import_utils36.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);
@@ -5893,7 +6002,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_utils35.AST_NODE_TYPES.Identifier)
+      if (implementation.expression.type !== import_utils36.AST_NODE_TYPES.Identifier)
         return false;
       const name = implementation.expression.name;
       const surface = interfaces.get(name);
@@ -5916,7 +6025,7 @@ function hasDeclaredServiceContract(node, operations, program) {
     }
     if (!addImplementedContracts(current)) return null;
     if (current.superClass === null) continue;
-    if (current.superClass.type !== import_utils35.AST_NODE_TYPES.Identifier) return null;
+    if (current.superClass.type !== import_utils36.AST_NODE_TYPES.Identifier) return null;
     const base = classes.get(current.superClass.name);
     if (base === void 0) return null;
     pending.push(base);
@@ -5926,8 +6035,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_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)
+    const declaration = statement.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils36.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils36.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null)
       classes.set(declaration.id.name, declaration);
   }
   return classes;
@@ -5935,13 +6044,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_utils35.AST_NODE_TYPES.TSAbstractMethodDefinition && member3.type !== import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition)
+    if (member3.type !== import_utils36.AST_NODE_TYPES.TSAbstractMethodDefinition && member3.type !== import_utils36.AST_NODE_TYPES.TSAbstractPropertyDefinition)
       continue;
     if (member3.static || member3.accessibility === "private" || member3.accessibility === "protected")
       continue;
-    if (member3.type === import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition) {
+    if (member3.type === import_utils36.AST_NODE_TYPES.TSAbstractPropertyDefinition) {
       const annotation = member3.typeAnnotation?.typeAnnotation;
-      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)))
+      if (annotation?.type !== import_utils36.AST_NODE_TYPES.TSFunctionType && !(annotation?.type === import_utils36.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils36.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)))
         continue;
     }
     const name = declaredMemberName(member3);
@@ -6077,7 +6186,7 @@ function isServiceRole(name, filename) {
 }
 
 // src/rules/no-conditional-empty-object-spread.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = 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.",
@@ -6129,7 +6238,7 @@ var NO_CONDITIONAL_EMPTY_OBJECT_SPREAD_DOCUMENTATION = {
   ]
 };
 function isEmptyObject(node) {
-  return node.type === import_utils37.AST_NODE_TYPES.ObjectExpression && node.properties.length === 0;
+  return node.type === import_utils38.AST_NODE_TYPES.ObjectExpression && node.properties.length === 0;
 }
 var no_conditional_empty_object_spread_default = createRule({
   name: "no-conditional-empty-object-spread",
@@ -6150,13 +6259,13 @@ var no_conditional_empty_object_spread_default = createRule({
     if (isGeneratedFile(context, context.sourceCode.text)) return {};
     return {
       SpreadElement(node) {
-        if (node.parent.type !== import_utils37.AST_NODE_TYPES.ObjectExpression || node.argument.type !== import_utils37.AST_NODE_TYPES.ConditionalExpression)
+        if (node.parent.type !== import_utils38.AST_NODE_TYPES.ObjectExpression || node.argument.type !== import_utils38.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_utils37.AST_NODE_TYPES.ObjectExpression && populated.properties.length > 0 && context.sourceCode.getCommentsInside(conditional).length === 0;
+          const canFix = populated.type === import_utils38.AST_NODE_TYPES.ObjectExpression && populated.properties.length > 0 && context.sourceCode.getCommentsInside(conditional).length === 0;
           context.report({
             node,
             messageId: "avoid",
@@ -6172,7 +6281,7 @@ var no_conditional_empty_object_spread_default = createRule({
 });
 
 // src/rules/prefer-typed-reflection.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = 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.",
@@ -6245,20 +6354,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_utils38.ESLintUtils.getParserServices(context);
+    const services = import_utils39.ESLintUtils.getParserServices(context);
     if (!services.program) return {};
     const checker = services.program.getTypeChecker();
-    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 isReflect = (node) => globalName(node, "Reflect") || node.type === import_utils39.AST_NODE_TYPES.MemberExpression && import_utils39.ASTUtils.getPropertyName(node) === "Reflect" && globalName(node.object, "globalThis");
+    const globalName = (node, name) => node.type === import_utils39.AST_NODE_TYPES.Identifier && node.name === name && !import_utils39.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_utils38.AST_NODE_TYPES.Literal && typeof key.value === "number") && closedObject(type);
+      return node.arguments.length === 2 && (staticString(key) !== null || key?.type === import_utils39.AST_NODE_TYPES.Literal && typeof key.value === "number") && closedObject(type);
     };
-    const inspectApply = (node, type) => node.arguments.length === 3 && node.arguments[2]?.type === import_utils38.AST_NODE_TYPES.ArrayExpression && knownType(type) && type.getCallSignatures().some(
+    const inspectApply = (node, type) => node.arguments.length === 3 && node.arguments[2]?.type === import_utils39.AST_NODE_TYPES.ArrayExpression && knownType(type) && type.getCallSignatures().some(
       (signature) => signature.typeParameters === void 0 && signature.parameters.every(
         (parameter) => knownType(
           checker.getTypeOfSymbolAtLocation(
@@ -6269,25 +6378,25 @@ var prefer_typed_reflection_default = createRule({
       )
     );
     const getReplacement = (node, type, target) => {
-      if (node.optional || node.callee.type !== import_utils38.AST_NODE_TYPES.MemberExpression || node.callee.optional || context.sourceCode.getCommentsInside(node).length > 0) return null;
+      if (node.optional || node.callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression || node.callee.optional || context.sourceCode.getCommentsInside(node).length > 0) return null;
       let outer = node;
-      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;
+      while (outer.parent.type === import_utils39.AST_NODE_TYPES.TSAsExpression || outer.parent.type === import_utils39.AST_NODE_TYPES.TSTypeAssertion || outer.parent.type === import_utils39.AST_NODE_TYPES.TSSatisfiesExpression || outer.parent.type === import_utils39.AST_NODE_TYPES.TSNonNullExpression || outer.parent.type === import_utils39.AST_NODE_TYPES.ChainExpression) outer = outer.parent;
+      if (outer.parent.type === import_utils39.AST_NODE_TYPES.UnaryExpression && outer.parent.operator === "delete" || outer.parent.type === import_utils39.AST_NODE_TYPES.CallExpression && outer.parent.callee === outer || outer.parent.type === import_utils39.AST_NODE_TYPES.TaggedTemplateExpression && outer.parent.tag === outer) return null;
       const writtenKey = node.arguments[1];
-      if (writtenKey === void 0 || writtenKey.type === import_utils38.AST_NODE_TYPES.SpreadElement) return null;
+      if (writtenKey === void 0 || writtenKey.type === import_utils39.AST_NODE_TYPES.SpreadElement) return null;
       const key = unwrapExpression(writtenKey);
-      const name = staticString(key) ?? (key.type === import_utils38.AST_NODE_TYPES.Literal && typeof key.value === "number" ? String(key.value) : null);
+      const name = staticString(key) ?? (key.type === import_utils39.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_utils38.AST_NODE_TYPES.MemberExpression || !isReflect(node.callee.object))
+        if (node.callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression || !isReflect(node.callee.object))
           return;
-        const method = import_utils38.ASTUtils.getPropertyName(node.callee);
+        const method = import_utils39.ASTUtils.getPropertyName(node.callee);
         const target = node.arguments[0];
-        if (!target || target.type === import_utils38.AST_NODE_TYPES.SpreadElement || method !== "get" && method !== "apply")
+        if (!target || target.type === import_utils39.AST_NODE_TYPES.SpreadElement || method !== "get" && method !== "apply")
           return;
         const type = checker.getTypeAtLocation(
           services.esTreeNodeToTSNodeMap.get(target)
@@ -6304,55 +6413,6 @@ var prefer_typed_reflection_default = createRule({
 // src/rules/no-broad-return-type.ts
 var import_utils40 = require("@typescript-eslint/utils");
 var import_typescript13 = __toESM(require("typescript"), 1);
-
-// src/rules/_unused-private-binding.ts
-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_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_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();
-function hasIdentifierNamed(node, name) {
-  let names = IDENTIFIER_NAMES.get(node);
-  if (names === void 0) {
-    const collected = /* @__PURE__ */ new Set();
-    const pending = [node];
-    const seen = /* @__PURE__ */ new WeakSet();
-    while (pending.length > 0) {
-      const current = pending.pop();
-      if (current === void 0 || seen.has(current)) continue;
-      seen.add(current);
-      if (current.type === import_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");
-    }
-    names = collected;
-    IDENTIFIER_NAMES.set(node, names);
-  }
-  return names.has(name);
-}
-function privatePredicateBooleanFix(sourceCode, node, annotation, filename) {
-  if (!annotation.typeAnnotation || !retainsNamedTypeUses(sourceCode, annotation.typeAnnotation) || node.type !== import_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, "")}`);
-}
-
-// src/rules/no-broad-return-type.ts
 var NO_BROAD_RETURN_TYPE_DOCUMENTATION = {
   summary: "Report explicit broad return annotations that erase a known return value.",
   rationale: "An unknown, object, or unknown-valued dictionary return hides fields that the implementation already knows.",
@@ -7196,7 +7256,7 @@ var NO_CONTRADICTORY_TYPE_PREDICATE_DOCUMENTATION = {
     "For the intrinsic object target, typeof-object also admits null only when the declared input admits null and strictNullChecks is enabled. This narrow check does not infer structural property validation or classify other object/function relationships. Overloaded implementations, contextually typed callbacks and methods with class heritage or contextual object contracts retain their separate callable domain.",
     "Compiler-invalid predicate target/input relations and typeof comparisons impossible for the input remain with existing compiler and unnecessary-condition controls. This rule does not validate arbitrary predicates or runtime refinements. Generated files are excluded; tests remain checked.",
     "A sole native Array.isArray call on unknown cannot establish a plain primitive-element array target. Standard-library call signatures and an unshadowed Array binding are required. Element validators, any/unknown elements, tuples, enums, branded or opaque elements and independent callable contracts abstain. Visible Array or host-global aliases, mutation, escapes, extracted methods, any value constructor or unresolved computed-property access and unrelated Array namespace uses disable this proof: structural receiver types cannot establish runtime constructor identity. Native Reflect value uses and Object prototype/descriptor reflection or namespace aliases also withdraw authority. Indirect opaque runtime replacements are not inferred.",
-    "For a same-file nongeneric named record with a required data property, a sole typeof-object check, optionally conjoined with a null exclusion, cannot establish that property from unknown or object input. Optional-only records, dictionaries, classes, imported/generic contracts and implementations with field checks are excluded. A non-null object without the required own property supplies the contradiction; this profile has no automatic fix."
+    "For a same-file nongeneric named record with a required data property, a sole typeof-object check, optionally conjoined with a null exclusion, cannot establish that property from unknown or object input. Optional-only records, dictionaries, classes, imported/generic contracts and implementations with field checks are excluded. A non-null object without the required own property supplies the contradiction. The same unused-private predicate proof may remove its unobserved narrowing contract; observed callable contracts and sole named-type uses remain manual."
   ],
   references: ["https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#inferred-type-predicates"],
   examples: [
@@ -7260,7 +7320,7 @@ var no_contradictory_type_predicate_default = createRule({
       const target = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(annotation.typeAnnotation.typeAnnotation));
       if (!checker.isTypeAssignableTo(target, input)) return;
       if (shallowRecordCheck(expression, parameter, input, target, context.sourceCode, checker, services.esTreeNodeToTSNodeMap.get(node).getSourceFile())) {
-        context.report({ node: annotation, messageId: "uncheckedRecordFields", data: { promised: checker.typeToString(target) } });
+        context.report({ node: annotation, messageId: "uncheckedRecordFields", fix: privatePredicateBooleanFix(context.sourceCode, node, annotation, context.filename), data: { promised: checker.typeToString(target) } });
         return;
       }
       if (check === void 0) {
@@ -7486,7 +7546,7 @@ var NO_PARTIAL_TYPE_PREDICATE_DOCUMENTATION = {
     "Automatic fixes replace the unsound predicate with boolean only for an unused private function declaration without overloads, exports, eval, comments in the predicate, or declaration-file ownership. Runtime checks are preserved; observed callable contracts remain manual.",
     "Requires type information and a non-generic, non-async function with one directly annotated parameter, an explicit broad string/number/bigint/boolean predicate and a single return. Literal, branded, structural, multi-primitive union, assertion, method and overloaded contracts are excluded; contextually typed callbacks are preserved.",
     "Recognizes double-negation truthiness, a boolean parameter return or one same-kind literal comparison, optionally after a matching typeof equality. Without a typeof check, the input must already belong to the target primitive, except for double negation. String length comparisons use only concrete witnesses up to 256 characters. Arithmetic, dynamic bounds and complex boolean conditions are not inferred.",
-    "A broad string predicate returning local Schema.safeParse(parameter).success is also checked for a locally unchanged official z.uuid() or z.string().uuid() schema. The checker must resolve the namespace to installed node_modules/zod declaration files; local path aliases and opaque module resolution abstain. The const schema permits local parse/type/direct-export reads; every safeParse call must have exactly one direct argument, without options or spreads. Local aliases, method writes and opaque consumers abstain. Direct export alone is not mutation, but external consumer monkey-patching is not proved absent. Other value uses of its imported Zod namespace cause abstention. Transforms, brands, custom schemas, imported schemas and dynamic parse calls are excluded. Visible RegExp capabilities, regex literals or dynamic evaluation invalidate this initial native-pattern proof; external runtime monkeypatches are not inferred. This new schema profile has no automatic fix.",
+    "A broad string predicate returning local Schema.safeParse(parameter).success is also checked for a locally unchanged official z.uuid() or z.string().uuid() schema. The checker must resolve the namespace to installed node_modules/zod declaration files; local path aliases and opaque module resolution abstain. The const schema permits local parse/type/direct-export reads; every safeParse call must have exactly one direct argument, without options or spreads. Local aliases, method writes and opaque consumers abstain. Direct export alone is not mutation, but external consumer monkey-patching is not proved absent. Other value uses of its imported Zod namespace cause abstention. Transforms, brands, custom schemas, imported schemas and dynamic parse calls are excluded. Visible RegExp capabilities, regex literals or dynamic evaluation invalidate this initial native-pattern proof; external runtime monkeypatches are not inferred. The same unused-private-declaration fix boundary applies; observed or exported predicates remain manual.",
     "A concrete member of the promised broad primitive must demonstrably return false. Numeric witnesses must also be assignable as literals to the declared input: broad number assignability alone does not prove membership in a numeric enum. Compiler-invalid target/input relations, any/never/generic inputs and opaque implementations abstain. This rule does not discourage total boundary guards or infer branded refinements. Generated files are excluded; tests remain checked."
   ],
   references: ["https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#inferred-type-predicates"],
@@ -7525,7 +7585,7 @@ var no_partial_type_predicate_default = createRule({
       if (predicate === void 0) return;
       const uuidWitness = predicate.kind === "string" ? uuidPredicateWitness(predicate.expression, predicate.parameter, context.sourceCode, services) : void 0;
       if (uuidWitness !== void 0) {
-        context.report({ node: predicate.annotation, messageId: "partialPredicate", data: { witness: showWitness(uuidWitness), target: "string" } });
+        context.report({ node: predicate.annotation, messageId: "partialPredicate", fix: privatePredicateBooleanFix(context.sourceCode, node, predicate.annotation, context.filename), data: { witness: showWitness(uuidWitness), target: "string" } });
         return;
       }
       const refinement = refinementExpression(predicate, context.sourceCode);
@@ -11005,7 +11065,16 @@ var no_comment_cruft_default = createRule({
       while (end + 1 < comments.length && areAdjacentLineComments(comments[end], comments[end + 1])) end += 1;
       const removals = comments.slice(start, end + 1).filter(pure).map((candidate2) => ownLineCommentRemovalRange(sourceCode.text, candidate2));
       if (removals.some((removal) => removal === null)) return null;
-      return (fixer) => removals.flatMap((removal) => removal === null ? [] : [fixer.replaceTextRange(removal.range, commentLineEndings(sourceCode.text, removal))]);
+      return (fixer) => {
+        const fixes = [];
+        for (const removal of removals) {
+          if (removal === null) return null;
+          const endings = commentLineEndings(sourceCode.text, removal);
+          if (endings === null) return null;
+          fixes.push(fixer.replaceTextRange(removal.range, endings));
+        }
+        return fixes;
+      };
     }
     function isSectionJsDoc(comment) {
       const texts = comment.value.split("\n").map(stripCommentMarker).filter((line) => line.length > 0 && !isDirective(line));
@@ -18884,7 +18953,10 @@ var no_restated_comment_default = createRule({
             context.report({
               node: comment,
               messageId: "restatesLineBelow",
-              fix: removal === null ? null : (fixer) => fixer.replaceTextRange(removal.range, commentLineEndings(sourceCode.text, removal)),
+              fix: removal === null ? null : (fixer) => {
+                const endings = commentLineEndings(sourceCode.text, removal);
+                return endings === null ? null : fixer.replaceTextRange(removal.range, endings);
+              },
               suggest: removal === null ? null : [
                 {
                   messageId: "deleteComment",
@@ -19043,7 +19115,10 @@ var no_restated_jsdoc_default = createRule({
           context.report({
             node: comment,
             messageId: "restatesSignature",
-            fix: removal === null ? null : (fixer) => fixer.replaceTextRange(removal.range, commentLineEndings(sourceCode.text, removal)),
+            fix: removal === null ? null : (fixer) => {
+              const endings = commentLineEndings(sourceCode.text, removal);
+              return endings === null ? null : fixer.replaceTextRange(removal.range, endings);
+            },
             suggest: removal === null ? [] : [
               {
                 messageId: "deleteBlock",
@@ -21862,7 +21937,10 @@ function typedTagEdit(comment, signature, sourceCode) {
   if (!removed) return null;
   while (retained[0]?.trim() === "") retained.shift();
   while (retained.at(-1)?.trim() === "") retained.pop();
-  if (retained.length === 0) return { range: removal.range, text: commentLineEndings(sourceCode.text, removal) };
+  if (retained.length === 0) {
+    const endings = commentLineEndings(sourceCode.text, removal);
+    return endings === null ? null : { range: removal.range, text: endings };
+  }
   const eol = sourceCode.text.includes("\r\n") ? "\r\n" : "\n";
   const indent = " ".repeat(comment.loc.start.column);
   return {
@@ -22465,7 +22543,15 @@ var no_declaration_comment_wall_default = createRule({
         },
         messageId: "commentWall",
         data: { restated: String(restated), commented: String(commented) },
-        fix: removals.length === 0 ? null : (fixer) => removals.map((removal) => fixer.replaceTextRange(removal.range, commentLineEndings(sourceCode.text, removal)))
+        fix: removals.length === 0 ? null : (fixer) => {
+          const fixes = [];
+          for (const removal of removals) {
+            const endings = commentLineEndings(sourceCode.text, removal);
+            if (endings === null) return null;
+            fixes.push(fixer.replaceTextRange(removal.range, endings));
+          }
+          return fixes;
+        }
       });
     }
     function isGroupLabel(comment, member3, headsRun) {
@@ -22816,7 +22902,15 @@ var no_type_member_comment_wall_default = createRule({
         },
         messageId: "commentWall",
         data: { restated: String(restated), commented: String(commented) },
-        fix: removals.length === 0 ? null : (fixer) => removals.map((removal) => fixer.replaceTextRange(removal.range, commentLineEndings(sourceCode.text, removal)))
+        fix: removals.length === 0 ? null : (fixer) => {
+          const fixes = [];
+          for (const removal of removals) {
+            const endings = commentLineEndings(sourceCode.text, removal);
+            if (endings === null) return null;
+            fixes.push(fixer.replaceTextRange(removal.range, endings));
+          }
+          return fixes;
+        }
       });
     }
     function isGroupLabel(comment, member3, headsRun) {
@@ -23825,7 +23919,10 @@ var test_phase_label_comment_default = createRule({
           context.report({
             node: comment,
             messageId: "removeLabel",
-            fix: (fixer) => fixer.replaceTextRange(removal.range, commentLineEndings(context.sourceCode.text, removal))
+            fix: (fixer) => {
+              const endings = commentLineEndings(context.sourceCode.text, removal);
+              return endings === null ? null : fixer.replaceTextRange(removal.range, endings);
+            }
           });
         }
       }
@@ -36492,8 +36589,10 @@ var RULE_POLICY = {
   "@sarj/require-pascal-case-zod-schema-name": ["error", "both"]
 };
 var ADVISORY_RULES = Object.keys(RULE_POLICY).filter(isAdvisoryRuleName).toSorted();
-var RECOMMENDED_RULES = presetRules("recommended");
-var STRICT_RULES = presetRules("strict");
+var FLAT_RECOMMENDED_RULES = presetRules("recommended");
+var FLAT_STRICT_RULES = presetRules("strict");
+var RECOMMENDED_RULES = FLAT_RECOMMENDED_RULES;
+var STRICT_RULES = FLAT_STRICT_RULES;
 function isAdvisoryRuleName(name) {
   return isPolicyName(name) && RULE_POLICY[name][0] === "warn";
 }
@@ -36528,12 +36627,12 @@ var PLUGIN = {
       recommended: {
         name: "@sarj/recommended",
         plugins: { "@sarj": PLUGIN },
-        rules: RECOMMENDED_RULES
+        rules: FLAT_RECOMMENDED_RULES
       },
       strict: {
         name: "@sarj/strict",
         plugins: { "@sarj": PLUGIN },
-        rules: STRICT_RULES
+        rules: FLAT_STRICT_RULES
       }
     };
   }