@sarj/eslint-plugin 18.0.0 → 18.0.3

package/dist/index.cjs

@@ -50,7 +50,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/rules/no-logical-or-fallback.ts
-var import_utils3 = require("@typescript-eslint/utils");
+var import_utils4 = require("@typescript-eslint/utils");
 var import_ts_api_utils = require("ts-api-utils");
 var import_typescript = __toESM(require("typescript"), 1);
 
@@ -590,7 +590,30 @@ function commentLineEnd(sourceText, start) {
   return end === -1 ? sourceText.length : start + end;
 }
 
+// src/rules/_unwrap-expression.ts
+var import_utils3 = require("@typescript-eslint/utils");
+function unwrapExpression(node) {
+  while (isErasedExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function outerExpression(node) {
+  while (node.parent !== void 0 && node.parent !== null && isErasedExpression(node.parent) && node.parent.expression === node) node = node.parent;
+  return node;
+}
+function directArgumentCall(node) {
+  const argument = outerExpression(node);
+  const call = argument.parent;
+  return call?.type === import_utils3.AST_NODE_TYPES.CallExpression && call.arguments.some((item) => item === argument) ? call : null;
+}
+function isErasedExpression(node) {
+  return node.type === import_utils3.AST_NODE_TYPES.TSAsExpression || node.type === import_utils3.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils3.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils3.AST_NODE_TYPES.TSTypeAssertion;
+}
+
 // src/rules/no-logical-or-fallback.ts
+var PRIMITIVE_FLAGS = import_typescript.default.TypeFlags.StringLike | import_typescript.default.TypeFlags.NumberLike | import_typescript.default.TypeFlags.BigIntLike | import_typescript.default.TypeFlags.BooleanLike;
+var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "window", "self"]);
 var NO_LOGICAL_OR_FALLBACK_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Use nullish defaults or explicit falsy-value checks instead of logical OR fallbacks.",
@@ -599,8 +622,8 @@ var NO_LOGICAL_OR_FALLBACK_DOCUMENTATION = {
   category: "correctness",
   autofix: "none",
   limitations: [
-    "Requires TypeScript type information and strict null checks. Reports non-nullable string, number or bigint value fallbacks, including mixed primitive unions. Nullable inputs remain owned by @typescript-eslint/prefer-nullish-coalescing; both rules are enabled in the managed strict config.",
-    "Preserves boolean aggregation, conditions, negations, left-hand && guards, and calls to the unshadowed Boolean constructor. Constant truthiness stays with no-unnecessary-condition. Unknown, any, generic, object-only and generated inputs are excluded. Strings and comments are never scanned as code.",
+    "Requires TypeScript type information and strict null checks. Reports non-nullable string, number or bigint value fallbacks, including branded primitives and mixed primitive unions. Nullable inputs, including nullable booleans, remain owned by @typescript-eslint/prefer-nullish-coalescing; both rules are enabled in the managed strict config.",
+    "Preserves non-nullable boolean aggregation, conditions, negations, left-hand && guards, and calls to the native unshadowed Boolean constructor, including erased TypeScript wrappers and globalThis/window/self access. Constant truthiness stays with no-unnecessary-condition. Unknown, any, unresolved generic, object-only and generated inputs are excluded. Strings and comments are never scanned as code.",
     "No automatic replacement is offered: replacing || with ?? would change empty-string or zero behavior. Non-nullable ||= expressions remain outside this companion rule."
   ],
   references: ["https://typescript-eslint.io/rules/prefer-nullish-coalescing/"],
@@ -628,83 +651,72 @@ var no_logical_or_fallback_default = createRule({
     if (!(options.strictNullChecks ?? options.strict ?? false)) return {};
     return {
       LogicalExpression(node) {
-        if (node.operator !== "||" || booleanContext(node, context.sourceCode)) return;
+        if (node.operator !== "||" || booleanContext(node, context.sourceCode, services)) return;
         const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node.left));
-        const members = type.isUnion() ? type.types : [type];
-        const primitiveFlags = import_typescript.default.TypeFlags.StringLike | import_typescript.default.TypeFlags.NumberLike | import_typescript.default.TypeFlags.BigIntLike | import_typescript.default.TypeFlags.BooleanLike;
-        if (!members.every((member3) => (member3.flags & primitiveFlags) !== 0) || !members.some((member3) => (member3.flags & (import_typescript.default.TypeFlags.StringLike | import_typescript.default.TypeFlags.NumberLike | import_typescript.default.TypeFlags.BigIntLike)) !== 0)) return;
-        const truthiness = members.map(literalTruthiness);
+        const members = (type.isUnion() ? type.types : [type]).map(primitivePart);
+        if (members.some((member3) => member3 === void 0) || !members.some((member3) => member3 !== void 0 && (member3.flags & (import_typescript.default.TypeFlags.StringLike | import_typescript.default.TypeFlags.NumberLike | import_typescript.default.TypeFlags.BigIntLike)) !== 0)) return;
+        const truthiness = members.map((member3) => member3 === void 0 ? void 0 : literalTruthiness(member3));
         if (truthiness.every((value) => value === true) || truthiness.every((value) => value === false)) return;
         context.report({ node, messageId: "logicalOrFallback" });
       }
     };
   }
 });
+function primitivePart(type) {
+  if ((type.flags & PRIMITIVE_FLAGS) !== 0) return type;
+  if (!type.isIntersection() || type.types.some((member3) => (member3.flags & import_typescript.default.TypeFlags.TypeParameter) !== 0)) return void 0;
+  return type.types.find((member3) => (member3.flags & PRIMITIVE_FLAGS) !== 0);
+}
 function literalTruthiness(type) {
   if (type.isStringLiteral() || type.isNumberLiteral()) return Boolean(type.value);
   if ((0, import_ts_api_utils.isBooleanLiteralType)(type)) return type.intrinsicName === "true";
   if ((0, import_ts_api_utils.isBigIntLiteralType)(type)) return type.value.base10Value !== "0";
   return void 0;
 }
