@sarj/eslint-plugin 18.2.0 → 18.3.0

package/dist/index.cjs

@@ -49,9 +49,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/rules/prefer-zod-enum-validator.ts
-var import_utils5 = require("@typescript-eslint/utils");
-
 // src/rules/_eslint-rule.ts
 var import_utils2 = require("@typescript-eslint/utils");
 
@@ -538,21 +535,21 @@ function validateExpectedSuggestion(value, exampleId, messageIds) {
   assertFields(value, ["messageId", "output"], exampleId);
 }
 function validateExpectedLocation(value, exampleId) {
-  if (!isObject(value) || !("line" in value) || !positiveCoordinate(value.line) || !("column" in value) || !positiveCoordinate(value.column)) {
+  if (!isObject(value) || !("line" in value) || typeof value.line !== "number" || !positiveCoordinate(value.line) || !("column" in value) || typeof value.column !== "number" || !positiveCoordinate(value.column)) {
     throw new TypeError(`${exampleId}: expected diagnostic location requires positive integer coordinates`);
   }
   if (!("end" in value)) {
     assertFields(value, ["line", "column"], exampleId);
     return;
   }
-  if (!isObject(value.end) || !("line" in value.end) || !positiveCoordinate(value.end.line) || !("column" in value.end) || !positiveCoordinate(value.end.column) || value.end.line < value.line || value.end.line === value.line && value.end.column < value.column) {
+  if (!isObject(value.end) || !("line" in value.end) || typeof value.end.line !== "number" || !positiveCoordinate(value.end.line) || !("column" in value.end) || typeof value.end.column !== "number" || !positiveCoordinate(value.end.column) || value.end.line < value.line || value.end.line === value.line && value.end.column < value.column) {
     throw new TypeError(`${exampleId}: expected diagnostic end point must be complete and ordered`);
   }
   assertFields(value.end, ["line", "column"], exampleId);
   assertFields(value, ["line", "column", "end"], exampleId);
 }
 function positiveCoordinate(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+  return Number.isSafeInteger(value) && value >= 1;
 }
 function assertFields(value, expected, exampleId) {
   const fields2 = Object.keys(value);
@@ -704,6 +701,56 @@ function commentLineEnd(sourceText, start) {
   return end === -1 ? sourceText.length : start + end;
 }
 
+// src/rules/no-explicit-type-predicate.ts
+var NO_EXPLICIT_TYPE_PREDICATE_DOCUMENTATION = {
+  defaultLevel: "warning",
+  summary: "Use compiler-checked narrowing instead of handwritten type predicates.",
+  rationale: "TypeScript trusts an explicit value is Type annotation without proving that its implementation recognizes that type in both branches. A stale or partial predicate can make callers read properties that do not exist. Direct discriminator checks and inferred predicates keep narrowing tied to the implementation.",
+  remediation: "For owned variants, check the discriminated union's tag directly or let TypeScript infer a simple discriminator helper or null filter. Parse unknown external data with a specific schema and consume its validated value or discriminated result. Do not replace a predicate with a cast or a schema boolean wrapper that repeats the same unchecked type claim. If a native API cannot express the required static contract, isolate that boundary and use an exact-rule local suppression explaining the constraint.",
+  category: "maintainability",
+  autofix: "none",
+  requiresTypeInformation: false,
+  limitations: [
+    "This is an explicit design policy, including otherwise correct handwritten predicates. Reports every authored TypeScript is predicate, including asserts value is Type, method and callback annotations, function types, overloads, ambient signatures and predicates inside casts or satisfies expressions.",
+    "Direct discriminator checks, compiler-inferred predicates, ordinary boolean returns and plain asserts condition remain valid. A tag on unknown input does not validate its payload. Imported library guard calls and imported predicate types are not redeclarations and are not inspected.",
+    "Shared generated, vendored and declaration-file exclusions apply. Maintained test implementations remain checked; strings, comments and JSDoc text are not TypeScript predicate nodes. There is no exemption based on helper names, imports or body shape.",
+    "No automatic fix or suggestion removes an annotation: public and callback contracts, overloads, both narrowing branches, emitted declarations and existing TypeScript versions may depend on it. Review callers and preserve intentional runtime behavior when migrating. Existing partial and contradictory predicate rules retain their separate correctness checks."
+  ],
+  references: [
+    "https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions",
+    "https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#inferred-type-predicates",
+    "https://zod.dev/basics"
+  ],
+  examples: [
+    { id: "manual-predicate", title: "Avoid an unchecked narrowing annotation", outcome: "match", files: [{ path: "src/job.ts", source: "type Job = { kind: 'queued'; queue: string } | { kind: 'done'; result: string }; type Done = Extract<Job, {kind: 'done'}>; function isDone(job: Job): job is Done { return job.kind === 'done'; } function render(job: Job) { return isDone(job) ? job.result : job.queue; }" }], focusPath: "src/job.ts", expectedCount: 1, public: true },
+    { id: "direct-discriminator", title: "Let the compiler narrow the tagged union", outcome: "no-match", files: [{ path: "src/job.ts", source: "type Job = { kind: 'queued'; queue: string } | { kind: 'done'; result: string }; function render(job: Job) { return job.kind === 'done' ? job.result : job.queue; }" }], focusPath: "src/job.ts", expectedCount: 0, public: true },
+    { id: "inferred-predicate", scenarioId: "inference", title: "Infer a discriminator helper from its body", outcome: "no-match", files: [{ path: "src/job.ts", source: "type Job = { kind: 'queued'; queue: string } | { kind: 'done'; result: string }; const isDone = (job: Job) => job.kind === 'done';" }], focusPath: "src/job.ts", expectedCount: 0, public: true },
+    { id: "written-predicate", scenarioId: "inference", title: "A written predicate remains an unchecked promise", outcome: "match", files: [{ path: "src/job.ts", source: "type Job = { kind: 'queued'; queue: string } | { kind: 'done'; result: string }; type Done = Extract<Job, {kind: 'done'}>; const isDone = (job: Job): job is Done => job.kind === 'done';" }], focusPath: "src/job.ts", expectedCount: 1, public: true }
+  ]
+};
+var no_explicit_type_predicate_default = createRule({
+  name: "no-explicit-type-predicate",
+  documentation: NO_EXPLICIT_TYPE_PREDICATE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: NO_EXPLICIT_TYPE_PREDICATE_DOCUMENTATION.summary },
+    schema: [],
+    messages: { noExplicitTypePredicate: "Replace this handwritten type predicate with a direct discriminator check or compiler-inferred narrowing. Parse unknown data with a schema and consume the validated result; preserve required external callable contracts." }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context, context.sourceCode.text)) return {};
+    return {
+      TSTypePredicate(node) {
+        if (node.typeAnnotation != null) context.report({ node, messageId: "noExplicitTypePredicate" });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-zod-enum-validator.ts
+var import_utils5 = require("@typescript-eslint/utils");
+
 // src/rules/_static-string.ts
 var import_utils4 = require("@typescript-eslint/utils");
 
@@ -1824,19 +1871,19 @@ function firstParameterBindings(source, node) {
 function collectParameterBindings(source, node) {
   if (hasDirectEval(source)) return /* @__PURE__ */ new Set();
   const parameter = node.params[0];
-  const identifiers = [];
+  const identifiers = /* @__PURE__ */ new Set();
   if (parameter?.type === import_utils14.AST_NODE_TYPES.Identifier)
-    identifiers.push(parameter);
+    identifiers.add(parameter);
   if (parameter?.type === import_utils14.AST_NODE_TYPES.ObjectPattern) {
     for (const property of parameter.properties) {
       if (property.type === import_utils14.AST_NODE_TYPES.Property && !property.computed && property.value.type === import_utils14.AST_NODE_TYPES.Identifier)
-        identifiers.push(property.value);
+        identifiers.add(property.value);
     }
   }
   return new Set(
     source.getDeclaredVariables(node).filter(
-      (variable) => identifiers.some(
-        (identifier) => variable.identifiers.includes(identifier)
+      (variable) => variable.identifiers.some(
+        (identifier) => identifiers.has(identifier)
       ) && stableValueBinding(variable)
     )
   );
@@ -1879,8 +1926,10 @@ function reactHook(source, callee, hook) {
   let identifier;
   let namespace = false;
   if (callee.type === import_utils14.AST_NODE_TYPES.Identifier) identifier = callee;
-  else if (callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils14.ASTUtils.getPropertyName(callee) === hook && callee.object.type === import_utils14.AST_NODE_TYPES.Identifier) {
-    identifier = callee.object;
+  else if (callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && !callee.optional && import_utils14.ASTUtils.getPropertyName(callee) === hook) {
+    const object = unwrapExpression(callee.object);
+    if (object.type !== import_utils14.AST_NODE_TYPES.Identifier) return false;
+    identifier = object;
     namespace = true;
   } else return false;
   const variable = import_utils14.ASTUtils.findVariable(
@@ -1888,17 +1937,33 @@ function reactHook(source, callee, hook) {
     identifier.name
   );
   if (variable === null) return false;
-  const specifier = reactImportSpecifier(variable);
-  if (specifier === null) return false;
-  return namespace ? specifier.type === import_utils14.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier : specifier.type === import_utils14.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type" && importSpecifierName(specifier) === hook;
-}
-function reactImportSpecifier(variable) {
-  let specifier = REACT_IMPORTS.get(variable);
-  if (specifier !== void 0) return specifier;
+  const imported = reactImport(variable);
+  if (imported === null) return false;
+  const { specifier, replacedMembers } = imported;
+  return namespace ? (specifier.type === import_utils14.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier) && replacedMembers?.has(null) !== true && replacedMembers?.has(hook) !== true : specifier.type === import_utils14.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type" && importSpecifierName(specifier) === hook;
+}
+function reactImport(variable) {
+  let imported = REACT_IMPORTS.get(variable);
+  if (imported !== void 0) return imported;
   const definition = variable.defs[0];
-  specifier = variable.defs.length === 1 && definition?.type === "ImportBinding" && definition.parent.type === import_utils14.AST_NODE_TYPES.ImportDeclaration && definition.parent.source.value === "react" && definition.parent.importKind !== "type" && stableValueBinding(variable) ? definition.node : null;
-  REACT_IMPORTS.set(variable, specifier);
-  return specifier;
+  imported = null;
+  if (variable.defs.length === 1 && definition?.type === "ImportBinding" && definition.parent.type === import_utils14.AST_NODE_TYPES.ImportDeclaration && definition.parent.source.value === "react" && definition.parent.importKind !== "type") {
+    const specifier = definition.node;
+    const replacedMembers = specifier.type === import_utils14.AST_NODE_TYPES.ImportSpecifier ? void 0 : /* @__PURE__ */ new Set();
+    if (stableValueBinding(variable, replacedMembers === void 0 ? void 0 : (reference) => {
+      const object = outerExpression(reference.identifier);
+      const member3 = object.parent;
+      if (member3?.type !== import_utils14.AST_NODE_TYPES.MemberExpression || member3.object !== object)
+        return true;
+      const target = outerExpression(member3);
+      if (target.parent?.type === import_utils14.AST_NODE_TYPES.MemberExpression && target.parent.object === target)
+        return true;
+      if (writtenMember(member3)) replacedMembers.add(import_utils14.ASTUtils.getPropertyName(member3));
+      return true;
+    })) imported = { specifier, replacedMembers };
+  }
+  REACT_IMPORTS.set(variable, imported);
+  return imported;
 }
 function containsView(node) {
   if (node.type === import_utils14.AST_NODE_TYPES.JSXElement || node.type === import_utils14.AST_NODE_TYPES.JSXFragment)
@@ -1953,6 +2018,7 @@ var PREFER_SERVER_DATA_PREPARATION_DOCUMENTATION = {
     "Advisory only. Local syntax cannot establish whether a caller is a Server Component, whether props change interactively or whether server preparation reduces the total cost. This rule is a review lead, never proof that code can be moved to the server. No automatic fix is provided.",
     "Requires an explicit use client directive and parser-owned TypeScript services resolving map/filter/flatMap to the standard Array or ReadonlyArray library signature. The receiver beneath erased wrappers must itself have an Array, ReadonlyArray or tuple type after nullish narrowing; casts from opaque or custom collections do not establish this. Subclass and structural collection types outside those native array types are excluded. The containing view must have an independent React useState/useReducer call or a native callable type on an intrinsic DOM onClick/onChange/onInput/onSubmit handler. Nullish, noncallable and opaque handler types do not establish interaction. Noninteractive boundaries remain owned by no-unnecessary-use-client; custom hooks and indirect client requirements are unsupported.",
     "Every runtime reference to the source parameter binding must be a supported native data projection or a field-only JSX display loop. Inputs also needed for editing, whole-record forwarding, lookup, mutation, other fields or opaque helpers are excluded. Files containing direct eval are excluded because it can observe or change lexical bindings; indirect eval and properties named eval do not establish lexical access. Only direct first-parameter paths and synchronous single-expression callbacks are supported. Whole-row identity maps and constant maps are excluded; supported projections must read a fixed input field.",
+    "Field-only object and dense array literals can form nested data shapes, including readonly tuples and flatMap outputs. Array holes, spreads, captured values and JSX outputs remain unsupported. Hook recognition follows erased namespace wrappers and excludes direct writes to the requested imported member; reflective or external API patches are not modeled.",
     "JSX-rendering callbacks are never reported as preparation findings. Callback calls, captured values, destructuring defaults/rest/nesting, async callbacks, event handlers, effects, memo callbacks, opaque helpers, dynamic/optional paths, custom collection signatures, missing type services, generated source and tests are excluded. First-parameter provenance is syntactic; annotations cannot prove absence of runtime getters or patched array methods. Analysis does not claim callback purity or preserve semantics of a hypothetical move.",
     "Reports the direct source projection once; chained operations with a call receiver are not independently reported. A static subprojection may still be prepared by its producer while a union with pending local edits remains in the client."
   ],
@@ -2107,6 +2173,10 @@ function projection(source, callback, mode = "data") {
       return inspect(node.left, depth + 1) && inspect(node.right, depth + 1);
     if (node.type === import_utils15.AST_NODE_TYPES.ConditionalExpression)
       return inspect(node.test, depth + 1) && inspect(node.consequent, depth + 1) && inspect(node.alternate, depth + 1);
+    if (node.type === import_utils15.AST_NODE_TYPES.ArrayExpression)
+      return node.elements.every(
+        (element) => element !== null && element.type !== import_utils15.AST_NODE_TYPES.SpreadElement && inspect(element, depth + 1)
+      );
     if (node.type === import_utils15.AST_NODE_TYPES.ObjectExpression)
       return node.properties.every(
         (property) => property.type === import_utils15.AST_NODE_TYPES.Property && property.kind === "init" && !property.method && !property.computed && inspect(property.value, depth + 1)
@@ -2191,8 +2261,9 @@ var NO_READONLY_PROP_STATE_DOCUMENTATION = {
   category: "correctness",
   limitations: [
     "Advisory only: initial snapshots can be intentional. There is no automatic fix because replacing state with current props changes how later updates behave.",
-    "Recognizes direct React useState imports and default/namespace member calls, including renamed imports, through lexical binding identity. Checks a direct array destructure in a function containing its own JSX and a direct first-parameter property path, or a zero-argument synchronous lazy initializer returning that path.",
+    "Recognizes direct React useState imports and default/namespace member calls, including renamed imports and erased wrappers around imported namespaces, through lexical binding identity. Checks a direct array destructure in a function containing its own JSX and a direct first-parameter property path, or a zero-argument synchronous lazy initializer returning that path.",
     "Eager initializers require parser-owned TypeScript services and primitive types, including unions composed entirely of primitives. Object and void types can hide callable values through structural assignment or ignored return values, so eager nonprimitive values, Any, unknown and unresolved generics are excluded. React executes function arguments as lazy initializers. Explicit zero-argument lazy callbacks returning a prop directly remain supported for all value types without type services. Opaque casts cannot prove runtime identity; lifecycle changes stay manual.",
+    "Direct writes to the requested imported namespace member exclude its hook calls. Unknown computed writes exclude all namespace hooks; unrelated member writes and a hook function's own properties do not replace the callable. Reflective mutation and external API patches are not modeled.",
     "An updater read, escape, reassignment or nontrivial destructuring excludes the finding. Unused state values remain owned by unused-variable checks. Files containing direct eval are excluded because it can observe or change lexical bindings. Indirect eval and properties named eval do not establish lexical access. Opaque initialization, property aliases, optional/dynamic paths, rest/default bindings, non-JSX hooks, generated source and tests are outside scope. This does not ban interactive useState or replace the upstream set-state-in-effect rule."
   ],
   references: [
@@ -2481,18 +2552,8 @@ var FRONTEND_IMPORT = /^(?:react(?:-dom)?|next|preact|vue|svelte|@angular\/core|
 function isFrontendSource(context) {
   return /\.[jt]sx$/u.test(context.filename) || frontendModule(context.sourceCode.ast) || frontendPackage(context.filename);
 }
-var FRONTEND_PACKAGE_BY_DIRECTORY = /* @__PURE__ */ new Map();
 function frontendPackage(filename) {
-  const directory = (0, import_node_path2.dirname)((0, import_node_path2.resolve)(filename));
-  let cached = FRONTEND_PACKAGE_BY_DIRECTORY.get(directory);
-  if (cached === void 0) {
-    cached = nearestManifestDeclaresFrontend(directory);
-    FRONTEND_PACKAGE_BY_DIRECTORY.set(directory, cached);
-  }
-  return cached;
-}
-function nearestManifestDeclaresFrontend(start) {
-  let directory = start;
+  let directory = (0, import_node_path2.dirname)((0, import_node_path2.resolve)(filename));
   for (; ; ) {
     const manifestPath = (0, import_node_path2.join)(directory, "package.json");
     if ((0, import_node_fs.existsSync)(manifestPath)) {
@@ -2838,6 +2899,23 @@ function ownsTestComments(context) {
   const framework = context.sourceCode.ast.body.some((statement) => statement.type === import_utils22.AST_NODE_TYPES.ImportDeclaration && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.type !== import_utils22.AST_NODE_TYPES.ImportSpecifier || specifier.importKind !== "type")) && ["vitest", "@jest/globals", "@playwright/test", "bun:test", "node:test"].includes(statement.source.value));
   return unambiguous || framework;
 }
+function legalNoticeComments(comments) {
+  const legal = /* @__PURE__ */ new Set();
+  for (const [index, comment] of comments.entries()) {
+    if (legal.has(comment) || comment.type !== "Line" || !LEGAL.test(comment.value)) continue;
+    legal.add(comment);
+    for (const direction of [-1, 1]) {
+      let previous = comment;
+      for (let next = index + direction; next >= 0 && next < comments.length; next += direction) {
+        const neighbor = comments[next];
+        if (neighbor?.type !== "Line" || Math.abs(neighbor.loc.start.line - previous.loc.start.line) !== 1) break;
+        legal.add(neighbor);
+        previous = neighbor;
+      }
+    }
+  }
+  return legal;
+}
 var no_test_comments_default = createRule({
   name: "no-test-comments",
   documentation: NO_TEST_COMMENTS_DOCUMENTATION,
@@ -2856,23 +2934,10 @@ var no_test_comments_default = createRule({
     return {
       Program() {
         const comments = context.sourceCode.getAllComments();
-        const legalLines = /* @__PURE__ */ new Set();
-        for (const [index, comment] of comments.entries()) {
-          if (comment.type !== "Line" || !LEGAL.test(comment.value)) continue;
-          legalLines.add(index);
-          for (const direction of [-1, 1]) {
-            let previous = comment;
-            for (let next = index + direction; next >= 0 && next < comments.length; next += direction) {
-              const neighbor = comments[next];
-              if (neighbor?.type !== "Line" || Math.abs(neighbor.loc.start.line - previous.loc.start.line) !== 1) break;
-              legalLines.add(next);
-              previous = neighbor;
-            }
-          }
-        }
-        for (const [index, comment] of comments.entries()) {
+        const legal = frontend ? void 0 : legalNoticeComments(comments);
+        for (const comment of comments) {
           const body3 = comment.value.trim().replace(/^\*\s*/u, "");
-          if (!frontend && (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;
+          if (!frontend && (DIRECTIVE.test(body3) || BEHAVIORAL_DIRECTIVE.test(comment.value) || LEGAL.test(comment.value) || legal?.has(comment) || TYPE_CONTRACT.test(comment.value) || hasDetectSecretsPragma(comment, context.sourceCode.text))) continue;
           context.report({
             node: comment,
             messageId: "testComment",
@@ -3687,7 +3752,7 @@ function fixtureConstructor(source, value) {
   const use = value.params[1];
   if (use?.type !== import_utils29.AST_NODE_TYPES.Identifier) return null;
   const binding3 = stableBinding(source, use);
-  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils29.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 1 && node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && stableBinding(source, node.callee) === binding3);
+  const calls = scopeNodes(value.body, source).filter((node) => node.type === import_utils29.AST_NODE_TYPES.CallExpression).filter((node) => !node.optional && node.arguments.length === 1 && node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && stableBinding(source, node.callee) === binding3);
   if (calls.length !== 1 || binding3 === null) return null;
   const argument = calls[0]?.arguments[0];
   return argument === void 0 || argument.type === import_utils29.AST_NODE_TYPES.SpreadElement ? null : newConstructor(source, argument);
@@ -3710,17 +3775,12 @@ function scopeNodes(root, source) {
     if (node === void 0) continue;
     result.push(node);
     if (node !== root && (node.type === import_utils29.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils29.AST_NODE_TYPES.FunctionExpression || node.type === import_utils29.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils29.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils29.AST_NODE_TYPES.ClassExpression)) continue;
-    for (const key of source.visitorKeys[node.type] ?? []) {
-      const value = Reflect.get(node, key);
-      if (Array.isArray(value)) pending.push(...value.filter(isNode2));
-      else if (isNode2(value)) pending.push(value);
-    }
+    forEachAstChild(node, source.visitorKeys, (child) => {
+      pending.push(child);
+    });
   }
   return result;
 }
-function isNode2(value) {
-  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
-}
 function testApiCallee(expression) {
   let node = unwrapExpression(expression);
   while (node.type === import_utils29.AST_NODE_TYPES.MemberExpression && !node.optional && TEST_MODIFIERS.has(import_utils29.ASTUtils.getPropertyName(node) ?? "")) node = unwrapExpression(node.object);
@@ -6287,7 +6347,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "18.2.0",
+  version: "18.3.0",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -6933,7 +6993,7 @@ function existingFactoryContractFix(sourceCode, candidate2) {
   const contract = contractStatement?.type === import_utils48.AST_NODE_TYPES.ExportNamedDeclaration ? contractStatement.declaration : null;
   const implementation = classStatement?.type === import_utils48.AST_NODE_TYPES.ExportNamedDeclaration ? classStatement.declaration : classStatement;
   const factory = factoryStatement?.type === import_utils48.AST_NODE_TYPES.ExportNamedDeclaration ? factoryStatement.declaration : null;
-  if (contract?.type !== import_utils48.AST_NODE_TYPES.TSTypeAliasDeclaration || worker?.type !== import_utils48.AST_NODE_TYPES.TSInterfaceDeclaration || implementation?.type !== import_utils48.AST_NODE_TYPES.ClassDeclaration || implementation !== candidate2 || !ordinaryClass(implementation) || !ordinaryFactory(factory))
+  if (contract?.type !== import_utils48.AST_NODE_TYPES.TSTypeAliasDeclaration || worker?.type !== import_utils48.AST_NODE_TYPES.TSInterfaceDeclaration || implementation?.type !== import_utils48.AST_NODE_TYPES.ClassDeclaration || implementation !== candidate2 || !ordinaryClass(implementation) || factory?.type !== import_utils48.AST_NODE_TYPES.FunctionDeclaration || !ordinaryFactory(factory))
     return null;
   const operation2 = contractOperation(contract);
   if (operation2 === null || interfaceOperation(worker) !== operation2)
@@ -6952,7 +7012,7 @@ 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_utils48.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.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;
@@ -7525,8 +7585,8 @@ var publicMethodNames = (body3, functionAliases) => {
 };
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
-  const methods = node.body.body.filter(
-    (member3) => member3.type === import_utils49.AST_NODE_TYPES.MethodDefinition && member3.kind === "method" && !member3.static && member3.accessibility !== "private" && member3.accessibility !== "protected" && member3.value.body !== null
+  const methods = node.body.body.filter((member3) => member3.type === import_utils49.AST_NODE_TYPES.MethodDefinition).filter(
+    (member3) => 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) => {
@@ -7690,7 +7750,7 @@ var require_port_for_service_default = createRule({
         const ctor = node.body.body.find(
           (member3) => member3.type === import_utils49.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null && member3.value.body !== void 0
         );
-        if (ctor === void 0) return;
+        if (ctor?.type !== import_utils49.AST_NODE_TYPES.MethodDefinition) return;
         const constructorFacts = readConstructor(
           ctor,
           objectTypes,
@@ -7757,7 +7817,7 @@ function createServiceOperationResolver(program) {
     const ctor = node.body.body.find(
       (member3) => member3.type === import_utils49.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor" && member3.value.body !== null
     );
-    if (ctor === void 0) return [];
+    if (ctor?.type !== import_utils49.AST_NODE_TYPES.MethodDefinition) return [];
     const declared = () => declaredTypes ??= fileTypeIndex(program);
     const facts = readConstructor(
       ctor,
@@ -9332,7 +9392,7 @@ function ordinaryHostReference(reference) {
 }
 
 // src/rules/no-contradictory-type-predicate.ts
-var RUNTIME_KINDS = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"]);
+var RUNTIME_KINDS = ["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"];
 var PRIMITIVE_KINDS = [
   [import_typescript23.default.TypeFlags.String, "string"],
   [import_typescript23.default.TypeFlags.Number, "number"],
@@ -9411,7 +9471,7 @@ var no_contradictory_type_predicate_default = createRule({
       if (hasSeparatePredicateContract(services.esTreeNodeToTSNodeMap.get(node), checker)) return;
       const parameter = node.params.find((candidate2) => candidate2.type === import_utils59.AST_NODE_TYPES.Identifier && candidate2.name === name);
       const expression = singleReturn(node);
-      if (parameter?.typeAnnotation === void 0 || expression === void 0) return;
+      if (parameter?.type !== import_utils59.AST_NODE_TYPES.Identifier || parameter.typeAnnotation === void 0 || expression === void 0) return;
       const check = typeofCheck(expression);
       if (check !== void 0 && !sameParameter(parameter, check.parameter, context.sourceCode)) return;
       const input = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(check?.parameter ?? parameter));
@@ -9502,15 +9562,13 @@ function typeofCheck(expression) {
   if (value.type !== import_utils59.AST_NODE_TYPES.BinaryExpression || value.operator !== "===" && value.operator !== "==") return void 0;
   for (const [tested, expected] of [[value.left, value.right], [value.right, value.left]]) {
     const operand = unwrapExpression(tested);
-    const kind = staticString(expected);
-    if (operand.type !== import_utils59.AST_NODE_TYPES.UnaryExpression || operand.operator !== "typeof" || operand.argument.type !== import_utils59.AST_NODE_TYPES.Identifier || kind === null || !isRuntimeKind(kind)) continue;
+    const expectedKind = staticString(expected);
+    const kind = RUNTIME_KINDS.find((candidate2) => candidate2 === expectedKind);
+    if (operand.type !== import_utils59.AST_NODE_TYPES.UnaryExpression || operand.operator !== "typeof" || operand.argument.type !== import_utils59.AST_NODE_TYPES.Identifier || kind === void 0) continue;
     return { parameter: operand.argument, kind };
   }
   return void 0;
 }
-function isRuntimeKind(value) {
-  return RUNTIME_KINDS.has(value);
-}
 function sameParameter(declared, tested, sourceCode) {
   const parameter = import_utils59.ASTUtils.findVariable(sourceCode.getScope(declared), declared.name);
   return parameter !== null && parameter === import_utils59.ASTUtils.findVariable(sourceCode.getScope(tested), tested.name);
@@ -9559,9 +9617,9 @@ var import_utils60 = require("@typescript-eslint/utils");
 var import_typescript24 = __toESM(require("typescript"), 1);
 function uuidPredicateWitness(expression, parameter, sourceCode, services) {
   const success = unwrapExpression(expression);
-  if (!member(success, "success")) return void 0;
+  if (success.type !== import_utils60.AST_NODE_TYPES.MemberExpression || !member(success, "success")) return void 0;
   const parse2 = unwrapExpression(success.object);
-  if (parse2.type !== import_utils60.AST_NODE_TYPES.CallExpression || parse2.optional || parse2.arguments.length !== 1 || !member(parse2.callee, "safeParse")) return void 0;
+  if (parse2.type !== import_utils60.AST_NODE_TYPES.CallExpression || parse2.optional || parse2.arguments.length !== 1 || parse2.callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || !member(parse2.callee, "safeParse")) return void 0;
   const argument = parse2.arguments[0];
   if (argument === void 0 || unwrapExpression(argument).type !== import_utils60.AST_NODE_TYPES.Identifier) return void 0;
   const value = unwrapExpression(argument);
@@ -9580,13 +9638,13 @@ function binding(node, sourceCode) {
   return import_utils60.ASTUtils.findVariable(sourceCode.getScope(node), node.name);
 }
 function member(node, name) {
-  return node?.type === import_utils60.AST_NODE_TYPES.MemberExpression && !node.optional && !node.computed && node.property.type === import_utils60.AST_NODE_TYPES.Identifier && node.property.name === name;
+  return !node.optional && !node.computed && node.property.type === import_utils60.AST_NODE_TYPES.Identifier && node.property.name === name;
 }
 function uuidNamespace(initializer, sourceCode, services) {
-  if (!noArguments(initializer) || !member(initializer.callee, "uuid")) return null;
+  if (initializer.type !== import_utils60.AST_NODE_TYPES.CallExpression || !noArguments(initializer) || initializer.callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || !member(initializer.callee, "uuid")) return null;
   let receiver = unwrapExpression(initializer.callee.object);
   let legacy = false;
-  if (noArguments(receiver) && member(receiver.callee, "string")) {
+  if (receiver.type === import_utils60.AST_NODE_TYPES.CallExpression && noArguments(receiver) && receiver.callee.type === import_utils60.AST_NODE_TYPES.MemberExpression && member(receiver.callee, "string")) {
     receiver = unwrapExpression(receiver.callee.object);
     legacy = true;
   }
@@ -9602,7 +9660,7 @@ function uuidNamespace(initializer, sourceCode, services) {
   return namespace ?? null;
 }
 function noArguments(node) {
-  return node.type === import_utils60.AST_NODE_TYPES.CallExpression && !node.optional && node.arguments.length === 0;
+  return !node.optional && node.arguments.length === 0;
 }
 function installedZod(node, services) {
   const checker = services.program.getTypeChecker();
@@ -9622,7 +9680,7 @@ function closedSchema(schema) {
     const receiver = outerExpression(reference.identifier);
     const property = receiver.parent;
     if (property?.type === import_utils60.AST_NODE_TYPES.ExportSpecifier && property.local === receiver) return true;
-    if (!member(property, "safeParse") || property.object !== receiver) return false;
+    if (property?.type !== import_utils60.AST_NODE_TYPES.MemberExpression || !member(property, "safeParse") || property.object !== receiver) return false;
     const call = property.parent;
     return call?.type === import_utils60.AST_NODE_TYPES.CallExpression && call.callee === property && !call.optional && call.arguments.length === 1 && call.arguments[0]?.type !== import_utils60.AST_NODE_TYPES.SpreadElement;
   });
@@ -10088,10 +10146,10 @@ function literalSelectorFix(sourceCode, parameter) {
   if (sourceCode.ast.body.length !== 4 || sourceCode.getAllComments().length > 0)
     return null;
   const [first, second, declaration, statement] = sourceCode.ast.body;
-  if (!isLiteralOperation(first) || !isLiteralOperation(second) || declaration?.type !== import_utils63.AST_NODE_TYPES.VariableDeclaration || declaration.declare || declaration.kind !== "const" || declaration.declarations.length !== 1 || statement?.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration?.type !== import_utils63.AST_NODE_TYPES.FunctionDeclaration)
+  if (first?.type !== import_utils63.AST_NODE_TYPES.FunctionDeclaration || !isLiteralOperation(first) || second?.type !== import_utils63.AST_NODE_TYPES.FunctionDeclaration || !isLiteralOperation(second) || declaration?.type !== import_utils63.AST_NODE_TYPES.VariableDeclaration || declaration.declare || declaration.kind !== "const" || declaration.declarations.length !== 1 || statement?.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration?.type !== import_utils63.AST_NODE_TYPES.FunctionDeclaration)
     return null;
   const binding3 = declaration.declarations[0];
-  if (binding3?.id.type !== import_utils63.AST_NODE_TYPES.Identifier || binding3.id.typeAnnotation !== void 0 || !isSelector(binding3.init, parameter))
+  if (binding3?.id.type !== import_utils63.AST_NODE_TYPES.Identifier || binding3.id.typeAnnotation !== void 0 || binding3.init?.type !== import_utils63.AST_NODE_TYPES.ArrowFunctionExpression || binding3.init.body.type !== import_utils63.AST_NODE_TYPES.ConditionalExpression || !isSelector(binding3.init, parameter))
     return null;
   const branch = binding3.init.body;
   const whenTrue = operation(sourceCode, branch.consequent, first, second);
@@ -10113,13 +10171,12 @@ function literalSelectorFix(sourceCode, parameter) {
   ];
 }
 function isLiteralOperation(node) {
-  if (node?.type !== import_utils63.AST_NODE_TYPES.FunctionDeclaration || node.id === null || node.declare || node.async || node.generator || node.params.length !== 0 || node.typeParameters !== void 0 || node.returnType !== void 0 || node.body.body.length !== 1)
+  if (node.id === null || node.declare || node.async || node.generator || node.params.length !== 0 || node.typeParameters !== void 0 || node.returnType !== void 0 || node.body.body.length !== 1)
     return false;
   const returned2 = node.body.body[0];
   return returned2?.type === import_utils63.AST_NODE_TYPES.ReturnStatement && returned2.argument?.type === import_utils63.AST_NODE_TYPES.Literal && typeof returned2.argument.value === "string";
 }
 function isSelector(node, parameter) {
-  if (node?.type !== import_utils63.AST_NODE_TYPES.ArrowFunctionExpression) return false;
   const actual = node.params[0];
   return actual?.type === import_utils63.AST_NODE_TYPES.Identifier && actual.name === parameter.name && !node.async && node.typeParameters === void 0 && node.returnType === void 0 && node.params.length === 1 && !actual.optional && actual.typeAnnotation?.typeAnnotation.type === import_utils63.AST_NODE_TYPES.TSBooleanKeyword && node.body.type === import_utils63.AST_NODE_TYPES.ConditionalExpression && node.body.test === parameter;
 }
@@ -11946,10 +12003,6 @@ var import_utils77 = require("@typescript-eslint/utils");
 var TEST_CALLERS = /* @__PURE__ */ new Set(["it", "test"]);
 var ASSERTION_NAMES = /* @__PURE__ */ new Set(["assert", "expect"]);
 var TEST_MODIFIERS2 = /* @__PURE__ */ new Set(["concurrent", "fails", "only", "sequential", "skip"]);
-var FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils77.AST_NODE_TYPES.FunctionExpression,
-  import_utils77.AST_NODE_TYPES.ArrowFunctionExpression
-]);
 var OMITTED_AST_KEYS = /* @__PURE__ */ new Set([
   "end",
   "loc",
@@ -12131,7 +12184,7 @@ function testBody(call, sourceCode) {
     return null;
   }
   const callback = call.arguments.map(unwrapExpression).find(
-    (argument) => argument.type !== import_utils77.AST_NODE_TYPES.SpreadElement && FUNCTION_TYPES.has(argument.type)
+    (argument) => argument.type === import_utils77.AST_NODE_TYPES.FunctionExpression || argument.type === import_utils77.AST_NODE_TYPES.ArrowFunctionExpression
   );
   if (callback === void 0 || call.arguments.length !== 2 || containsInlineSnapshot(callback.body)) {
     return null;
@@ -15425,7 +15478,7 @@ function uuidModule(sourceCode, kind) {
   const native = statements[offset + 1];
   const legacy = statements[offset + 2];
   const exported = statements[offset + 3];
-  if (imported !== null && imported?.type !== import_utils93.AST_NODE_TYPES.ImportDeclaration || declaration?.type !== import_utils93.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare || declaration.declarations.length !== 1 || !stringFunction(native) || !stringFunction(legacy) || exported?.type !== import_utils93.AST_NODE_TYPES.ExportNamedDeclaration || exported.specifiers.length !== 0 || exported.source !== null || !arrayFunction(exported.declaration))
+  if (imported !== null && imported?.type !== import_utils93.AST_NODE_TYPES.ImportDeclaration || declaration?.type !== import_utils93.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare || declaration.declarations.length !== 1 || native?.type !== import_utils93.AST_NODE_TYPES.FunctionDeclaration || !stringFunction(native) || legacy?.type !== import_utils93.AST_NODE_TYPES.FunctionDeclaration || !stringFunction(legacy) || exported?.type !== import_utils93.AST_NODE_TYPES.ExportNamedDeclaration || exported.specifiers.length !== 0 || exported.source !== null || exported.declaration?.type !== import_utils93.AST_NODE_TYPES.FunctionDeclaration || !arrayFunction(exported.declaration))
     return null;
   const provider = declaration.declarations[0];
   if (provider === void 0 || !nativeProvider(sourceCode, provider) || !providerRead(sourceCode, returned(native), provider) || !exportedReads(
@@ -15447,7 +15500,7 @@ function arrayFunction(node) {
   return annotation?.type === import_utils93.AST_NODE_TYPES.TSArrayType && annotation.elementType.type === import_utils93.AST_NODE_TYPES.TSStringKeyword;
 }
 function ordinaryFunction(node) {
-  return node?.type === import_utils93.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.params.length === 0 && node.body.body.length === 1 && node.body.body[0]?.type === import_utils93.AST_NODE_TYPES.ReturnStatement && node.body.body[0].argument !== null;
+  return node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.params.length === 0 && node.body.body.length === 1 && node.body.body[0]?.type === import_utils93.AST_NODE_TYPES.ReturnStatement && node.body.body[0].argument !== null;
 }
 function returned(node) {
   const statement = node.body.body[0];
@@ -15459,14 +15512,14 @@ function nativeProvider(sourceCode, node) {
   if (node.id.type !== import_utils93.AST_NODE_TYPES.Identifier || node.id.typeAnnotation !== void 0)
     return false;
   const call = node.init;
-  if (call?.type !== import_utils93.AST_NODE_TYPES.CallExpression || call.optional || call.typeArguments !== void 0 || call.arguments.length !== 1 || !member2(call.callee, "bind") || !member2(call.callee.object, "randomUUID"))
+  if (call?.type !== import_utils93.AST_NODE_TYPES.CallExpression || call.optional || call.typeArguments !== void 0 || call.arguments.length !== 1 || call.callee.type !== import_utils93.AST_NODE_TYPES.MemberExpression || !member2(call.callee, "bind") || call.callee.object.type !== import_utils93.AST_NODE_TYPES.MemberExpression || !member2(call.callee.object, "randomUUID"))
     return false;
   const receiver = call.callee.object.object;
   const argument = call.arguments[0];
   return receiver.type === import_utils93.AST_NODE_TYPES.Identifier && receiver.name === "crypto" && argument?.type === import_utils93.AST_NODE_TYPES.Identifier && argument.name === "crypto" && (import_utils93.ASTUtils.findVariable(sourceCode.getScope(receiver), "crypto")?.defs.length ?? 0) === 0 && (import_utils93.ASTUtils.findVariable(sourceCode.getScope(argument), "crypto")?.defs.length ?? 0) === 0;
 }
 function member2(node, property) {
-  return node.type === import_utils93.AST_NODE_TYPES.MemberExpression && !node.computed && !node.optional && node.property.type === import_utils93.AST_NODE_TYPES.Identifier && node.property.name === property;
+  return !node.computed && !node.optional && node.property.type === import_utils93.AST_NODE_TYPES.Identifier && node.property.name === property;
 }
 function providerRead(sourceCode, node, declaration) {
   return node.type === import_utils93.AST_NODE_TYPES.CallExpression && !node.optional && node.typeArguments === void 0 && node.arguments.length === 0 && node.callee.type === import_utils93.AST_NODE_TYPES.Identifier && sameBinding2(sourceCode, node.callee, declaration);
@@ -15495,7 +15548,7 @@ function exportedReads(sourceCode, node, native, legacy, imported) {
   return nilImport !== void 0 && sameBinding2(sourceCode, nil, nilImport);
 }
 function isUuidRecipe(sourceCode, node, reported) {
-  if (node.type !== import_utils93.AST_NODE_TYPES.CallExpression || node.optional || node.typeArguments !== void 0 || !member2(node.callee, "replace") || node.callee.object.type !== import_utils93.AST_NODE_TYPES.Literal || node.callee.object.value !== UUID_TEMPLATE || node.arguments.length !== IMPORT_COUNT)
+  if (node.type !== import_utils93.AST_NODE_TYPES.CallExpression || node.optional || node.typeArguments !== void 0 || node.callee.type !== import_utils93.AST_NODE_TYPES.MemberExpression || !member2(node.callee, "replace") || node.callee.object.type !== import_utils93.AST_NODE_TYPES.Literal || node.callee.object.value !== UUID_TEMPLATE || node.arguments.length !== IMPORT_COUNT)
     return false;
   const [pattern, callback] = node.arguments;
   if (pattern?.type !== import_utils93.AST_NODE_TYPES.Literal || !("regex" in pattern) || pattern.regex.pattern !== "[xy]" || pattern.regex.flags !== "g" || callback?.type !== import_utils93.AST_NODE_TYPES.ArrowFunctionExpression || callback.async || callback.typeParameters !== void 0 || callback.returnType !== void 0 || callback.params.length !== 1 || callback.params[0]?.type !== import_utils93.AST_NODE_TYPES.Identifier || callback.params[0].typeAnnotation !== void 0 || callback.params[0].optional || callback.body.type !== import_utils93.AST_NODE_TYPES.BlockStatement || callback.body.body.length !== IMPORT_COUNT)
@@ -16044,8 +16097,8 @@ function serverActionErrorResults(sourceCode) {
   if (nodes.some((node) => node.type === import_utils98.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils98.AST_NODE_TYPES.Identifier && node.callee.name === "eval")) return [];
   const analysis = new ActionResults(sourceCode);
   const actionSet = new Set(actions);
-  return nodes.filter((node) => {
-    if (node.type !== import_utils98.AST_NODE_TYPES.ReturnStatement || node.argument === null) return false;
+  return nodes.filter((node) => node.type === import_utils98.AST_NODE_TYPES.ReturnStatement).filter((node) => {
+    if (node.argument === null) return false;
     const owner = functionOwner(node);
     return owner !== null && actionSet.has(owner) && escapingActionReturn(node, owner, sourceCode) && analysis.payload(node.argument, owner);
   });
@@ -17027,7 +17080,7 @@ function existingDomainComparisonFix(sourceCode, comparison2) {
   if (comparison2.operator !== "===" || sourceCode.ast.body.length !== 2 || sourceCode.getAllComments().length !== 0)
     return null;
   const [comparator, exported] = sourceCode.ast.body;
-  if (!isOrdinary(comparator) || comparator.id === null || exported?.type !== import_utils101.AST_NODE_TYPES.ExportNamedDeclaration || exported.exportKind !== "value" || !isOrdinary(exported.declaration))
+  if (comparator?.type !== import_utils101.AST_NODE_TYPES.FunctionDeclaration || !isOrdinary(comparator) || comparator.id === null || exported?.type !== import_utils101.AST_NODE_TYPES.ExportNamedDeclaration || exported.exportKind !== "value" || exported.declaration?.type !== import_utils101.AST_NODE_TYPES.FunctionDeclaration || !isOrdinary(exported.declaration))
     return null;
   const fields2 = comparatorFields(comparator);
   const elements = callerElements(exported.declaration);
@@ -17046,7 +17099,7 @@ function existingDomainComparisonFix(sourceCode, comparison2) {
   );
 }
 function isOrdinary(node) {
-  return node?.type === import_utils101.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.body.body.length === 1;
+  return node.id !== null && !node.declare && !node.async && !node.generator && node.typeParameters === void 0 && node.body.body.length === 1;
 }
 function comparatorFields(node) {
   const [left, right] = node.params;
@@ -18278,7 +18331,7 @@ function reportClass(context, services, owner) {
   if (contract === null) return;
   const groups = /* @__PURE__ */ new Map();
   for (const member3 of owner.body.body) {
-    if (!candidate(member3)) continue;
+    if (member3.type !== import_utils109.AST_NODE_TYPES.MethodDefinition || !candidate(member3)) continue;
     const name = convertibleMemberName(member3);
     if (name === null || contract.has(name)) continue;
     if (member3.accessibility === "private" || member3.key.type === import_utils109.AST_NODE_TYPES.PrivateIdentifier) continue;
@@ -18298,7 +18351,7 @@ function reportClass(context, services, owner) {
   }
 }
 function candidate(member3) {
-  return member3.type === import_utils109.AST_NODE_TYPES.MethodDefinition && member3.kind !== "constructor" && !member3.static && member3.accessibility !== "protected" && !member3.override && !member3.computed && member3.key.type === import_utils109.AST_NODE_TYPES.Identifier && member3.value.body !== null;
+  return member3.kind !== "constructor" && !member3.static && member3.accessibility !== "protected" && !member3.override && !member3.computed && member3.key.type === import_utils109.AST_NODE_TYPES.Identifier && member3.value.body !== null;
 }
 function interfaceNames(services, owner) {
   const tsOwner = services.esTreeNodeToTSNodeMap.get(owner);
@@ -18470,7 +18523,7 @@ var SINGLE_STATEMENT_HOSTS = /* @__PURE__ */ new Set([
   import_utils111.AST_NODE_TYPES.IfStatement,
   import_utils111.AST_NODE_TYPES.WhileStatement
 ]);
-var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
   import_utils111.AST_NODE_TYPES.ArrowFunctionExpression,
   import_utils111.AST_NODE_TYPES.FunctionDeclaration,
   import_utils111.AST_NODE_TYPES.FunctionExpression
@@ -18500,7 +18553,7 @@ function fallbackFollowsTry(tryStatement) {
   return last?.type === import_utils111.AST_NODE_TYPES.ReturnStatement && hasFollowingStatement(tryStatement);
 }
 function hasFollowingStatement(node) {
-  for (let current = node; current !== void 0 && !FUNCTION_TYPES2.has(current.type); current = current.parent) {
+  for (let current = node; current !== void 0 && !FUNCTION_TYPES.has(current.type); current = current.parent) {
     const slot = statementSlot(current);
     if (slot !== null && slot.index < slot.list.length - 1) return true;
   }
@@ -18588,7 +18641,7 @@ var no_log_only_catch_default = createRule({
     function hasFollowingCoercionCheck(owner, left, coercion) {
       let current = owner;
       let slot = statementSlot(current);
-      while (slot === null && current.parent !== void 0 && !FUNCTION_TYPES2.has(current.parent.type)) {
+      while (slot === null && current.parent !== void 0 && !FUNCTION_TYPES.has(current.parent.type)) {
         current = current.parent;
         slot = statementSlot(current);
       }
@@ -18673,7 +18726,7 @@ var TEST_NAMES = /* @__PURE__ */ new Set(["it", "test"]);
 var TEST_MODIFIERS3 = /* @__PURE__ */ new Set(["concurrent", "fails", "only", "sequential", "skip"]);
 var TEST_BUILDERS = /* @__PURE__ */ new Set(["each", "for", "runIf", "skipIf"]);
 var ASSERTION_NAMES2 = /* @__PURE__ */ new Set(["assert", "assertType", "expect", "expectTypeOf"]);
-var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([import_utils112.AST_NODE_TYPES.ArrowFunctionExpression, import_utils112.AST_NODE_TYPES.FunctionExpression, import_utils112.AST_NODE_TYPES.FunctionDeclaration]);
+var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([import_utils112.AST_NODE_TYPES.ArrowFunctionExpression, import_utils112.AST_NODE_TYPES.FunctionExpression, import_utils112.AST_NODE_TYPES.FunctionDeclaration]);
 function staticMemberName3(node) {
   if (!node.computed && node.property.type === import_utils112.AST_NODE_TYPES.Identifier) return node.property.name;
   if (node.computed && node.property.type === import_utils112.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
@@ -18686,7 +18739,6 @@ function rootIdentifier2(callee) {
   return null;
 }
 function isDirectTestCallback(node, context) {
-  if (node.type !== import_utils112.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils112.AST_NODE_TYPES.FunctionExpression) return false;
   const call = directArgumentCall(node);
   if (call === null) return false;
   const root = testRoot(call.callee);
@@ -18706,12 +18758,12 @@ function testRoot(callee) {
   return modifier !== null && TEST_MODIFIERS3.has(modifier) ? testRoot(callee.object) : null;
 }
 function nearestFunction(node) {
-  for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) if (FUNCTION_TYPES3.has(current.type)) return current;
+  for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) if (FUNCTION_TYPES2.has(current.type)) return current;
   return null;
 }
 function walkOwnScope(node, predicate) {
   if (predicate(node)) return true;
-  return forEachOwnAstChild(node, (child) => !FUNCTION_TYPES3.has(child.type) && walkOwnScope(child, predicate));
+  return forEachOwnAstChild(node, (child) => !FUNCTION_TYPES2.has(child.type) && walkOwnScope(child, predicate));
 }
 function isAssertion(node, context) {
   if (node.type !== import_utils112.AST_NODE_TYPES.CallExpression) return false;
@@ -18803,7 +18855,7 @@ var no_bare_return_from_test_catch_default = createRule({
       ReturnStatement(node) {
         if (node.argument !== null) return;
         const owner = nearestFunction(node);
-        if (owner === null || !isDirectTestCallback(owner, context)) return;
+        if (owner?.type !== import_utils112.AST_NODE_TYPES.ArrowFunctionExpression && owner?.type !== import_utils112.AST_NODE_TYPES.FunctionExpression || !isDirectTestCallback(owner, context)) return;
         let catchClause = null;
         for (let current = node.parent; current !== owner; current = current?.parent) {
           if (current?.type === import_utils112.AST_NODE_TYPES.CatchClause) {
@@ -19433,7 +19485,7 @@ function labeledTupleObjectFix(sourceCode, annotation) {
   if (sourceCode.ast.body.length !== 2 || sourceCode.getAllComments().length > 0)
     return null;
   const [helper, statement] = sourceCode.ast.body;
-  if (!isOrdinary2(helper) || statement?.type !== import_utils117.AST_NODE_TYPES.ExportNamedDeclaration || !isOrdinary2(statement.declaration) || helper.returnType?.typeAnnotation !== annotation)
+  if (helper?.type !== import_utils117.AST_NODE_TYPES.FunctionDeclaration || !isOrdinary2(helper) || statement?.type !== import_utils117.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration?.type !== import_utils117.AST_NODE_TYPES.FunctionDeclaration || !isOrdinary2(statement.declaration) || helper.returnType?.typeAnnotation !== annotation)
     return null;
   const caller = statement.declaration;
   const fields2 = tupleFields(helper);
@@ -19458,7 +19510,7 @@ function labeledTupleObjectFix(sourceCode, annotation) {
   ];
 }
 function isOrdinary2(node) {
-  return node?.type === import_utils117.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && !node.declare && !node.async && !node.generator && node.params.length === 0 && node.typeParameters === void 0;
+  return node.id !== null && !node.declare && !node.async && !node.generator && node.params.length === 0 && node.typeParameters === void 0;
 }
 function tupleFields(helper) {
   const tuple = helper.returnType?.typeAnnotation;
@@ -20786,7 +20838,7 @@ var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
 var URL_PATH_RE = /^\/(?=[^\s]*[A-Za-z0-9])[A-Za-z0-9._~!$&'()*+,;=:@%/?#{}\u005B\u005D-]+$/;
-var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
   import_utils124.AST_NODE_TYPES.FunctionDeclaration,
   import_utils124.AST_NODE_TYPES.FunctionExpression,
   import_utils124.AST_NODE_TYPES.ArrowFunctionExpression
@@ -20860,7 +20912,7 @@ function preview(value) {
 }
 function enclosingFunction4(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (FUNCTION_TYPES4.has(current.type)) {
+    if (FUNCTION_TYPES3.has(current.type)) {
       return current;
     }
   }
@@ -22325,9 +22377,6 @@ function isSentinelArgument(arg) {
 function isFunctionNode(node) {
   return node.type === import_utils132.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils132.AST_NODE_TYPES.FunctionExpression || node.type === import_utils132.AST_NODE_TYPES.ArrowFunctionExpression;
 }
-function isNode3(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string";
-}
 function walkWithinScope(node, visit) {
   let found = false;
   const recurse = (current) => {
@@ -22454,7 +22503,7 @@ function enclosingFunctionName(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
     if (isFunctionNode(current)) {
-      if ("id" in current && isNode3(current.id) && current.id.type === import_utils132.AST_NODE_TYPES.Identifier) {
+      if ("id" in current && current.id !== null && current.id.type === import_utils132.AST_NODE_TYPES.Identifier) {
         return current.id.name;
       }
       const parent = current.parent;
@@ -22555,7 +22604,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
 function enclosingFunctionBody(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === import_utils132.AST_NODE_TYPES.BlockStatement) {
+    if (isFunctionNode(current) && current.body?.type === import_utils132.AST_NODE_TYPES.BlockStatement) {
       return current.body;
     }
     current = current.parent;
@@ -22962,7 +23011,7 @@ var TEST_CALLERS2 = /* @__PURE__ */ new Set([
   "beforeEach",
   "afterEach"
 ]);
-var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
   import_utils134.AST_NODE_TYPES.FunctionDeclaration,
   import_utils134.AST_NODE_TYPES.FunctionExpression,
   import_utils134.AST_NODE_TYPES.ArrowFunctionExpression
@@ -22997,7 +23046,7 @@ function isHelperSleep(node) {
 }
 function nearestEnclosingFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (!FUNCTION_TYPES5.has(current.type)) {
+    if (!FUNCTION_TYPES4.has(current.type)) {
       continue;
     }
     const grandparent = current.parent;
@@ -26002,7 +26051,7 @@ var ASSERTION_ROOTS = /* @__PURE__ */ new Set([
   "expect",
   "expectTypeOf"
 ]);
-var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
   import_utils150.AST_NODE_TYPES.FunctionDeclaration,
   import_utils150.AST_NODE_TYPES.FunctionExpression,
   import_utils150.AST_NODE_TYPES.ArrowFunctionExpression
@@ -26037,7 +26086,7 @@ function isTestCaller(callee, isFrameworkTest) {
 }
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (FUNCTION_TYPES6.has(current.type)) {
+    if (FUNCTION_TYPES5.has(current.type)) {
       return current;
     }
   }
@@ -26070,7 +26119,7 @@ function walkOwnScope2(node, predicate) {
   if (predicate(node)) {
     return true;
   }
-  return forEachOwnAstChild(node, (child) => !FUNCTION_TYPES6.has(child.type) && walkOwnScope2(child, predicate));
+  return forEachOwnAstChild(node, (child) => !FUNCTION_TYPES5.has(child.type) && walkOwnScope2(child, predicate));
 }
 function isAssertion2(node, isFrameworkAssertion) {
   if (node.type !== import_utils150.AST_NODE_TYPES.CallExpression) return false;
@@ -26083,7 +26132,7 @@ function opensSubtest(node, callbackParameters) {
   }
   const callee = unwrapExpression(node.callee);
   return callee.type === import_utils150.AST_NODE_TYPES.MemberExpression && staticMemberName6(callee) === "test" && callee.object.type === import_utils150.AST_NODE_TYPES.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
-    (argument) => argument.type !== import_utils150.AST_NODE_TYPES.SpreadElement && FUNCTION_TYPES6.has(argument.type)
+    (argument) => argument.type !== import_utils150.AST_NODE_TYPES.SpreadElement && FUNCTION_TYPES5.has(argument.type)
   );
 }
 var LOOP_CARRIED_CONTROL = /* @__PURE__ */ new Set([
@@ -26449,7 +26498,7 @@ var PREFER_ECMASCRIPT_PRIVATE_MEMBERS_DOCUMENTATION = {
 function reportClass2(context, owner, services) {
   const groups = /* @__PURE__ */ new Map();
   for (const member3 of owner.body.body) {
-    if (!isConvertible(member3)) continue;
+    if (member3.type !== import_utils153.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils153.AST_NODE_TYPES.PropertyDefinition && member3.type !== import_utils153.AST_NODE_TYPES.AccessorProperty || !isConvertible(member3)) continue;
     const name = convertibleMemberName(member3);
     if (name === null) continue;
     const members = groups.get(name) ?? [];
@@ -26468,7 +26517,6 @@ function reportClass2(context, owner, services) {
   }
 }
 function isConvertible(member3) {
-  if (member3.type !== import_utils153.AST_NODE_TYPES.MethodDefinition && member3.type !== import_utils153.AST_NODE_TYPES.PropertyDefinition && member3.type !== import_utils153.AST_NODE_TYPES.AccessorProperty) return false;
   return member3.accessibility === "private" && !(member3.type === import_utils153.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor") && !member3.computed && member3.key.type === import_utils153.AST_NODE_TYPES.Identifier && member3.decorators.length === 0 && !("declare" in member3 && member3.declare) && !member3.override && !(member3.type === import_utils153.AST_NODE_TYPES.MethodDefinition && member3.value.body === null);
 }
 var prefer_ecmascript_private_members_default = createRule({
@@ -28160,7 +28208,7 @@ var MUTATING_METHODS2 = /* @__PURE__ */ new Set([
   // Object-ish escape hatches
   "assign"
 ]);
-var FUNCTION_TYPES7 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
   import_utils162.AST_NODE_TYPES.FunctionDeclaration,
   import_utils162.AST_NODE_TYPES.FunctionExpression,
   import_utils162.AST_NODE_TYPES.ArrowFunctionExpression
@@ -28182,8 +28230,8 @@ function unwrap3(node) {
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
-function isRegexLiteral(node) {
-  return node.type === import_utils162.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+function literalRegex(node) {
+  return node.type === import_utils162.AST_NODE_TYPES.Literal && "regex" in node ? node.regex : void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -28192,7 +28240,7 @@ function isLiteralOnly(node, depth) {
   const inner = unwrap3(node);
   switch (inner.type) {
     case import_utils162.AST_NODE_TYPES.Literal: {
-      return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
+      return !HAS_STATEFUL_FLAG_RE.test(literalRegex(inner)?.flags ?? "");
     }
     case import_utils162.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
@@ -28226,11 +28274,12 @@ function isLiteralOnly(node, depth) {
 }
 function classify(init, checkRegex, sourceCode) {
   const node = unwrapObjectFreeze(init, sourceCode);
-  if (isRegexLiteral(node)) {
+  const regex = literalRegex(node);
+  if (regex !== void 0) {
     if (!checkRegex) {
       return null;
     }
-    if (HAS_STATEFUL_FLAG_RE.test(node.regex.flags)) {
+    if (HAS_STATEFUL_FLAG_RE.test(regex.flags)) {
       return null;
     }
     return { kind: "regex", size: 1 };
@@ -28257,7 +28306,7 @@ function unwrapObjectFreeze(node, sourceCode) {
 function enclosingFunction5(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (FUNCTION_TYPES7.has(current.type)) {
+    if (FUNCTION_TYPES6.has(current.type)) {
       return current;
     }
     current = current.parent;
@@ -28561,7 +28610,7 @@ var I18N_RECEIVER_NAMES = /* @__PURE__ */ new Set([
   "i18n",
   "intl"
 ]);
-var FUNCTION_TYPES8 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES7 = /* @__PURE__ */ new Set([
   import_utils163.AST_NODE_TYPES.ArrowFunctionExpression,
   import_utils163.AST_NODE_TYPES.FunctionDeclaration,
   import_utils163.AST_NODE_TYPES.FunctionExpression
@@ -28587,7 +28636,7 @@ function outermostEnclosingFunction(node) {
   let outermost;
   let current = node.parent ?? void 0;
   while (current !== void 0) {
-    if (FUNCTION_TYPES8.has(current.type)) {
+    if (FUNCTION_TYPES7.has(current.type)) {
       outermost = current;
     }
     current = current.parent ?? void 0;
@@ -28610,7 +28659,7 @@ function subtreeSome(root, predicate, skipDeferredFunctions = false) {
     if (typeof candidate2.type !== "string") {
       return;
     }
-    if (skipDeferredFunctions && FUNCTION_TYPES8.has(candidate2.type)) return;
+    if (skipDeferredFunctions && FUNCTION_TYPES7.has(candidate2.type)) return;
     if (predicate(candidate2)) {
       found = true;
       return;
@@ -28725,7 +28774,7 @@ var prefer_module_level_schema_default = createRule({
     function isCovered(node) {
       let current = node.parent ?? void 0;
       while (current !== void 0) {
-        if (current !== node && isZodCall(current) && current.callee.type === import_utils163.AST_NODE_TYPES.MemberExpression && import_utils163.ASTUtils.getPropertyName(current.callee) !== null && factories.has(import_utils163.ASTUtils.getPropertyName(current.callee) ?? "")) {
+        if (current !== node && current.type === import_utils163.AST_NODE_TYPES.CallExpression && isZodCall(current) && current.callee.type === import_utils163.AST_NODE_TYPES.MemberExpression && import_utils163.ASTUtils.getPropertyName(current.callee) !== null && factories.has(import_utils163.ASTUtils.getPropertyName(current.callee) ?? "")) {
           return true;
         }
         if (current.type === import_utils163.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils163.AST_NODE_TYPES.Identifier && memoCallees.has(current.callee.name) || current.callee.type === import_utils163.AST_NODE_TYPES.MemberExpression && import_utils163.ASTUtils.getPropertyName(current.callee) !== null && memoCallees.has(import_utils163.ASTUtils.getPropertyName(current.callee) ?? ""))) {
@@ -28981,7 +29030,7 @@ var I18N_RECEIVER_NAMES2 = /* @__PURE__ */ new Set([
   "i18n",
   "intl"
 ]);
-var FUNCTION_TYPES9 = /* @__PURE__ */ new Set([
+var FUNCTION_TYPES8 = /* @__PURE__ */ new Set([
   import_utils164.AST_NODE_TYPES.ArrowFunctionExpression,
   import_utils164.AST_NODE_TYPES.FunctionDeclaration,
   import_utils164.AST_NODE_TYPES.FunctionExpression
@@ -29029,7 +29078,7 @@ function outermostEnclosingFunction2(node) {
   let outermost;
   let current = node.parent ?? void 0;
   while (current !== void 0) {
-    if (FUNCTION_TYPES9.has(current.type)) outermost = current;
+    if (FUNCTION_TYPES8.has(current.type)) outermost = current;
     current = current.parent ?? void 0;
   }
   return outermost;
@@ -29048,7 +29097,7 @@ function subtreeSome2(root, predicate, skipDeferredFunctions = false) {
     }
     const candidate2 = value;
     if (typeof candidate2.type !== "string") return;
-    if (skipDeferredFunctions && FUNCTION_TYPES9.has(candidate2.type)) return;
+    if (skipDeferredFunctions && FUNCTION_TYPES8.has(candidate2.type)) return;
     if (predicate(candidate2)) {
       found = true;
       return;
@@ -29194,7 +29243,7 @@ var prefer_module_level_refined_schema_default = createRule({
       let current = node;
       while (current.parent != null) {
         current = current.parent;
-        if (FUNCTION_TYPES9.has(current.type)) return false;
+        if (FUNCTION_TYPES8.has(current.type)) return false;
         if (current.type === import_utils164.AST_NODE_TYPES.CallExpression && (factoryName(current, FACTORIES) !== null || factoryName(current, COMPOSITE_FACTORIES) !== null))
           return true;
       }
@@ -31059,7 +31108,7 @@ var prefer_non_nullable_collection_default = createRule({
           const bindingProperty = parameter.properties.find(
             (entry) => entry.type === import_utils174.AST_NODE_TYPES.Property && !entry.computed && import_utils174.ASTUtils.getPropertyName(entry) === property.name
           );
-          if (bindingProperty === void 0) continue;
+          if (bindingProperty?.type !== import_utils174.AST_NODE_TYPES.Property) continue;
           const value = bindingProperty.value;
           const binding3 = value.type === import_utils174.AST_NODE_TYPES.AssignmentPattern ? value.left : value;
           if (binding3.type !== import_utils174.AST_NODE_TYPES.Identifier) {
@@ -35872,7 +35921,7 @@ function injectedMembers(owner) {
   const constructor = owner.body.body.find(
     (member3) => member3.type === import_utils191.AST_NODE_TYPES.MethodDefinition && member3.kind === "constructor"
   );
-  if (constructor === void 0) return injected;
+  if (constructor?.type !== import_utils191.AST_NODE_TYPES.MethodDefinition) return injected;
   const parameters = /* @__PURE__ */ new Set();
   for (const parameter of constructor.value.params) {
     for (const name of parameterNames(parameter)) parameters.add(name);
@@ -38606,6 +38655,7 @@ var RETIRED_RULES = {
 
 // src/index.ts
 var RULES = {
+  "no-explicit-type-predicate": no_explicit_type_predicate_default,
   "prefer-zod-enum-validator": prefer_zod_enum_validator_default,
   "no-growing-array-spread-in-loop": no_growing_array_spread_in_loop_default,
   "no-logical-or-fallback": no_logical_or_fallback_default,
@@ -38788,6 +38838,7 @@ var RULE_POLICY = {
   "@sarj/no-invalid-typed-mutation": ["error", "both"],
   "@sarj/no-contradictory-type-predicate": ["error", "both"],
   "@sarj/no-partial-type-predicate": ["error", "both"],
+  "@sarj/no-explicit-type-predicate": ["warn", "both"],
   "@sarj/no-boolean-selector-parameter": ["warn", "both"],
   "@sarj/no-invalid-zod-custom-parse": ["error", "both"],
   "@sarj/no-contradictory-overload-return": ["error", "both"],