@sarj/eslint-plugin 16.36.6 → 16.36.7

package/dist/index.cjs

@@ -2727,6 +2727,7 @@ function directCalls(binding3) {
 var CONFIG = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler"}}' };
 var EXAMPLE = 'export {}; interface Animal {readonly name: string} interface Dog extends Animal {readonly breed: string} export type KeptDog = Dog; const dog: Dog = {name: "Ada", breed: "Collie"}; function label(value: Dog | Animal): string {return value.name;} label(dog);';
 var NULLABLE_EXAMPLE = EXAMPLE.replace("readonly name: string", "readonly name: string | null").replace("return value.name;", "return value.name ?? '';");
+var OPTIONAL_EXAMPLE = EXAMPLE.replace("readonly breed: string", "readonly breed?: string");
 var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Keep the covering object contract in a private scalar consumer union.",
@@ -2738,12 +2739,14 @@ var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
     "Automatic fixes additionally require every existing identifier caller to be natively assignable to the original contract, without Any, unknown, error or unresolved types on the relevant surface. Comments inside the annotation and TypeScript suppression directives keep the finding manual. Removed named types/imports must retain an independent top-level exported type-alias or direct type-export read. Other removable annotations/assertions, the covering annotation and own-definition/self references cannot keep one another live; otherwise simultaneous fixes can introduce unused-type errors. The exact authored covering type and terminator token sequence are retained; edits that would merge distinct CR and LF terminators remain manual; no producer, call or function body is rewritten.",
     "Only an inline binary parameter union in a strict module's top-level private scalar consumer is supported. Exactly one parameter, an explicit broad primitive return annotation, a single pure returned scalar expression and direct identifier-argument callers are required. Type queries or type-only exports of the callable, public APIs, callbacks, contextual signatures, overloads, generics, decorators, async functions, direct eval and fresh-object callers prevent findings.",
     "Both alternatives must have complete ordinary finite structural surfaces consisting only of explicitly readonly broad string, number, boolean or bigint properties, optionally paired directly with null or undefined in an exact two-part union. Required and optional nullable fields may be read under the same native coverage proof. Every field must have one actual declaration origin throughout each alternative's inheritance/intersection graph. Shared ancestors retain that origin; repeated merged fields, explicit overrides and independently declared overlapping fields abstain, including valid compatible declarations. This excludes recovered conflicting properties without claiming whole-source health. Aliases, imports, re-exports and ordinary inheritance are resolved by the parser-owned TypeScript checker. Any, unknown, missing imports, open/generic/mapped/indexed types, classes, brands, literal discriminants, methods, properties with scalar type aliases, parenthesized or more complex property unions, callbacks and recursive or nested object fields are unsupported.",
-    "Reports only proper native assignability: covered is assignable to covering and the reverse is false. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any also cannot witness coverage. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; mutually assignable but nonidentical structures are excluded.",
+    "Reports proper native assignability, where covered is assignable to covering and the reverse is false, or mutual native assignability with a strict smaller declared covering surface and only optional covered-only members. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any cannot replace explicit declared coverage or the native Optional requirement. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; equal-key and incomparable mutually assignable structures are excluded. The mutual case additionally requires inline contracts or locally bound interfaces/type aliases whose alias and heritage references can be traced through the parser-owned type scope. Merged interface fragments must all resolve to the reference's same native symbol; mixed exported/local recovery abstains. Imported, global and qualified-namespace references in that path abstain; proper one-way coverage retains its existing alias/import support.",
     "General union simplification can change Extract, conditional types, in-narrowing, fresh-literal checking and public presentation. Those contexts are excluded even when ordinary assignment succeeds. Flat destructuring counts every bound field as read; whole-object escape, mutation, helpers, closures, reflection, serialization, dynamic reads, implicit Object capabilities and JSX prevent findings. Imported Python protocol assignability is not approximated by this rule."
   ],
   examples: [
     { id: "covered-alternative", title: "The private consumer needs the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "public-contract", title: "A public union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
+    { id: "optional-covered-alternative", scenarioId: "optional-readonly-contract", title: "An unread optional breed retains the smaller Animal surface", outcome: "match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("Dog | Animal", "Animal") }] },
+    { id: "optional-public-contract", scenarioId: "optional-readonly-contract", title: "A public optional union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
     { id: "nullable-covered-alternative", scenarioId: "nullable-readonly-contract", title: "A nullable name retains the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "nullable-domain-contract", scenarioId: "nullable-readonly-contract", title: "A literal breed keeps the authored domain contract", outcome: "no-match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("readonly breed: string", "readonly breed: 'Collie'") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true }
   ]
@@ -2758,6 +2761,68 @@ function scalarFields(type, checker) {
   }
   return fields2.size ? fields2 : null;
 }
+function localContractBindings(roots, source, services) {
+  const pending = [...roots];
+  const visited = /* @__PURE__ */ new Set();
+  for (let index = 0; index < pending.length; index++) {
+    const node = pending[index];
+    if (!node || visited.has(node)) continue;
+    visited.add(node);
+    const references = localContractReferences(node, source, services);
+    if (references === null) return false;
+    pending.push(...references);
+  }
+  return true;
+}
+function localContractReferences(node, source, services) {
+  switch (node.type) {
+    case import_utils24.AST_NODE_TYPES.TSTypeLiteral:
+      return [];
+    case import_utils24.AST_NODE_TYPES.TSIntersectionType:
+      return node.types;
+    case import_utils24.AST_NODE_TYPES.TSTypeReference:
+      return !node.typeArguments && node.typeName.type === import_utils24.AST_NODE_TYPES.Identifier ? [node.typeName] : null;
+    case import_utils24.AST_NODE_TYPES.Identifier:
+      return localBindingReferences(node, source, services);
+    default:
+      return null;
+  }
+}
+function localBindingReferences(identifier, source, services) {
+  const definitions2 = typeBinding(source, identifier)?.defs.filter((definition) => definition.isTypeDefinition).map((definition) => definition.node);
+  if (!definitions2?.length || !definitions2.every(moduleTypeDeclaration)) return null;
+  const first = definitions2[0];
+  if (definitions2.length === 1 && first?.type === import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration && !first.typeParameters) return [first.typeAnnotation];
+  const interfaces = definitions2.filter((definition) => definition.type === import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration);
+  if (interfaces.length !== definitions2.length || interfaces.some((declaration) => declaration.typeParameters)) return null;
+  if (interfaces.length > 1) {
+    const checker = services.program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(identifier));
+    if (!symbol || interfaces.some((declaration) => checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(declaration.id)) !== symbol)) return null;
+  }
+  const bases = interfaces.flatMap((declaration) => declaration.extends.map((base) => base.expression));
+  return bases.every((base) => base.type === import_utils24.AST_NODE_TYPES.Identifier) ? bases : null;
+}
+function moduleTypeDeclaration(node) {
+  const parent = node.parent;
+  if (parent?.type === import_utils24.AST_NODE_TYPES.Program) return true;
+  if (parent?.type !== import_utils24.AST_NODE_TYPES.ExportNamedDeclaration && parent?.type !== import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) return false;
+  return parent.parent.type === import_utils24.AST_NODE_TYPES.Program;
+}
+function coveringAlternative(leftNode, rightNode, checker, fieldsOf, reads) {
+  const left = checker.getTypeFromTypeNode(leftNode);
+  const right = checker.getTypeFromTypeNode(rightNode);
+  const leftFields = fieldsOf(left);
+  const rightFields = fieldsOf(right);
+  if (!leftFields || !rightFields) return null;
+  const forward = checker.isTypeAssignableTo(left, right);
+  const reverse = checker.isTypeAssignableTo(right, left);
+  const mutual = forward && reverse;
+  if (!forward && !reverse || mutual && leftFields.size === rightFields.size) return null;
+  const [covered2, covering, coveredFields, coveringFields] = forward && (!reverse || leftFields.size > rightFields.size) ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
+  if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || mutual && [...coveredFields].some(([key, required]) => required && !coveringFields.has(key)) || [...reads].some((key) => !coveringFields.has(key)) || ![...reads].some((key) => coveringFields.get(key))) return null;
+  return { covered: covered2, covering, mutual };
+}
 function privateUnionFix(sourceCode, services, proof) {
   const covering = services.tsNodeToESTreeNodeMap.get(proof.covering);
   if (!validConsumerFixCalls(proof.candidate, proof.parameter, sourceCode, services)) return null;
@@ -2808,17 +2873,11 @@ var no_redundant_consumer_union_default = createRule({
           const leftNode = annotation.types[0];
           const rightNode = annotation.types[1];
           if (!leftNode || !rightNode) continue;
-          const left = checker.getTypeFromTypeNode(leftNode);
-          const right = checker.getTypeFromTypeNode(rightNode);
-          const leftFields = fieldsOf(left);
-          const rightFields = fieldsOf(right);
-          if (!leftFields || !rightFields) continue;
-          const forward = checker.isTypeAssignableTo(left, right);
-          const reverse = checker.isTypeAssignableTo(right, left);
-          if (forward === reverse) continue;
-          const [coveredNode, coveringNode, coveredFields, coveringFields] = forward ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
-          if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || [...consumer.reads].some((key) => !coveringFields.has(key)) || ![...consumer.reads].some((key) => coveringFields.get(key))) continue;
+          const coverage = coveringAlternative(leftNode, rightNode, checker, fieldsOf, consumer.reads);
+          if (!coverage) continue;
           const reportNode = services.tsNodeToESTreeNodeMap.get(annotation);
+          if (coverage.mutual && (reportNode.type !== import_utils24.AST_NODE_TYPES.TSUnionType || !localContractBindings(reportNode.types, context.sourceCode, services))) continue;
+          const { covered: coveredNode, covering: coveringNode } = coverage;
           const fix = privateUnionFix(context.sourceCode, services, {
             candidate: candidate2,
             parameter: consumer.parameter,
@@ -4025,7 +4084,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.36.6",
+  version: "16.36.7",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",

package/dist/index.js

@@ -2676,6 +2676,7 @@ function directCalls(binding3) {
 var CONFIG = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler"}}' };
 var EXAMPLE = 'export {}; interface Animal {readonly name: string} interface Dog extends Animal {readonly breed: string} export type KeptDog = Dog; const dog: Dog = {name: "Ada", breed: "Collie"}; function label(value: Dog | Animal): string {return value.name;} label(dog);';
 var NULLABLE_EXAMPLE = EXAMPLE.replace("readonly name: string", "readonly name: string | null").replace("return value.name;", "return value.name ?? '';");
+var OPTIONAL_EXAMPLE = EXAMPLE.replace("readonly breed: string", "readonly breed?: string");
 var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Keep the covering object contract in a private scalar consumer union.",
@@ -2687,12 +2688,14 @@ var NO_REDUNDANT_CONSUMER_UNION_DOCUMENTATION = {
     "Automatic fixes additionally require every existing identifier caller to be natively assignable to the original contract, without Any, unknown, error or unresolved types on the relevant surface. Comments inside the annotation and TypeScript suppression directives keep the finding manual. Removed named types/imports must retain an independent top-level exported type-alias or direct type-export read. Other removable annotations/assertions, the covering annotation and own-definition/self references cannot keep one another live; otherwise simultaneous fixes can introduce unused-type errors. The exact authored covering type and terminator token sequence are retained; edits that would merge distinct CR and LF terminators remain manual; no producer, call or function body is rewritten.",
     "Only an inline binary parameter union in a strict module's top-level private scalar consumer is supported. Exactly one parameter, an explicit broad primitive return annotation, a single pure returned scalar expression and direct identifier-argument callers are required. Type queries or type-only exports of the callable, public APIs, callbacks, contextual signatures, overloads, generics, decorators, async functions, direct eval and fresh-object callers prevent findings.",
     "Both alternatives must have complete ordinary finite structural surfaces consisting only of explicitly readonly broad string, number, boolean or bigint properties, optionally paired directly with null or undefined in an exact two-part union. Required and optional nullable fields may be read under the same native coverage proof. Every field must have one actual declaration origin throughout each alternative's inheritance/intersection graph. Shared ancestors retain that origin; repeated merged fields, explicit overrides and independently declared overlapping fields abstain, including valid compatible declarations. This excludes recovered conflicting properties without claiming whole-source health. Aliases, imports, re-exports and ordinary inheritance are resolved by the parser-owned TypeScript checker. Any, unknown, missing imports, open/generic/mapped/indexed types, classes, brands, literal discriminants, methods, properties with scalar type aliases, parenthesized or more complex property unions, callbacks and recursive or nested object fields are unsupported.",
-    "Reports only proper native assignability: covered is assignable to covering and the reverse is false. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any also cannot witness coverage. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; mutually assignable but nonidentical structures are excluded.",
+    "Reports proper native assignability, where covered is assignable to covering and the reverse is false, or mutual native assignability with a strict smaller declared covering surface and only optional covered-only members. Every covering member, including optional members, must exist in the covered type's enumerated declared surface. Otherwise an existing identifier may carry an incompatible extra field and be rejected after simplification; implicit Object members containing Any cannot replace explicit declared coverage or the native Optional requirement. The covering type must declare every read field and a read required field; an all-optional reduced contract can reject existing callers. Identical alternatives and primitive/top/bottom redundancy remain upstream-owned; equal-key and incomparable mutually assignable structures are excluded. The mutual case additionally requires inline contracts or locally bound interfaces/type aliases whose alias and heritage references can be traced through the parser-owned type scope. Merged interface fragments must all resolve to the reference's same native symbol; mixed exported/local recovery abstains. Imported, global and qualified-namespace references in that path abstain; proper one-way coverage retains its existing alias/import support.",
     "General union simplification can change Extract, conditional types, in-narrowing, fresh-literal checking and public presentation. Those contexts are excluded even when ordinary assignment succeeds. Flat destructuring counts every bound field as read; whole-object escape, mutation, helpers, closures, reflection, serialization, dynamic reads, implicit Object capabilities and JSX prevent findings. Imported Python protocol assignability is not approximated by this rule."
   ],
   examples: [
     { id: "covered-alternative", title: "The private consumer needs the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "public-contract", title: "A public union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
+    { id: "optional-covered-alternative", scenarioId: "optional-readonly-contract", title: "An unread optional breed retains the smaller Animal surface", outcome: "match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("Dog | Animal", "Animal") }] },
+    { id: "optional-public-contract", scenarioId: "optional-readonly-contract", title: "A public optional union retains its observable alternatives", outcome: "no-match", files: [{ path: "src/case.ts", source: OPTIONAL_EXAMPLE.replace("function label", "export function label") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true },
     { id: "nullable-covered-alternative", scenarioId: "nullable-readonly-contract", title: "A nullable name retains the covering Animal contract", outcome: "match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE }, CONFIG], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("Dog | Animal", "Animal") }] },
     { id: "nullable-domain-contract", scenarioId: "nullable-readonly-contract", title: "A literal breed keeps the authored domain contract", outcome: "no-match", files: [{ path: "src/case.ts", source: NULLABLE_EXAMPLE.replace("readonly breed: string", "readonly breed: 'Collie'") }, CONFIG], focusPath: "src/case.ts", expectedCount: 0, public: true }
   ]
@@ -2707,6 +2710,68 @@ function scalarFields(type, checker) {
   }
   return fields2.size ? fields2 : null;
 }
+function localContractBindings(roots, source, services) {
+  const pending = [...roots];
+  const visited = /* @__PURE__ */ new Set();
+  for (let index = 0; index < pending.length; index++) {
+    const node = pending[index];
+    if (!node || visited.has(node)) continue;
+    visited.add(node);
+    const references = localContractReferences(node, source, services);
+    if (references === null) return false;
+    pending.push(...references);
+  }
+  return true;
+}
+function localContractReferences(node, source, services) {
+  switch (node.type) {
+    case AST_NODE_TYPES22.TSTypeLiteral:
+      return [];
+    case AST_NODE_TYPES22.TSIntersectionType:
+      return node.types;
+    case AST_NODE_TYPES22.TSTypeReference:
+      return !node.typeArguments && node.typeName.type === AST_NODE_TYPES22.Identifier ? [node.typeName] : null;
+    case AST_NODE_TYPES22.Identifier:
+      return localBindingReferences(node, source, services);
+    default:
+      return null;
+  }
+}
+function localBindingReferences(identifier, source, services) {
+  const definitions2 = typeBinding(source, identifier)?.defs.filter((definition) => definition.isTypeDefinition).map((definition) => definition.node);
+  if (!definitions2?.length || !definitions2.every(moduleTypeDeclaration)) return null;
+  const first = definitions2[0];
+  if (definitions2.length === 1 && first?.type === AST_NODE_TYPES22.TSTypeAliasDeclaration && !first.typeParameters) return [first.typeAnnotation];
+  const interfaces = definitions2.filter((definition) => definition.type === AST_NODE_TYPES22.TSInterfaceDeclaration);
+  if (interfaces.length !== definitions2.length || interfaces.some((declaration) => declaration.typeParameters)) return null;
+  if (interfaces.length > 1) {
+    const checker = services.program.getTypeChecker();
+    const symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(identifier));
+    if (!symbol || interfaces.some((declaration) => checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(declaration.id)) !== symbol)) return null;
+  }
+  const bases = interfaces.flatMap((declaration) => declaration.extends.map((base) => base.expression));
+  return bases.every((base) => base.type === AST_NODE_TYPES22.Identifier) ? bases : null;
+}
+function moduleTypeDeclaration(node) {
+  const parent = node.parent;
+  if (parent?.type === AST_NODE_TYPES22.Program) return true;
+  if (parent?.type !== AST_NODE_TYPES22.ExportNamedDeclaration && parent?.type !== AST_NODE_TYPES22.ExportDefaultDeclaration) return false;
+  return parent.parent.type === AST_NODE_TYPES22.Program;
+}
+function coveringAlternative(leftNode, rightNode, checker, fieldsOf, reads) {
+  const left = checker.getTypeFromTypeNode(leftNode);
+  const right = checker.getTypeFromTypeNode(rightNode);
+  const leftFields = fieldsOf(left);
+  const rightFields = fieldsOf(right);
+  if (!leftFields || !rightFields) return null;
+  const forward = checker.isTypeAssignableTo(left, right);
+  const reverse = checker.isTypeAssignableTo(right, left);
+  const mutual = forward && reverse;
+  if (!forward && !reverse || mutual && leftFields.size === rightFields.size) return null;
+  const [covered2, covering, coveredFields, coveringFields] = forward && (!reverse || leftFields.size > rightFields.size) ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
+  if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || mutual && [...coveredFields].some(([key, required]) => required && !coveringFields.has(key)) || [...reads].some((key) => !coveringFields.has(key)) || ![...reads].some((key) => coveringFields.get(key))) return null;
+  return { covered: covered2, covering, mutual };
+}
 function privateUnionFix(sourceCode, services, proof) {
   const covering = services.tsNodeToESTreeNodeMap.get(proof.covering);
   if (!validConsumerFixCalls(proof.candidate, proof.parameter, sourceCode, services)) return null;
@@ -2757,17 +2822,11 @@ var no_redundant_consumer_union_default = createRule({
           const leftNode = annotation.types[0];
           const rightNode = annotation.types[1];
           if (!leftNode || !rightNode) continue;
-          const left = checker.getTypeFromTypeNode(leftNode);
-          const right = checker.getTypeFromTypeNode(rightNode);
-          const leftFields = fieldsOf(left);
-          const rightFields = fieldsOf(right);
-          if (!leftFields || !rightFields) continue;
-          const forward = checker.isTypeAssignableTo(left, right);
-          const reverse = checker.isTypeAssignableTo(right, left);
-          if (forward === reverse) continue;
-          const [coveredNode, coveringNode, coveredFields, coveringFields] = forward ? [leftNode, rightNode, leftFields, rightFields] : [rightNode, leftNode, rightFields, leftFields];
-          if ([...coveringFields.keys()].some((key) => !coveredFields.has(key)) || [...consumer.reads].some((key) => !coveringFields.has(key)) || ![...consumer.reads].some((key) => coveringFields.get(key))) continue;
+          const coverage = coveringAlternative(leftNode, rightNode, checker, fieldsOf, consumer.reads);
+          if (!coverage) continue;
           const reportNode = services.tsNodeToESTreeNodeMap.get(annotation);
+          if (coverage.mutual && (reportNode.type !== AST_NODE_TYPES22.TSUnionType || !localContractBindings(reportNode.types, context.sourceCode, services))) continue;
+          const { covered: coveredNode, covering: coveringNode } = coverage;
           const fix = privateUnionFix(context.sourceCode, services, {
             candidate: candidate2,
             parameter: consumer.parameter,
@@ -3978,7 +4037,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.36.6",
+  version: "16.36.7",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "16.36.6",
+  "version": "16.36.7",
   "packageManager": "npm@12.2.1",
   "description": "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",