-function booleanContext(node, source) {
-  let current = node;
+function booleanContext(node, source, services) {
+  let current = outerExpression(node);
   while (current.parent !== void 0) {
     const parent = current.parent;
     switch (parent.type) {
-      case import_utils3.AST_NODE_TYPES.TSAsExpression:
-      case import_utils3.AST_NODE_TYPES.TSSatisfiesExpression:
-      case import_utils3.AST_NODE_TYPES.TSNonNullExpression:
-        current = parent;
-        continue;
-      case import_utils3.AST_NODE_TYPES.LogicalExpression:
+      case import_utils4.AST_NODE_TYPES.LogicalExpression:
         if (parent.operator === "&&" && parent.left === current) return true;
-        current = parent;
+        current = outerExpression(parent);
         continue;
-      case import_utils3.AST_NODE_TYPES.IfStatement:
-      case import_utils3.AST_NODE_TYPES.WhileStatement:
-      case import_utils3.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils3.AST_NODE_TYPES.ForStatement:
-      case import_utils3.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils4.AST_NODE_TYPES.IfStatement:
+      case import_utils4.AST_NODE_TYPES.WhileStatement:
+      case import_utils4.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils4.AST_NODE_TYPES.ForStatement:
+      case import_utils4.AST_NODE_TYPES.ConditionalExpression:
         return parent.test === current;
-      case import_utils3.AST_NODE_TYPES.UnaryExpression:
+      case import_utils4.AST_NODE_TYPES.UnaryExpression:
         return parent.operator === "!";
-      case import_utils3.AST_NODE_TYPES.CallExpression:
-        return parent.callee.type === import_utils3.AST_NODE_TYPES.Identifier && parent.callee.name === "Boolean" && parent.arguments[0] === current && import_utils3.ASTUtils.findVariable(source.getScope(parent.callee), "Boolean")?.defs.length === 0;
+      case import_utils4.AST_NODE_TYPES.CallExpression:
+        return parent.arguments[0] === current && nativeBoolean(parent.callee, source, services);
       default:
         return false;
     }
   }
   return false;
 }
-
-// src/rules/no-zod-parse-typed-object.ts
-var import_utils5 = require("@typescript-eslint/utils");
-var import_typescript2 = __toESM(require("typescript"), 1);
-
-// src/rules/_unwrap-expression.ts
-var import_utils4 = require("@typescript-eslint/utils");
-function unwrapExpression(node) {
-  while (isErasedExpression(node)) {
-    node = node.expression;
+function nativeBoolean(node, source, services) {
+  const callee = unwrapExpression(node);
+  const checker = services.program.getTypeChecker();
+  let symbol;
+  if (callee.type === import_utils4.AST_NODE_TYPES.Identifier && callee.name === "Boolean" && !import_utils4.ASTUtils.findVariable(source.getScope(callee), callee.name)?.defs.length) {
+    symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(callee));
+  } else if (callee.type === import_utils4.AST_NODE_TYPES.MemberExpression && import_utils4.ASTUtils.getPropertyName(callee) === "Boolean") {
+    const receiver = unwrapExpression(callee.object);
+    if (receiver.type !== import_utils4.AST_NODE_TYPES.Identifier || !GLOBAL_RECEIVERS.has(receiver.name) || import_utils4.ASTUtils.findVariable(source.getScope(receiver), receiver.name)?.defs.length) return false;
+    symbol = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(receiver)).getProperty("Boolean");
   }
-  return node;
-}
-function outerExpression(node) {
-  while (node.parent !== void 0 && node.parent !== null && isErasedExpression(node.parent) && node.parent.expression === node) node = node.parent;
-  return node;
-}
-function directArgumentCall(node) {
-  const argument = outerExpression(node);
-  const call = argument.parent;
-  return call?.type === import_utils4.AST_NODE_TYPES.CallExpression && call.arguments.some((item) => item === argument) ? call : null;
-}
-function isErasedExpression(node) {
-  return node.type === import_utils4.AST_NODE_TYPES.TSAsExpression || node.type === import_utils4.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils4.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils4.AST_NODE_TYPES.TSTypeAssertion;
+  return symbol?.declarations !== void 0 && symbol.declarations.length > 0 && symbol.declarations.every((declaration) => services.program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
 }
 
 // src/rules/no-zod-parse-typed-object.ts
+var import_utils5 = require("@typescript-eslint/utils");
+var import_ts_api_utils2 = require("ts-api-utils");
+var import_typescript2 = __toESM(require("typescript"), 1);
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "parseAsync", "safeParse", "safeParseAsync"]);
-var TUPLE_INDEX_RE = /^(?:0|[1-9]\d*)$/u;
 var OPAQUE_FLAGS = import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown | import_typescript2.default.TypeFlags.Never | import_typescript2.default.TypeFlags.TypeParameter | import_typescript2.default.TypeFlags.Conditional | import_typescript2.default.TypeFlags.IndexedAccess | import_typescript2.default.TypeFlags.Intersection | import_typescript2.default.TypeFlags.NonPrimitive;
 var NO_ZOD_PARSE_TYPED_OBJECT_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -717,7 +729,7 @@ var NO_ZOD_PARSE_TYPED_OBJECT_DOCUMENTATION = {
     "Requires type information, strict null checks, and a native installed Zod parse, parseAsync, safeParse or safeParseAsync signature. Recognizes imported schemas, aliases, member access and awaited service results without guessing from names.",
     "Reports fully known object or array inputs assignable to the schema input, when schema input and output have the same value shape. Optional-to-required defaults are included; type-changing transforms, coercions, brands, incompatible contracts, primitive roots and nested any/unknown/generic contracts are excluded.",
     "Static types do not establish runtime trust or prove refinements and normalization redundant. This is an architectural warning with no automatic removal. Keep intentional validation at an unknown-data boundary or document an exact local suppression. Tests, stories and generated code are excluded.",
-    "Shape comparison ignores undefined introduced by optional properties and is bounded to 128 object pairs or visited input objects. Opaque or larger graphs are conservatively excluded."
+    "Shape comparison ignores undefined introduced by optional properties and checks tuple element types and rest positions. It is bounded to 128 object pairs, visited input objects, properties, tuple elements or primitive union alternatives; object unions have at most 16 alternatives. Opaque or larger graphs are conservatively excluded."
   ],
   references: ["https://zod.dev/basics"],
   examples: [
@@ -777,7 +789,11 @@ function knownValue(checker, type, location, seen) {
   if (seen.has(type)) return true;
   if (seen.size >= 128 || type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return false;
   seen.add(type);
-  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+  if ((0, import_ts_api_utils2.isTupleTypeReference)(type)) {
+    const elements = checker.getTypeArguments(type);
+    return elements.length <= 128 && elements.every((element) => knownValue(checker, element, location, seen));
+  }
+  if (checker.isArrayType(type)) {
     const element = type.getNumberIndexType();
     return element !== void 0 && knownValue(checker, element, location, seen);
   }
@@ -793,7 +809,8 @@ function sameShape(checker, input, output, location) {
     if (left.isUnion() || right.isUnion()) {
       const a = (left.isUnion() ? left.types : [left]).filter((member3) => (member3.flags & import_typescript2.default.TypeFlags.Undefined) === 0);
       const b = (right.isUnion() ? right.types : [right]).filter((member3) => (member3.flags & import_typescript2.default.TypeFlags.Undefined) === 0);
-      return a.length > 0 && a.length === b.length && a.length <= 16 && a.every((member3) => b.some((other) => compare(member3, other))) && b.every((member3) => a.some((other) => compare(other, member3)));
+      const limit = [...a, ...b].every((member3) => (member3.flags & (import_typescript2.default.TypeFlags.Object | OPAQUE_FLAGS)) === 0) ? 128 : 16;
+      return a.length > 0 && a.length === b.length && a.length <= limit && a.every((member3) => b.some((other) => compare(member3, other))) && b.every((member3) => a.some((other) => compare(other, member3)));
     }
     if ((left.flags & import_typescript2.default.TypeFlags.Object) === 0 || (right.flags & import_typescript2.default.TypeFlags.Object) === 0) {
       return checker.isTypeAssignableTo(left, right) && checker.isTypeAssignableTo(right, left);
@@ -811,9 +828,9 @@ function sameShape(checker, input, output, location) {
   function sameObjectShape(left, right) {
     const leftTuple = checker.isTupleType(left);
     const rightTuple = checker.isTupleType(right);
-    if (leftTuple !== rightTuple || leftTuple && !sameTuplePositions(left, right)) return false;
-    if (checker.isArrayType(left) || leftTuple) {
-      if (!checker.isArrayType(right) && !rightTuple) return false;
+    if (leftTuple || rightTuple) return leftTuple && rightTuple && sameTuplePositions(left, right);
+    if (checker.isArrayType(left)) {
+      if (!checker.isArrayType(right)) return false;
       const a2 = left.getNumberIndexType();
       const b2 = right.getNumberIndexType();
       return a2 !== void 0 && b2 !== void 0 && compare(a2, b2);
@@ -829,17 +846,13 @@ function sameShape(checker, input, output, location) {
     return a.length === b.length && a.every((index) => b.some((other) => checker.isTypeAssignableTo(index.keyType, other.keyType) && checker.isTypeAssignableTo(other.keyType, index.keyType) && compare(index.type, other.type)));
   }
   function sameTuplePositions(left, right) {
-    const leftLength = left.getProperty("length");
-    const rightLength = right.getProperty("length");
-    if (leftLength === void 0 || rightLength === void 0) return false;
-    const a = checker.getTypeOfSymbolAtLocation(leftLength, location);
-    const b = checker.getTypeOfSymbolAtLocation(rightLength, location);
-    if (!checker.isTypeAssignableTo(a, b) || !checker.isTypeAssignableTo(b, a)) return false;
-    const properties = left.getProperties().filter((property) => TUPLE_INDEX_RE.test(property.name));
-    const otherProperties = right.getProperties().filter((property) => TUPLE_INDEX_RE.test(property.name));
-    return properties.length <= 128 && properties.length === otherProperties.length && properties.every((property) => {
-      const other = right.getProperty(property.name);
-      return other !== void 0 && compare(checker.getTypeOfSymbolAtLocation(property, location), checker.getTypeOfSymbolAtLocation(other, location));
+    if (!(0, import_ts_api_utils2.isTupleTypeReference)(left) || !(0, import_ts_api_utils2.isTupleTypeReference)(right)) return false;
+    const a = checker.getTypeArguments(left);
+    const b = checker.getTypeArguments(right);
+    const flags = right.target.elementFlags;
+    return a.length <= 128 && a.length === b.length && left.target.elementFlags.every((flag, index) => flag === flags[index]) && a.every((element, index) => {
+      const other = b[index];
+      return other !== void 0 && compare(element, other);
     });
   }
   return compare(input, output);
@@ -882,7 +895,7 @@ function stableValueBinding(variable, acceptRead) {
 var VIEWS = /* @__PURE__ */ new WeakMap();
 function renderFunction(node) {
   let parent = node.parent;
-  while (parent !== void 0) {
+  while (parent !== void 0 && parent !== null) {
     if (isFunction(parent)) {
       let view = VIEWS.get(parent);
       if (view === void 0) {
@@ -2510,7 +2523,7 @@ function nativeRead(node, name) {
 }
 
 // src/rules/_native-fetch-reference.ts
-var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
+var GLOBAL_RECEIVERS2 = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
 function nativeFetchReference(node, sourceCode) {
   return lexicalFetchReference(node, sourceCode) && nativeRuntimeUnchanged(sourceCode, "fetch");
 }
@@ -2533,7 +2546,7 @@ function lexicalFetchReference(node, sourceCode, seen = /* @__PURE__ */ new Set(
 }
 function globalReceiver(node, sourceCode) {
   const receiver = unwrapExpression(node);
-  return receiver.type === import_utils22.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS.has(receiver.name) && !import_utils22.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
+  return receiver.type === import_utils22.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS2.has(receiver.name) && !import_utils22.ASTUtils.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
 }
 
 // src/rules/_test-mock-provenance.ts
@@ -5526,7 +5539,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "18.0.0",
+  version: "18.0.3",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -7958,7 +7971,7 @@ var no_known_value_widening_default = createRule({
 
 // src/rules/no-invalid-typed-mutation.ts
 var import_utils53 = require("@typescript-eslint/utils");
-var import_ts_api_utils2 = require("ts-api-utils");
+var import_ts_api_utils3 = require("ts-api-utils");
 var import_typescript20 = __toESM(require("typescript"), 1);
 var NO_INVALID_TYPED_MUTATION_DOCUMENTATION = {
   summary: "Keep native object mutation APIs from writing incompatible values into declared property types.",
@@ -8129,7 +8142,7 @@ function typedDataProperty(property) {
 function propertyWriteType(target, property, node, checker, exact) {
   const exposed = checker.getTypeOfSymbolAtLocation(property, node);
   if (!exact || (property.flags & import_typescript20.default.SymbolFlags.Optional) === 0 || (property.flags & import_typescript20.default.SymbolFlags.Transient) !== 0) return exposed;
-  if ((target.aliasTypeArguments?.length ?? 0) > 0 || (0, import_ts_api_utils2.isTypeReference)(target) && checker.getTypeArguments(target).length > 0 || (0, import_ts_api_utils2.isObjectType)(target) && (target.objectFlags & (import_typescript20.default.ObjectFlags.Mapped | import_typescript20.default.ObjectFlags.Instantiated)) !== 0) return exposed;
+  if ((target.aliasTypeArguments?.length ?? 0) > 0 || (0, import_ts_api_utils3.isTypeReference)(target) && checker.getTypeArguments(target).length > 0 || (0, import_ts_api_utils3.isObjectType)(target) && (target.objectFlags & (import_typescript20.default.ObjectFlags.Mapped | import_typescript20.default.ObjectFlags.Instantiated)) !== 0) return exposed;
   const declaration = property.getDeclarations()?.[0];
   if (declaration === void 0 || !(import_typescript20.default.isPropertySignature(declaration) || import_typescript20.default.isPropertyDeclaration(declaration)) || declaration.questionToken === void 0 || declaration.type === void 0) return exposed;
   const authored = checker.getTypeFromTypeNode(declaration.type);
@@ -8142,10 +8155,10 @@ function definiteType(type, checker, seen = /* @__PURE__ */ new Set()) {
   const unsafe = import_typescript20.default.TypeFlags.Any | import_typescript20.default.TypeFlags.Unknown | import_typescript20.default.TypeFlags.Never | import_typescript20.default.TypeFlags.TypeParameter | import_typescript20.default.TypeFlags.Conditional | import_typescript20.default.TypeFlags.IndexedAccess | import_typescript20.default.TypeFlags.Substitution;
   if ((type.flags & unsafe) !== 0) return false;
   if (type.isUnionOrIntersection()) return type.types.every((part) => definiteType(part, checker, seen));
-  const arguments_ = (0, import_ts_api_utils2.isTypeReference)(type) ? checker.getTypeArguments(type) : type.aliasTypeArguments ?? [];
+  const arguments_ = (0, import_ts_api_utils3.isTypeReference)(type) ? checker.getTypeArguments(type) : type.aliasTypeArguments ?? [];
   if (!arguments_.every((argument) => definiteType(argument, checker, seen))) return false;
   if (!definiteSignatures(type, checker, seen)) return false;
-  if ((0, import_ts_api_utils2.isTypeReference)(type) || (type.flags & import_typescript20.default.TypeFlags.Object) === 0) return true;
+  if ((0, import_ts_api_utils3.isTypeReference)(type) || (type.flags & import_typescript20.default.TypeFlags.Object) === 0) return true;
   return type.getProperties().every((property) => {
     const declaration = property.valueDeclaration ?? property.getDeclarations()?.[0];
     return declaration !== void 0 && definiteType(checker.getTypeOfSymbolAtLocation(property, declaration), checker, seen);
@@ -8246,7 +8259,7 @@ function hasSeparatePredicateContract(node, checker) {
 // src/rules/_contradictory-array-predicate.ts
 var import_utils54 = require("@typescript-eslint/utils");
 var import_typescript22 = __toESM(require("typescript"), 1);
-var import_ts_api_utils3 = require("ts-api-utils");
+var import_ts_api_utils4 = require("ts-api-utils");
 var HOST_GLOBALS = ["globalThis", "window", "self", "global"];
 var PRIMITIVE_ELEMENTS = import_typescript22.default.TypeFlags.String | import_typescript22.default.TypeFlags.Number | import_typescript22.default.TypeFlags.Boolean | import_typescript22.default.TypeFlags.BigInt | import_typescript22.default.TypeFlags.ESSymbol;
 var OBJECT_REFLECTION2 = /* @__PURE__ */ new Set(["getPrototypeOf", "getOwnPropertyDescriptor", "getOwnPropertyDescriptors", "prototype", "constructor", "__proto__"]);
@@ -8281,7 +8294,7 @@ function contradictoryArrayPredicate(sourceCode, services) {
   };
 }
 function plainPrimitiveArray(target, checker) {
-  if (!checker.isArrayType(target) || !(0, import_ts_api_utils3.isTypeReference)(target)) return false;
+  if (!checker.isArrayType(target) || !(0, import_ts_api_utils4.isTypeReference)(target)) return false;
   const [element] = checker.getTypeArguments(target);
   return element !== void 0 && (element.flags & PRIMITIVE_ELEMENTS) !== 0 && (element.flags & (import_typescript22.default.TypeFlags.Enum | import_typescript22.default.TypeFlags.EnumLiteral | import_typescript22.default.TypeFlags.Intersection)) === 0;
 }
@@ -8565,7 +8578,7 @@ function primitiveKind(type, allowLiterals) {
 
 // src/rules/no-partial-type-predicate.ts
 var import_utils57 = require("@typescript-eslint/utils");
-var import_ts_api_utils4 = require("ts-api-utils");
+var import_ts_api_utils5 = require("ts-api-utils");
 var import_typescript25 = __toESM(require("typescript"), 1);
 
 // src/rules/_uuid-predicate-witness.ts
@@ -8737,7 +8750,7 @@ function primitiveKind2(type) {
   return void 0;
 }
 function numericWitnessInInput(value, input) {
-  return (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & (import_typescript25.default.TypeFlags.Unknown | import_typescript25.default.TypeFlags.Number)) !== 0 || Number.isFinite(value) && (0, import_ts_api_utils4.isNumberLiteralType)(member3) && member3.value === value);
+  return (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & (import_typescript25.default.TypeFlags.Unknown | import_typescript25.default.TypeFlags.Number)) !== 0 || Number.isFinite(value) && (0, import_ts_api_utils5.isNumberLiteralType)(member3) && member3.value === value);
 }
 function returnedExpression2(node) {
   if (node.body === void 0) return void 0;
@@ -9323,7 +9336,7 @@ function isDirectTest(identifier) {
 
 // src/rules/no-invalid-zod-custom-parse.ts
 var import_utils61 = require("@typescript-eslint/utils");
-var import_ts_api_utils5 = require("ts-api-utils");
+var import_ts_api_utils6 = require("ts-api-utils");
 var import_typescript27 = __toESM(require("typescript"), 1);
 var NO_INVALID_ZOD_CUSTOM_PARSE_DOCUMENTATION = {
   summary: "Do not parse an incompatible primitive literal through an unvalidated Zod custom schema.",
@@ -9419,10 +9432,10 @@ function primitiveDomain(type) {
 function acceptsPrimitive(type, value) {
   if (type.isUnion()) return type.types.some((member3) => acceptsPrimitive(member3, value));
   if (value === null) return (type.flags & import_typescript27.default.TypeFlags.Null) !== 0;
-  if (typeof value === "string") return (type.flags & import_typescript27.default.TypeFlags.String) !== 0 || (0, import_ts_api_utils5.isStringLiteralType)(type) && type.value === value;
-  if (typeof value === "number") return (type.flags & import_typescript27.default.TypeFlags.Number) !== 0 || (0, import_ts_api_utils5.isNumberLiteralType)(type) && type.value === value;
-  if (typeof value === "boolean") return (0, import_ts_api_utils5.isBooleanLiteralType)(type) && type.intrinsicName === String(value);
-  return (type.flags & import_typescript27.default.TypeFlags.BigInt) !== 0 || (0, import_ts_api_utils5.isBigIntLiteralType)(type) && bigintValue(type) === value;
+  if (typeof value === "string") return (type.flags & import_typescript27.default.TypeFlags.String) !== 0 || (0, import_ts_api_utils6.isStringLiteralType)(type) && type.value === value;
+  if (typeof value === "number") return (type.flags & import_typescript27.default.TypeFlags.Number) !== 0 || (0, import_ts_api_utils6.isNumberLiteralType)(type) && type.value === value;
+  if (typeof value === "boolean") return (0, import_ts_api_utils6.isBooleanLiteralType)(type) && type.intrinsicName === String(value);
+  return (type.flags & import_typescript27.default.TypeFlags.BigInt) !== 0 || (0, import_ts_api_utils6.isBigIntLiteralType)(type) && bigintValue(type) === value;
 }
 function bigintValue(type) {
   return BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`);
@@ -14808,7 +14821,7 @@ var NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION = {
     }
   ]
 };
-var GLOBAL_RECEIVERS2 = /* @__PURE__ */ new Set([
+var GLOBAL_RECEIVERS3 = /* @__PURE__ */ new Set([
   "globalThis",
   "self",
   "window"
@@ -14855,7 +14868,7 @@ var no_detached_global_fetch_default = createRule({
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalReceiver(node) {
-      return node.type === import_utils92.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS2.has(node.name) && resolvesToGlobal(node);
+      return node.type === import_utils92.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS3.has(node.name) && resolvesToGlobal(node);
     }
     function recordAlias(identifier) {
       const variable = bindingOf(identifier);
@@ -14914,7 +14927,7 @@ var no_detached_global_fetch_default = createRule({
         return false;
       if (node.type !== import_utils92.AST_NODE_TYPES.Identifier || !resolvesToGlobal(node))
         return false;
-      return GLOBAL_RECEIVERS2.has(node.name) || node.name === "undefined";
+      return GLOBAL_RECEIVERS3.has(node.name) || node.name === "undefined";
     }
     return {
       AssignmentExpression(node) {
@@ -16202,7 +16215,7 @@ var EQUALITY_OPERATORS = /* @__PURE__ */ new Set([
   "==",
   "==="
 ]);
-var PRIMITIVE_FLAGS = import_typescript29.default.TypeFlags.BigIntLike | import_typescript29.default.TypeFlags.BooleanLike | import_typescript29.default.TypeFlags.ESSymbolLike | import_typescript29.default.TypeFlags.Never | import_typescript29.default.TypeFlags.Null | import_typescript29.default.TypeFlags.NumberLike | import_typescript29.default.TypeFlags.StringLike | import_typescript29.default.TypeFlags.Undefined | import_typescript29.default.TypeFlags.Void;
+var PRIMITIVE_FLAGS2 = import_typescript29.default.TypeFlags.BigIntLike | import_typescript29.default.TypeFlags.BooleanLike | import_typescript29.default.TypeFlags.ESSymbolLike | import_typescript29.default.TypeFlags.Never | import_typescript29.default.TypeFlags.Null | import_typescript29.default.TypeFlags.NumberLike | import_typescript29.default.TypeFlags.StringLike | import_typescript29.default.TypeFlags.Undefined | import_typescript29.default.TypeFlags.Void;
 function unwrapComparisonExpression(node) {
   let current = unwrapExpression(node);
   while (current.type === import_utils98.AST_NODE_TYPES.ChainExpression) {
@@ -16256,7 +16269,7 @@ function typeMayContainObject(type, checker) {
   if (type.isUnionOrIntersection()) {
     return type.types.some((member3) => typeMayContainObject(member3, checker));
   }
-  if ((type.flags & PRIMITIVE_FLAGS) !== 0) return false;
+  if ((type.flags & PRIMITIVE_FLAGS2) !== 0) return false;
   if ((type.flags & (import_typescript29.default.TypeFlags.Any | import_typescript29.default.TypeFlags.Unknown | import_typescript29.default.TypeFlags.TypeParameter)) !== 0) {
     return true;
   }
@@ -33451,7 +33464,7 @@ var import_utils182 = require("@typescript-eslint/utils");
 var import_typescript34 = __toESM(require("typescript"), 1);
 
 // src/rules/_equivalent-zod-output-contracts.ts
-var import_ts_api_utils6 = require("ts-api-utils");
+var import_ts_api_utils7 = require("ts-api-utils");
 var import_typescript32 = __toESM(require("typescript"), 1);
 var MAX_CONTRACT_PAIRS = 128;
 var MAX_UNION_MEMBERS = 16;
@@ -33480,8 +33493,8 @@ function seenPair(comparison2, left, right) {
 function equivalentPair(comparison2, left, right) {
   if (!mutuallyAssignable(comparison2.checker, left, right)) return false;
   if (left.isUnion() || right.isUnion()) return equivalentUnions(comparison2, left, right);
-  const leftContainer = comparison2.checker.isArrayType(left) || (0, import_ts_api_utils6.isTupleTypeReference)(left);
-  const rightContainer = comparison2.checker.isArrayType(right) || (0, import_ts_api_utils6.isTupleTypeReference)(right);
+  const leftContainer = comparison2.checker.isArrayType(left) || (0, import_ts_api_utils7.isTupleTypeReference)(left);
+  const rightContainer = comparison2.checker.isArrayType(right) || (0, import_ts_api_utils7.isTupleTypeReference)(right);
   if (leftContainer || rightContainer) return equivalentContainers(comparison2, left, right);
   if (hasClassDeclaration(left) || hasClassDeclaration(right)) return false;
   if (!objectLike(left) || !objectLike(right)) return false;
@@ -33510,9 +33523,9 @@ function queuePair(comparison2, left, right) {
   return true;
 }
 function equivalentContainers(comparison2, left, right) {
-  if (!(0, import_ts_api_utils6.isTypeReference)(left) || !(0, import_ts_api_utils6.isTypeReference)(right)) return false;
-  const leftTuple = (0, import_ts_api_utils6.isTupleTypeReference)(left);
-  const rightTuple = (0, import_ts_api_utils6.isTupleTypeReference)(right);
+  if (!(0, import_ts_api_utils7.isTypeReference)(left) || !(0, import_ts_api_utils7.isTypeReference)(right)) return false;
+  const leftTuple = (0, import_ts_api_utils7.isTupleTypeReference)(left);
+  const rightTuple = (0, import_ts_api_utils7.isTupleTypeReference)(right);
   if (leftTuple !== rightTuple) return false;
   if (leftTuple && rightTuple && (left.target.readonly !== right.target.readonly || left.target.elementFlags.length !== right.target.elementFlags.length || left.target.elementFlags.some((flag, index) => flag !== right.target.elementFlags[index]))) return false;
   const leftIndex = comparison2.checker.getIndexInfoOfType(left, import_typescript32.default.IndexKind.Number);
@@ -33550,7 +33563,7 @@ function equivalentProperty(comparison2, left, right, property, other) {
   const { checker } = comparison2;
   if (opaqueProperty(property) || opaqueProperty(other)) return false;
   if ((property.flags & import_typescript32.default.SymbolFlags.Optional) !== (other.flags & import_typescript32.default.SymbolFlags.Optional)) return false;
-  if ((0, import_ts_api_utils6.isPropertyReadonlyInType)(left, property.getEscapedName(), checker) !== (0, import_ts_api_utils6.isPropertyReadonlyInType)(right, other.getEscapedName(), checker)) return false;
+  if ((0, import_ts_api_utils7.isPropertyReadonlyInType)(left, property.getEscapedName(), checker) !== (0, import_ts_api_utils7.isPropertyReadonlyInType)(right, other.getEscapedName(), checker)) return false;
   const declaration = property.valueDeclaration ?? property.getDeclarations()?.[0];
   const otherDeclaration = other.valueDeclaration ?? other.getDeclarations()?.[0];
   return declaration !== void 0 && otherDeclaration !== void 0 && queuePair(

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/rules/no-logical-or-fallback.ts
-import { ASTUtils, AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+import { ASTUtils, AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 import { isBigIntLiteralType, isBooleanLiteralType } from "ts-api-utils";
 import ts from "typescript";
 
@@ -539,7 +539,30 @@ function commentLineEnd(sourceText, start) {
   return end === -1 ? sourceText.length : start + end;
 }
 
+// src/rules/_unwrap-expression.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+function unwrapExpression(node) {
+  while (isErasedExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function outerExpression(node) {
+  while (node.parent !== void 0 && node.parent !== null && isErasedExpression(node.parent) && node.parent.expression === node) node = node.parent;
+  return node;
+}
+function directArgumentCall(node) {
+  const argument = outerExpression(node);
+  const call = argument.parent;
+  return call?.type === AST_NODE_TYPES2.CallExpression && call.arguments.some((item) => item === argument) ? call : null;
+}
+function isErasedExpression(node) {
+  return node.type === AST_NODE_TYPES2.TSAsExpression || node.type === AST_NODE_TYPES2.TSSatisfiesExpression || node.type === AST_NODE_TYPES2.TSNonNullExpression || node.type === AST_NODE_TYPES2.TSTypeAssertion;
+}
+
 // src/rules/no-logical-or-fallback.ts
+var PRIMITIVE_FLAGS = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike;
+var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "window", "self"]);
 var NO_LOGICAL_OR_FALLBACK_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Use nullish defaults or explicit falsy-value checks instead of logical OR fallbacks.",
@@ -548,8 +571,8 @@ var NO_LOGICAL_OR_FALLBACK_DOCUMENTATION = {
   category: "correctness",
   autofix: "none",
   limitations: [
-    "Requires TypeScript type information and strict null checks. Reports non-nullable string, number or bigint value fallbacks, including mixed primitive unions. Nullable inputs remain owned by @typescript-eslint/prefer-nullish-coalescing; both rules are enabled in the managed strict config.",
-    "Preserves boolean aggregation, conditions, negations, left-hand && guards, and calls to the unshadowed Boolean constructor. Constant truthiness stays with no-unnecessary-condition. Unknown, any, generic, object-only and generated inputs are excluded. Strings and comments are never scanned as code.",
+    "Requires TypeScript type information and strict null checks. Reports non-nullable string, number or bigint value fallbacks, including branded primitives and mixed primitive unions. Nullable inputs, including nullable booleans, remain owned by @typescript-eslint/prefer-nullish-coalescing; both rules are enabled in the managed strict config.",
+    "Preserves non-nullable boolean aggregation, conditions, negations, left-hand && guards, and calls to the native unshadowed Boolean constructor, including erased TypeScript wrappers and globalThis/window/self access. Constant truthiness stays with no-unnecessary-condition. Unknown, any, unresolved generic, object-only and generated inputs are excluded. Strings and comments are never scanned as code.",
     "No automatic replacement is offered: replacing || with ?? would change empty-string or zero behavior. Non-nullable ||= expressions remain outside this companion rule."
   ],
   references: ["https://typescript-eslint.io/rules/prefer-nullish-coalescing/"],
@@ -577,83 +600,72 @@ var no_logical_or_fallback_default = createRule({
     if (!(options.strictNullChecks ?? options.strict ?? false)) return {};
     return {
       LogicalExpression(node) {
-        if (node.operator !== "||" || booleanContext(node, context.sourceCode)) return;
+        if (node.operator !== "||" || booleanContext(node, context.sourceCode, services)) return;
         const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node.left));
-        const members = type.isUnion() ? type.types : [type];
-        const primitiveFlags = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike;
-        if (!members.every((member3) => (member3.flags & primitiveFlags) !== 0) || !members.some((member3) => (member3.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike)) !== 0)) return;
-        const truthiness = members.map(literalTruthiness);
+        const members = (type.isUnion() ? type.types : [type]).map(primitivePart);
+        if (members.some((member3) => member3 === void 0) || !members.some((member3) => member3 !== void 0 && (member3.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike)) !== 0)) return;
+        const truthiness = members.map((member3) => member3 === void 0 ? void 0 : literalTruthiness(member3));
         if (truthiness.every((value) => value === true) || truthiness.every((value) => value === false)) return;
         context.report({ node, messageId: "logicalOrFallback" });
       }
     };
   }
 });
+function primitivePart(type) {
+  if ((type.flags & PRIMITIVE_FLAGS) !== 0) return type;
+  if (!type.isIntersection() || type.types.some((member3) => (member3.flags & ts.TypeFlags.TypeParameter) !== 0)) return void 0;
+  return type.types.find((member3) => (member3.flags & PRIMITIVE_FLAGS) !== 0);
+}
 function literalTruthiness(type) {
   if (type.isStringLiteral() || type.isNumberLiteral()) return Boolean(type.value);
   if (isBooleanLiteralType(type)) return type.intrinsicName === "true";
   if (isBigIntLiteralType(type)) return type.value.base10Value !== "0";
   return void 0;
 }
-function booleanContext(node, source) {
-  let current = node;
+function booleanContext(node, source, services) {
+  let current = outerExpression(node);
   while (current.parent !== void 0) {
     const parent = current.parent;
     switch (parent.type) {
-      case AST_NODE_TYPES2.TSAsExpression:
-      case AST_NODE_TYPES2.TSSatisfiesExpression:
-      case AST_NODE_TYPES2.TSNonNullExpression:
-        current = parent;
-        continue;
-      case AST_NODE_TYPES2.LogicalExpression:
+      case AST_NODE_TYPES3.LogicalExpression:
         if (parent.operator === "&&" && parent.left === current) return true;
-        current = parent;
+        current = outerExpression(parent);
         continue;
-      case AST_NODE_TYPES2.IfStatement:
-      case AST_NODE_TYPES2.WhileStatement:
-      case AST_NODE_TYPES2.DoWhileStatement:
-      case AST_NODE_TYPES2.ForStatement:
-      case AST_NODE_TYPES2.ConditionalExpression:
+      case AST_NODE_TYPES3.IfStatement:
+      case AST_NODE_TYPES3.WhileStatement:
+      case AST_NODE_TYPES3.DoWhileStatement:
+      case AST_NODE_TYPES3.ForStatement:
+      case AST_NODE_TYPES3.ConditionalExpression:
         return parent.test === current;
-      case AST_NODE_TYPES2.UnaryExpression:
+      case AST_NODE_TYPES3.UnaryExpression:
         return parent.operator === "!";
-      case AST_NODE_TYPES2.CallExpression:
-        return parent.callee.type === AST_NODE_TYPES2.Identifier && parent.callee.name === "Boolean" && parent.arguments[0] === current && ASTUtils.findVariable(source.getScope(parent.callee), "Boolean")?.defs.length === 0;
+      case AST_NODE_TYPES3.CallExpression:
+        return parent.arguments[0] === current && nativeBoolean(parent.callee, source, services);
       default:
         return false;
     }
   }
   return false;
 }
-
-// src/rules/no-zod-parse-typed-object.ts
-import { ASTUtils as ASTUtils2, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
-import ts2 from "typescript";
-
-// src/rules/_unwrap-expression.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
-function unwrapExpression(node) {
-  while (isErasedExpression(node)) {
-    node = node.expression;
+function nativeBoolean(node, source, services) {
+  const callee = unwrapExpression(node);
+  const checker = services.program.getTypeChecker();
+  let symbol;
+  if (callee.type === AST_NODE_TYPES3.Identifier && callee.name === "Boolean" && !ASTUtils.findVariable(source.getScope(callee), callee.name)?.defs.length) {
+    symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(callee));
+  } else if (callee.type === AST_NODE_TYPES3.MemberExpression && ASTUtils.getPropertyName(callee) === "Boolean") {
+    const receiver = unwrapExpression(callee.object);
+    if (receiver.type !== AST_NODE_TYPES3.Identifier || !GLOBAL_RECEIVERS.has(receiver.name) || ASTUtils.findVariable(source.getScope(receiver), receiver.name)?.defs.length) return false;
+    symbol = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(receiver)).getProperty("Boolean");
   }
-  return node;
-}
-function outerExpression(node) {
-  while (node.parent !== void 0 && node.parent !== null && isErasedExpression(node.parent) && node.parent.expression === node) node = node.parent;
-  return node;
-}
-function directArgumentCall(node) {
-  const argument = outerExpression(node);
-  const call = argument.parent;
-  return call?.type === AST_NODE_TYPES3.CallExpression && call.arguments.some((item) => item === argument) ? call : null;
-}
-function isErasedExpression(node) {
-  return node.type === AST_NODE_TYPES3.TSAsExpression || node.type === AST_NODE_TYPES3.TSSatisfiesExpression || node.type === AST_NODE_TYPES3.TSNonNullExpression || node.type === AST_NODE_TYPES3.TSTypeAssertion;
+  return symbol?.declarations !== void 0 && symbol.declarations.length > 0 && symbol.declarations.every((declaration) => services.program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
 }
 
 // src/rules/no-zod-parse-typed-object.ts
+import { ASTUtils as ASTUtils2, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+import { isTupleTypeReference } from "ts-api-utils";
+import ts2 from "typescript";
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "parseAsync", "safeParse", "safeParseAsync"]);
-var TUPLE_INDEX_RE = /^(?:0|[1-9]\d*)$/u;
 var OPAQUE_FLAGS = ts2.TypeFlags.Any | ts2.TypeFlags.Unknown | ts2.TypeFlags.Never | ts2.TypeFlags.TypeParameter | ts2.TypeFlags.Conditional | ts2.TypeFlags.IndexedAccess | ts2.TypeFlags.Intersection | ts2.TypeFlags.NonPrimitive;
 var NO_ZOD_PARSE_TYPED_OBJECT_DOCUMENTATION = {
   defaultLevel: "warning",
@@ -666,7 +678,7 @@ var NO_ZOD_PARSE_TYPED_OBJECT_DOCUMENTATION = {
     "Requires type information, strict null checks, and a native installed Zod parse, parseAsync, safeParse or safeParseAsync signature. Recognizes imported schemas, aliases, member access and awaited service results without guessing from names.",
     "Reports fully known object or array inputs assignable to the schema input, when schema input and output have the same value shape. Optional-to-required defaults are included; type-changing transforms, coercions, brands, incompatible contracts, primitive roots and nested any/unknown/generic contracts are excluded.",
     "Static types do not establish runtime trust or prove refinements and normalization redundant. This is an architectural warning with no automatic removal. Keep intentional validation at an unknown-data boundary or document an exact local suppression. Tests, stories and generated code are excluded.",
-    "Shape comparison ignores undefined introduced by optional properties and is bounded to 128 object pairs or visited input objects. Opaque or larger graphs are conservatively excluded."
+    "Shape comparison ignores undefined introduced by optional properties and checks tuple element types and rest positions. It is bounded to 128 object pairs, visited input objects, properties, tuple elements or primitive union alternatives; object unions have at most 16 alternatives. Opaque or larger graphs are conservatively excluded."
   ],
   references: ["https://zod.dev/basics"],
   examples: [
@@ -726,7 +738,11 @@ function knownValue(checker, type, location, seen) {
   if (seen.has(type)) return true;
   if (seen.size >= 128 || type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return false;
   seen.add(type);
-  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+  if (isTupleTypeReference(type)) {
+    const elements = checker.getTypeArguments(type);
+    return elements.length <= 128 && elements.every((element) => knownValue(checker, element, location, seen));
+  }
+  if (checker.isArrayType(type)) {
     const element = type.getNumberIndexType();
     return element !== void 0 && knownValue(checker, element, location, seen);
   }
@@ -742,7 +758,8 @@ function sameShape(checker, input, output, location) {
     if (left.isUnion() || right.isUnion()) {
       const a = (left.isUnion() ? left.types : [left]).filter((member3) => (member3.flags & ts2.TypeFlags.Undefined) === 0);
       const b = (right.isUnion() ? right.types : [right]).filter((member3) => (member3.flags & ts2.TypeFlags.Undefined) === 0);
-      return a.length > 0 && a.length === b.length && a.length <= 16 && a.every((member3) => b.some((other) => compare(member3, other))) && b.every((member3) => a.some((other) => compare(other, member3)));
+      const limit = [...a, ...b].every((member3) => (member3.flags & (ts2.TypeFlags.Object | OPAQUE_FLAGS)) === 0) ? 128 : 16;
+      return a.length > 0 && a.length === b.length && a.length <= limit && a.every((member3) => b.some((other) => compare(member3, other))) && b.every((member3) => a.some((other) => compare(other, member3)));
     }
     if ((left.flags & ts2.TypeFlags.Object) === 0 || (right.flags & ts2.TypeFlags.Object) === 0) {
       return checker.isTypeAssignableTo(left, right) && checker.isTypeAssignableTo(right, left);
@@ -760,9 +777,9 @@ function sameShape(checker, input, output, location) {
   function sameObjectShape(left, right) {
     const leftTuple = checker.isTupleType(left);
     const rightTuple = checker.isTupleType(right);
-    if (leftTuple !== rightTuple || leftTuple && !sameTuplePositions(left, right)) return false;
-    if (checker.isArrayType(left) || leftTuple) {
-      if (!checker.isArrayType(right) && !rightTuple) return false;
+    if (leftTuple || rightTuple) return leftTuple && rightTuple && sameTuplePositions(left, right);
+    if (checker.isArrayType(left)) {
+      if (!checker.isArrayType(right)) return false;
       const a2 = left.getNumberIndexType();
       const b2 = right.getNumberIndexType();
       return a2 !== void 0 && b2 !== void 0 && compare(a2, b2);
@@ -778,17 +795,13 @@ function sameShape(checker, input, output, location) {
     return a.length === b.length && a.every((index) => b.some((other) => checker.isTypeAssignableTo(index.keyType, other.keyType) && checker.isTypeAssignableTo(other.keyType, index.keyType) && compare(index.type, other.type)));
   }
   function sameTuplePositions(left, right) {
-    const leftLength = left.getProperty("length");
-    const rightLength = right.getProperty("length");
-    if (leftLength === void 0 || rightLength === void 0) return false;
-    const a = checker.getTypeOfSymbolAtLocation(leftLength, location);
-    const b = checker.getTypeOfSymbolAtLocation(rightLength, location);
-    if (!checker.isTypeAssignableTo(a, b) || !checker.isTypeAssignableTo(b, a)) return false;
-    const properties = left.getProperties().filter((property) => TUPLE_INDEX_RE.test(property.name));
-    const otherProperties = right.getProperties().filter((property) => TUPLE_INDEX_RE.test(property.name));
-    return properties.length <= 128 && properties.length === otherProperties.length && properties.every((property) => {
-      const other = right.getProperty(property.name);
-      return other !== void 0 && compare(checker.getTypeOfSymbolAtLocation(property, location), checker.getTypeOfSymbolAtLocation(other, location));
+    if (!isTupleTypeReference(left) || !isTupleTypeReference(right)) return false;
+    const a = checker.getTypeArguments(left);
+    const b = checker.getTypeArguments(right);
+    const flags = right.target.elementFlags;
+    return a.length <= 128 && a.length === b.length && left.target.elementFlags.every((flag, index) => flag === flags[index]) && a.every((element, index) => {
+      const other = b[index];
+      return other !== void 0 && compare(element, other);
     });
   }
   return compare(input, output);
@@ -837,7 +850,7 @@ function stableValueBinding(variable, acceptRead) {
 var VIEWS = /* @__PURE__ */ new WeakMap();
 function renderFunction(node) {
   let parent = node.parent;
-  while (parent !== void 0) {
+  while (parent !== void 0 && parent !== null) {
     if (isFunction(parent)) {
       let view = VIEWS.get(parent);
       if (view === void 0) {
@@ -2465,7 +2478,7 @@ function nativeRead(node, name) {
 }
 
 // src/rules/_native-fetch-reference.ts
-var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
+var GLOBAL_RECEIVERS2 = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
 function nativeFetchReference(node, sourceCode) {
   return lexicalFetchReference(node, sourceCode) && nativeRuntimeUnchanged(sourceCode, "fetch");
 }
@@ -2488,7 +2501,7 @@ function lexicalFetchReference(node, sourceCode, seen = /* @__PURE__ */ new Set(
 }
 function globalReceiver(node, sourceCode) {
   const receiver = unwrapExpression(node);
-  return receiver.type === AST_NODE_TYPES20.Identifier && GLOBAL_RECEIVERS.has(receiver.name) && !ASTUtils10.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
+  return receiver.type === AST_NODE_TYPES20.Identifier && GLOBAL_RECEIVERS2.has(receiver.name) && !ASTUtils10.findVariable(sourceCode.getScope(receiver), receiver.name)?.defs.length;
 }
 
 // src/rules/_test-mock-provenance.ts
@@ -5481,7 +5494,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "18.0.0",
+  version: "18.0.3",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -14769,7 +14782,7 @@ var NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION = {
     }
   ]
 };
-var GLOBAL_RECEIVERS2 = /* @__PURE__ */ new Set([
+var GLOBAL_RECEIVERS3 = /* @__PURE__ */ new Set([
   "globalThis",
   "self",
   "window"
@@ -14816,7 +14829,7 @@ var no_detached_global_fetch_default = createRule({
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalReceiver(node) {
-      return node.type === AST_NODE_TYPES85.Identifier && GLOBAL_RECEIVERS2.has(node.name) && resolvesToGlobal(node);
+      return node.type === AST_NODE_TYPES85.Identifier && GLOBAL_RECEIVERS3.has(node.name) && resolvesToGlobal(node);
     }
     function recordAlias(identifier) {
       const variable = bindingOf(identifier);
@@ -14875,7 +14888,7 @@ var no_detached_global_fetch_default = createRule({
         return false;
       if (node.type !== AST_NODE_TYPES85.Identifier || !resolvesToGlobal(node))
         return false;
-      return GLOBAL_RECEIVERS2.has(node.name) || node.name === "undefined";
+      return GLOBAL_RECEIVERS3.has(node.name) || node.name === "undefined";
     }
     return {
       AssignmentExpression(node) {
@@ -16163,7 +16176,7 @@ var EQUALITY_OPERATORS = /* @__PURE__ */ new Set([
   "==",
   "==="
 ]);
-var PRIMITIVE_FLAGS = ts30.TypeFlags.BigIntLike | ts30.TypeFlags.BooleanLike | ts30.TypeFlags.ESSymbolLike | ts30.TypeFlags.Never | ts30.TypeFlags.Null | ts30.TypeFlags.NumberLike | ts30.TypeFlags.StringLike | ts30.TypeFlags.Undefined | ts30.TypeFlags.Void;
+var PRIMITIVE_FLAGS2 = ts30.TypeFlags.BigIntLike | ts30.TypeFlags.BooleanLike | ts30.TypeFlags.ESSymbolLike | ts30.TypeFlags.Never | ts30.TypeFlags.Null | ts30.TypeFlags.NumberLike | ts30.TypeFlags.StringLike | ts30.TypeFlags.Undefined | ts30.TypeFlags.Void;
 function unwrapComparisonExpression(node) {
   let current = unwrapExpression(node);
   while (current.type === AST_NODE_TYPES90.ChainExpression) {
@@ -16217,7 +16230,7 @@ function typeMayContainObject(type, checker) {
   if (type.isUnionOrIntersection()) {
     return type.types.some((member3) => typeMayContainObject(member3, checker));
   }
-  if ((type.flags & PRIMITIVE_FLAGS) !== 0) return false;
+  if ((type.flags & PRIMITIVE_FLAGS2) !== 0) return false;
   if ((type.flags & (ts30.TypeFlags.Any | ts30.TypeFlags.Unknown | ts30.TypeFlags.TypeParameter)) !== 0) {
     return true;
   }
@@ -33440,7 +33453,7 @@ import { ASTUtils as ASTUtils111, AST_NODE_TYPES as AST_NODE_TYPES165 } from "@t
 import ts39 from "typescript";
 
 // src/rules/_equivalent-zod-output-contracts.ts
-import { isPropertyReadonlyInType, isTupleTypeReference, isTypeReference as isTypeReference3 } from "ts-api-utils";
+import { isPropertyReadonlyInType, isTupleTypeReference as isTupleTypeReference2, isTypeReference as isTypeReference3 } from "ts-api-utils";
 import ts37 from "typescript";
 var MAX_CONTRACT_PAIRS = 128;
 var MAX_UNION_MEMBERS = 16;
@@ -33469,8 +33482,8 @@ function seenPair(comparison2, left, right) {
 function equivalentPair(comparison2, left, right) {
   if (!mutuallyAssignable(comparison2.checker, left, right)) return false;
   if (left.isUnion() || right.isUnion()) return equivalentUnions(comparison2, left, right);
-  const leftContainer = comparison2.checker.isArrayType(left) || isTupleTypeReference(left);
-  const rightContainer = comparison2.checker.isArrayType(right) || isTupleTypeReference(right);
+  const leftContainer = comparison2.checker.isArrayType(left) || isTupleTypeReference2(left);
+  const rightContainer = comparison2.checker.isArrayType(right) || isTupleTypeReference2(right);
   if (leftContainer || rightContainer) return equivalentContainers(comparison2, left, right);
   if (hasClassDeclaration(left) || hasClassDeclaration(right)) return false;
   if (!objectLike(left) || !objectLike(right)) return false;
@@ -33500,8 +33513,8 @@ function queuePair(comparison2, left, right) {
 }
 function equivalentContainers(comparison2, left, right) {
   if (!isTypeReference3(left) || !isTypeReference3(right)) return false;
-  const leftTuple = isTupleTypeReference(left);
-  const rightTuple = isTupleTypeReference(right);
+  const leftTuple = isTupleTypeReference2(left);
+  const rightTuple = isTupleTypeReference2(right);
   if (leftTuple !== rightTuple) return false;
   if (leftTuple && rightTuple && (left.target.readonly !== right.target.readonly || left.target.elementFlags.length !== right.target.elementFlags.length || left.target.elementFlags.some((flag, index) => flag !== right.target.elementFlags[index]))) return false;
   const leftIndex = comparison2.checker.getIndexInfoOfType(left, ts37.IndexKind.Number);

package/package.json

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