@sarj/eslint-plugin 15.17.1 → 15.17.2

package/dist/index.js

@@ -12019,100 +12019,371 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-module-level-refined-schema.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53 } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES53,
+  ASTUtils as ASTUtils15
+} from "@typescript-eslint/utils";
+var BENCHMARK_PATH_RE = /(^|[/\\])(?:benchmarks?|bench)[/\\]/;
 var FACTORIES = /* @__PURE__ */ new Set([
   "array",
+  "base64",
+  "base64url",
   "bigint",
   "boolean",
+  "cidrv4",
+  "cidrv6",
+  "codec",
+  "custom",
   "date",
-  "number",
-  "string"
-]);
-var REFINEMENTS = /* @__PURE__ */ new Set([
-  "brand",
-  "check",
+  "datetime",
+  "duration",
   "email",
-  "finite",
-  "int",
-  "length",
-  "max",
-  "min",
-  "multipleOf",
-  "nonempty",
-  "positive",
-  "regex",
-  "refine",
-  "safe",
-  "superRefine",
-  "transform",
-  "trim",
+  "emoji",
+  "enum",
+  "file",
+  "function",
+  "hash",
+  "hex",
+  "hostname",
+  "instanceof",
+  "ipv4",
+  "ipv6",
+  "json",
+  "jwt",
+  "literal",
+  "map",
+  "nan",
+  "nativeEnum",
+  "never",
+  "null",
+  "nullable",
+  "nullish",
+  "number",
+  "optional",
+  "partialRecord",
+  "preprocess",
+  "promise",
+  "set",
+  "string",
+  "stringbool",
+  "symbol",
+  "templateLiteral",
+  "time",
+  "undefined",
   "url",
-  "uuid"
+  "uuid",
+  "void"
+]);
+var COMPOSITE_FACTORIES = /* @__PURE__ */ new Set([
+  "discriminatedUnion",
+  "intersection",
+  "looseObject",
+  "object",
+  "record",
+  "strictObject",
+  "tuple",
+  "union"
+]);
+var FACTORY_NAMESPACES = /* @__PURE__ */ new Set(["coerce", "iso"]);
+var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
+  "decode",
+  "decodeAsync",
+  "encode",
+  "encodeAsync",
+  "flattenError",
+  "formatError",
+  "implement",
+  "isNullable",
+  "isOptional",
+  "parse",
+  "parseAsync",
+  "prettifyError",
+  "registry",
+  "safeDecode",
+  "safeDecodeAsync",
+  "safeEncode",
+  "safeEncodeAsync",
+  "safeParse",
+  "safeParseAsync",
+  "spa",
+  "toJSONSchema",
+  "treeifyError"
+]);
+var MEMO_CALLEES2 = /* @__PURE__ */ new Set([
+  "lazy",
+  "memo",
+  "once",
+  "useMemo"
+]);
+var I18N_CALLEE_NAMES2 = /* @__PURE__ */ new Set([
+  "$t",
+  "defineMessage",
+  "gettext",
+  "msg",
+  "ngettext",
+  "t",
+  "translate"
+]);
+var I18N_RECEIVER_NAMES2 = /* @__PURE__ */ new Set([
+  "$i18n",
+  "i18n",
+  "intl"
+]);
+var FUNCTION_TYPES9 = /* @__PURE__ */ new Set([
+  AST_NODE_TYPES53.ArrowFunctionExpression,
+  AST_NODE_TYPES53.FunctionDeclaration,
+  AST_NODE_TYPES53.FunctionExpression
 ]);
 var PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION = {
-  summary: "Declare closed, refined Zod scalar and array schemas at module scope.",
+  summary: "Declare closed Zod scalar, format, and wrapper schemas at module scope.",
   rationale: "A closed validation pipeline created inside a function is rebuilt on every invocation and obscures a reusable constraint.",
-  remediation: "Move the validation schema to module scope and call parse on the shared schema.",
+  remediation: "Move the validation schema to module scope, name it with a PascalCase Schema suffix, and call parse on the shared schema.",
   category: "performance",
-  limitations: ["Only direct Zod scalar/array chains with at least two refinement methods and no non-literal arguments are reported."],
+  limitations: [
+    "Composite object/record/tuple/union schemas are owned by prefer-module-level-schema.",
+    "Schemas that depend on function-local or mutable state, localized text, receiver state, lazy construction, or recognized memoization are excluded.",
+    "Literal string z.enum domains are owned by prefer-shared-zod-enum."
+  ],
   examples: [
-    { id: "module-refinement", title: "Share the validation schema", outcome: "no-match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; const BatchSize = z.number().int().min(1).max(1000); export function parse(value: unknown) { return BatchSize.parse(value); }" }], focusPath: "src/options.ts", expectedCount: 0, public: true },
-    { id: "local-refinement", title: "Do not rebuild a closed validation chain", outcome: "match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; export function parse(value: unknown) { return z.number().int().min(1).max(1000).parse(value); }" }], focusPath: "src/options.ts", expectedCount: 1, public: true }
+    {
+      id: "module-refinement",
+      title: "Share the validation schema",
+      outcome: "no-match",
+      files: [{
+        path: "src/options.ts",
+        source: "import { z } from 'zod'; const BatchSizeSchema = z.number().int().min(1).max(1000); export function parse(value: unknown) { return BatchSizeSchema.parse(value); }"
+      }],
+      focusPath: "src/options.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "local-refinement",
+      title: "Do not rebuild a closed validation chain",
+      outcome: "match",
+      files: [{
+        path: "src/options.ts",
+        source: "import { z } from 'zod'; export function parse(value: unknown) { return z.string().trim().min(1).max(128).parse(value); }"
+      }],
+      focusPath: "src/options.ts",
+      expectedCount: 1,
+      public: true
+    }
   ]
 };
-function enclosingFunction4(node) {
+function outermostEnclosingFunction2(node) {
+  let outermost;
   let current = node.parent ?? void 0;
   while (current !== void 0) {
-    if ([AST_NODE_TYPES53.ArrowFunctionExpression, AST_NODE_TYPES53.FunctionDeclaration, AST_NODE_TYPES53.FunctionExpression].includes(current.type)) return current;
+    if (FUNCTION_TYPES9.has(current.type)) outermost = current;
     current = current.parent ?? void 0;
   }
-  return void 0;
+  return outermost;
 }
 function collectReferences2(scope, output) {
   output.push(...scope.references);
   for (const child of scope.childScopes) collectReferences2(child, output);
 }
+function subtreeSome2(root, predicate) {
+  let found = false;
+  const visit = (value) => {
+    if (found || value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    const candidate2 = value;
+    if (typeof candidate2.type !== "string") return;
+    if (predicate(candidate2)) {
+      found = true;
+      return;
+    }
+    for (const key of Object.keys(candidate2)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      visit(candidate2[key]);
+    }
+  };
+  visit(root);
+  return found;
+}
+function readsReceiver2(node) {
+  return subtreeSome2(
+    node,
+    (inner) => inner.type === AST_NODE_TYPES53.ThisExpression || inner.type === AST_NODE_TYPES53.Super || inner.type === AST_NODE_TYPES53.Identifier && inner.name === "arguments"
+  );
+}
+function buildsLocalizedText2(node) {
+  return subtreeSome2(node, (inner) => {
+    if (inner.type === AST_NODE_TYPES53.TaggedTemplateExpression) return true;
+    if (inner.type !== AST_NODE_TYPES53.CallExpression) return false;
+    const { callee } = inner;
+    if (callee.type === AST_NODE_TYPES53.Identifier)
+      return I18N_CALLEE_NAMES2.has(callee.name);
+    return callee.type === AST_NODE_TYPES53.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES53.Identifier && I18N_RECEIVER_NAMES2.has(callee.object.name);
+  });
+}
+function calleeChainRoot(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === AST_NODE_TYPES53.Identifier) return current;
+    if (current.type === AST_NODE_TYPES53.MemberExpression) {
+      current = current.object;
+      continue;
+    }
+    if (current.type === AST_NODE_TYPES53.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    return null;
+  }
+}
+function chainMemberNames(node) {
+  const names = [];
+  let current = node;
+  for (; ; ) {
+    if (current.type === AST_NODE_TYPES53.MemberExpression) {
+      if (current.computed || current.property.type !== AST_NODE_TYPES53.Identifier)
+        return [];
+      names.push(current.property.name);
+      current = current.object;
+      continue;
+    }
+    if (current.type === AST_NODE_TYPES53.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    break;
+  }
+  names.reverse();
+  return names;
+}
+function schemaExpression2(node) {
+  let current = node;
+  for (; ; ) {
+    const parent = current.parent ?? void 0;
+    if (parent?.type === AST_NODE_TYPES53.MemberExpression && parent.object === current && !parent.computed && parent.property.type === AST_NODE_TYPES53.Identifier && parent.parent?.type === AST_NODE_TYPES53.CallExpression && parent.parent.callee === parent) {
+      if (NON_SCHEMA_TERMINALS.has(parent.property.name)) return current;
+      current = parent.parent;
+      continue;
+    }
+    if (parent?.type === AST_NODE_TYPES53.TSAsExpression || parent?.type === AST_NODE_TYPES53.TSNonNullExpression || parent?.type === AST_NODE_TYPES53.TSSatisfiesExpression || parent?.type === AST_NODE_TYPES53.TSTypeAssertion) {
+      current = parent;
+      continue;
+    }
+    return current;
+  }
+}
 var prefer_module_level_refined_schema_default = createRule({
   name: "prefer-module-level-refined-schema",
   documentation: PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION,
-  meta: { type: "suggestion", docs: { description: "Declare closed, refined Zod scalar and array schemas at module scope." }, schema: [], messages: { hoistRefinedSchema: "Move this closed refined Zod schema to module scope and reuse it for parsing." } },
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Declare closed Zod scalar, format, and wrapper schemas at module scope."
+    },
+    schema: [],
+    messages: {
+      hoistRefinedSchema: "Move this closed Zod schema to module scope, give it a PascalCase Schema name, and reuse it for parsing."
+    }
+  },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
-    const namespaces = /* @__PURE__ */ new Set();
+    if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
+      return {};
+    const zodBindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return ASTUtils15.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function recordZodBinding(identifier) {
+      const binding = resolvedBinding(identifier);
+      if (binding !== null) zodBindings.add(binding);
+    }
+    function factoryName(node, allowed) {
+      if (node.callee.type !== AST_NODE_TYPES53.MemberExpression) return null;
+      const root = calleeChainRoot(node.callee);
+      if (root === null) return null;
+      const binding = resolvedBinding(root);
+      if (binding === null || !zodBindings.has(binding)) return null;
+      const names = chainMemberNames(node.callee);
+      if (names.length === 1 && allowed.has(names[0] ?? ""))
+        return names[0] ?? null;
+      if (names.length === 2 && FACTORY_NAMESPACES.has(names[0] ?? "") && allowed.has(names[1] ?? ""))
+        return names[1] ?? null;
+      return null;
+    }
+    function isSharedEnumDomain(node, factory) {
+      if (factory !== "enum") return false;
+      const [argument] = node.arguments;
+      return argument?.type === AST_NODE_TYPES53.ArrayExpression && argument.elements.length >= 2 && argument.elements.every(
+        (element) => element?.type === AST_NODE_TYPES53.Literal && typeof element.value === "string"
+      );
+    }
+    function isNestedInOwnedFactory(node) {
+      let current = node;
+      while (current.parent != null) {
+        current = current.parent;
+        if (FUNCTION_TYPES9.has(current.type)) return false;
+        if (current.type === AST_NODE_TYPES53.CallExpression && (factoryName(current, FACTORIES) !== null || factoryName(current, COMPOSITE_FACTORIES) !== null))
+          return true;
+      }
+      return false;
+    }
+    function isMemoized(node) {
+      let current = node.parent ?? void 0;
+      while (current !== void 0) {
+        if (current.type === AST_NODE_TYPES53.CallExpression && (current.callee.type === AST_NODE_TYPES53.Identifier && MEMO_CALLEES2.has(current.callee.name) || current.callee.type === AST_NODE_TYPES53.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES53.Identifier && MEMO_CALLEES2.has(current.callee.property.name)))
+          return true;
+        current = current.parent ?? void 0;
+      }
+      return false;
+    }
+    function closesOverNothing(node, enclosing) {
+      const references = [];
+      collectReferences2(context.sourceCode.getScope(node), references);
+      const [start, end] = node.range;
+      const [functionStart, functionEnd] = enclosing.range;
+      for (const reference of references) {
+        const [referenceStart] = reference.identifier.range;
+        if (referenceStart < start || referenceStart >= end) continue;
+        const resolved = reference.resolved;
+        if (resolved === null) continue;
+        for (const definition of resolved.defs) {
+          if (definition.type === "ImportBinding") {
+            const parent = reference.identifier.parent;
+            if (parent?.type === AST_NODE_TYPES53.CallExpression && parent.callee === reference.identifier && !zodBindings.has(resolved))
+              return false;
+            continue;
+          }
+          if (definition.node.type === AST_NODE_TYPES53.VariableDeclarator && definition.node.parent.type === AST_NODE_TYPES53.VariableDeclaration && definition.node.parent.kind !== "const")
+            return false;
+          const [definitionStart, definitionEnd] = definition.node.range;
+          if (definitionStart >= start && definitionEnd <= end) continue;
+          if (definitionStart >= functionStart && definitionEnd <= functionEnd)
+            return false;
+        }
+      }
+      return true;
+    }
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
-        for (const specifier of node.specifiers) if (specifier.type === AST_NODE_TYPES53.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES53.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES53.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES53.Identifier && specifier.imported.name === "z") namespaces.add(specifier.local.name);
+        for (const specifier of node.specifiers) {
+          if (specifier.type === AST_NODE_TYPES53.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES53.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES53.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES53.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z"))
+            recordZodBinding(specifier.local);
+        }
       },
       CallExpression(node) {
-        const enclosing = enclosingFunction4(node);
-        if (enclosing === void 0 || node.parent?.type !== AST_NODE_TYPES53.MemberExpression || node.parent.object !== node) return;
-        if (node.callee.type !== AST_NODE_TYPES53.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES53.Identifier || !namespaces.has(node.callee.object.name) || node.callee.property.type !== AST_NODE_TYPES53.Identifier || !FACTORIES.has(node.callee.property.name)) return;
-        let current = node;
-        let refinements = 0;
-        while (current.parent?.type === AST_NODE_TYPES53.MemberExpression && current.parent.object === current && !current.parent.computed && current.parent.property.type === AST_NODE_TYPES53.Identifier && current.parent.parent?.type === AST_NODE_TYPES53.CallExpression && current.parent.parent.callee === current.parent) {
-          const call = current.parent.parent;
-          if (["parse", "parseAsync", "safeParse", "safeParseAsync"].includes(current.parent.property.name)) break;
-          if (REFINEMENTS.has(current.parent.property.name)) refinements += 1;
-          current = call;
-        }
-        if (refinements < 2) return;
-        const references = [];
-        collectReferences2(context.sourceCode.getScope(current), references);
-        const [start, end] = current.range;
-        const [functionStart, functionEnd] = enclosing.range;
-        for (const reference of references) {
-          const [referenceStart] = reference.identifier.range;
-          if (referenceStart < start || referenceStart >= end || reference.resolved === null) continue;
-          for (const definition of reference.resolved.defs) {
-            if (definition.type === "ImportBinding") continue;
-            if (definition.node.type === AST_NODE_TYPES53.VariableDeclarator && definition.node.parent.type === AST_NODE_TYPES53.VariableDeclaration && definition.node.parent.kind !== "const") return;
-            const [definitionStart, definitionEnd] = definition.node.range;
-            if (definitionStart >= start && definitionEnd <= end) continue;
-            if (definitionStart >= functionStart && definitionEnd <= functionEnd) return;
-          }
-        }
+        const factory = factoryName(node, FACTORIES);
+        if (factory === null || isSharedEnumDomain(node, factory) || isNestedInOwnedFactory(node) || isMemoized(node))
+          return;
+        const enclosing = outermostEnclosingFunction2(node);
+        if (enclosing === void 0) return;
+        const expression = schemaExpression2(node);
+        if (readsReceiver2(expression) || buildsLocalizedText2(expression) || !closesOverNothing(expression, enclosing))
+          return;
         context.report({ node, messageId: "hoistRefinedSchema" });
       }
     };
@@ -12120,26 +12391,30 @@ var prefer_module_level_refined_schema_default = createRule({
 });
 
 // src/rules/prefer-multi-value-zod-literal.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES54 } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES54,
+  ASTUtils as ASTUtils16
+} from "@typescript-eslint/utils";
 var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
   summary: "Use the Zod 4 multi-value literal API instead of a union of literal schemas.",
   rationale: "One multi-value literal expresses the same closed value domain without repeated schema wrappers.",
   remediation: "Replace the union with z.literal([value1, value2, ...]).",
   category: "maintainability",
+  autofix: "safe",
   limitations: [
-    "Bare `zod` imports are analyzed only when the rule option explicitly declares `zodMajorVersion: 4`; `zod/v4` imports are self-declaring."
+    "Bare zod imports are analyzed only when the rule option explicitly declares zodMajorVersion: 4; explicit zod/v4 entrypoints are self-declaring.",
+    "All-string domains are left to zod/prefer-enum-over-literal-union.",
+    "A finding containing comments is not autofixed because moving its trivia is ambiguous."
   ],
   examples: [
     {
       id: "multi-value",
       title: "Use one multi-value literal",
       outcome: "no-match",
-      files: [
-        {
-          path: "src/schema.ts",
-          source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
-        }
-      ],
+      files: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
+      }],
       focusPath: "src/schema.ts",
       expectedCount: 0,
       public: true
@@ -12148,80 +12423,116 @@ var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
       id: "literal-union",
       title: "Avoid repeated literal wrappers",
       outcome: "match",
-      files: [
-        {
-          path: "src/schema.ts",
-          source: "import { z } from 'zod'; export const Version = z.union([z.literal(1), z.literal(2), z.literal(3)]);"
-        }
-      ],
+      files: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.union([z.literal(1), z.literal(2), z.literal(3)]);"
+      }],
+      fixedFiles: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
+      }],
       focusPath: "src/schema.ts",
       expectedCount: 1,
       public: true
     }
   ]
 };
-function memberCall(node, object, method) {
-  return node.callee.type === AST_NODE_TYPES54.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES54.Identifier && node.callee.object.name === object && node.callee.property.type === AST_NODE_TYPES54.Identifier && node.callee.property.name === method;
+function isStaticPrimitive(node, context) {
+  if (node.type === AST_NODE_TYPES54.Literal) {
+    return node.value === null || ["bigint", "boolean", "number", "string"].includes(typeof node.value);
+  }
+  if (node.type === AST_NODE_TYPES54.TemplateLiteral && node.expressions.length === 0)
+    return true;
+  if (node.type === AST_NODE_TYPES54.Identifier && node.name === "undefined") {
+    const binding = ASTUtils16.findVariable(
+      context.sourceCode.getScope(node),
+      node.name
+    );
+    return binding === null || binding.defs.length === 0;
+  }
+  return node.type === AST_NODE_TYPES54.UnaryExpression && node.operator === "-" && node.argument.type === AST_NODE_TYPES54.Literal && ["bigint", "number"].includes(typeof node.argument.value);
+}
+function isStaticString(node) {
+  return node.type === AST_NODE_TYPES54.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES54.TemplateLiteral && node.expressions.length === 0;
 }
 var prefer_multi_value_zod_literal_default = createRule({
   name: "prefer-multi-value-zod-literal",
   documentation: PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION,
   meta: {
     type: "suggestion",
+    fixable: "code",
     docs: {
       description: "Use the Zod 4 multi-value literal API instead of a union of literal schemas."
     },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          zodMajorVersion: { type: "integer", minimum: 4, maximum: 4 }
-        }
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        zodMajorVersion: { type: "integer", minimum: 4, maximum: 4 }
       }
-    ],
+    }],
     messages: {
-      useMultiValueLiteral: "Replace this literal-schema union with `{{zod}}.literal([\u2026])`."
+      useMultiValueLiteral: "Replace this literal-schema union with {{zod}}.literal([\u2026])."
     }
   },
   defaultOptions: [{}],
   create(context, [options]) {
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
       return {};
-    const namespaces = /* @__PURE__ */ new Set();
-    const zod4Namespaces = /* @__PURE__ */ new Set();
+    const zodBindings = /* @__PURE__ */ new Set();
+    const zod4Bindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return ASTUtils16.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function directMemberCall(node, binding, method) {
+      if (node.callee.type !== AST_NODE_TYPES54.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES54.Identifier || node.callee.property.type !== AST_NODE_TYPES54.Identifier || node.callee.property.name !== method)
+        return false;
+      return resolvedBinding(node.callee.object) === binding;
+    }
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
+        const isExplicitV4 = /^zod\/v4(?:$|[-/])/.test(node.source.value);
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES54.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES54.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES54.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES54.Identifier && specifier.imported.name === "z") {
-            namespaces.add(specifier.local.name);
-            if (node.source.value === "zod/v4" || node.source.value.startsWith("zod/v4/"))
-              zod4Namespaces.add(specifier.local.name);
+          if (specifier.type === AST_NODE_TYPES54.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES54.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES54.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES54.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+            const binding = resolvedBinding(specifier.local);
+            if (binding === null) continue;
+            zodBindings.add(binding);
+            if (isExplicitV4) zod4Bindings.add(binding);
           }
         }
       },
       CallExpression(node) {
-        const namespace = [...namespaces].find(
-          (name) => memberCall(node, name, "union")
-        );
-        if (namespace === void 0 || options?.zodMajorVersion !== 4 && !zod4Namespaces.has(namespace) || node.arguments.length !== 1)
+        if (node.callee.type !== AST_NODE_TYPES54.MemberExpression || node.callee.object.type !== AST_NODE_TYPES54.Identifier)
+          return;
+        const binding = resolvedBinding(node.callee.object);
+        if (binding === null || !zodBindings.has(binding) || !directMemberCall(node, binding, "union") || options?.zodMajorVersion !== 4 && !zod4Bindings.has(binding) || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument?.type !== AST_NODE_TYPES54.ArrayExpression || argument.elements.length < 3 || argument.elements.some((element) => {
-          if (element === null || element.type !== AST_NODE_TYPES54.CallExpression || !memberCall(element, namespace, "literal") || element.arguments.length !== 1)
-            return true;
-          const [value] = element.arguments;
-          return value === void 0 || value.type === AST_NODE_TYPES54.SpreadElement || ![
-            AST_NODE_TYPES54.Literal,
-            AST_NODE_TYPES54.TemplateLiteral
-          ].includes(value.type);
-        }))
+        if (argument?.type !== AST_NODE_TYPES54.ArrayExpression || argument.elements.length < 2)
           return;
+        const values = [];
+        for (const element of argument.elements) {
+          if (element === null || element.type !== AST_NODE_TYPES54.CallExpression || !directMemberCall(element, binding, "literal") || element.arguments.length !== 1)
+            return;
+          const [value] = element.arguments;
+          if (value === void 0 || !isStaticPrimitive(value, context)) return;
+          values.push(value);
+        }
+        if (values.every(isStaticString)) return;
+        const namespace = node.callee.object.name;
+        const hasComments = context.sourceCode.getCommentsInside(node).length > 0;
         context.report({
           node,
           messageId: "useMultiValueLiteral",
-          data: { zod: namespace }
+          data: { zod: namespace },
+          fix: hasComments ? null : (fixer) => fixer.replaceText(
+            node,
+            `${namespace}.literal([${values.map((value) => context.sourceCode.getText(value)).join(", ")}])`
+          )
         });
       }
     };
@@ -12338,7 +12649,7 @@ var prefer_named_complex_return_type_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils17 } from "@typescript-eslint/utils";
 var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
@@ -12374,7 +12685,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils15.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils17.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -12437,7 +12748,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-node-crypto-hash.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES58, ASTUtils as ASTUtils16 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES58, ASTUtils as ASTUtils18 } from "@typescript-eslint/utils";
 var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   summary: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
   rationale: "A createHash-update-digest chain allocates mutable streaming state for a single in-memory value; Node's built-in hash function expresses the one-shot operation directly and can use its optimized fast path.",
@@ -12493,7 +12804,7 @@ var prefer_node_crypto_hash_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils16.findVariable(
+      return ASTUtils18.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -12680,7 +12991,7 @@ var prefer_node_fs_promises_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES60, ASTUtils as ASTUtils17 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES60, ASTUtils as ASTUtils19 } from "@typescript-eslint/utils";
 var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -12810,14 +13121,14 @@ function directlyCoalesced(node) {
   return parent?.type === AST_NODE_TYPES60.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = ASTUtils17.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = ASTUtils19.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = ASTUtils17.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = ASTUtils19.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
@@ -12927,7 +13238,7 @@ var prefer_non_nullable_collection_default = createRule({
 // src/rules/prefer-nullish-filter-predicate.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES61,
-  ASTUtils as ASTUtils18,
+  ASTUtils as ASTUtils20,
   ESLintUtils as ESLintUtils5
 } from "@typescript-eslint/utils";
 import ts3 from "typescript";
@@ -12973,7 +13284,7 @@ var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   ]
 };
 function isUnshadowedBoolean(node, context) {
-  const variable = ASTUtils18.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = ASTUtils20.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isBuiltinArrayFilter(node, services) {
@@ -13032,7 +13343,7 @@ function isProvablyTruthy(type, checker) {
 }
 function availableParameterName(node, context) {
   for (const name of ["value", "item", "element", "candidate"]) {
-    if (ASTUtils18.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+    if (ASTUtils20.findVariable(context.sourceCode.getScope(node), name) === null) return name;
   }
   return null;
 }
@@ -13086,7 +13397,7 @@ var prefer_nullish_filter_predicate_default = createRule({
 
 // src/rules/prefer-await-in-async-return.ts
 import {
-  ASTUtils as ASTUtils19,
+  ASTUtils as ASTUtils21,
   ESLintUtils as ESLintUtils6,
   AST_NODE_TYPES as AST_NODE_TYPES62
 } from "@typescript-eslint/utils";
@@ -13200,13 +13511,13 @@ var prefer_await_in_async_return_default = createRule({
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = ASTUtils19.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils21.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
       if (parent.type !== AST_NODE_TYPES62.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES62.Identifier) return false;
-      const variable = ASTUtils19.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      const variable = ASTUtils21.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
       return variable !== null && frameworkLoaders.has(variable);
     };
     return {
@@ -14786,7 +15097,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES68, ASTUtils as ASTUtils20 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES68, ASTUtils as ASTUtils22 } from "@typescript-eslint/utils";
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -14812,7 +15123,7 @@ function staticMemberName5(node) {
   return null;
 }
 function importedName6(identifier, context, modules) {
-  const variable = ASTUtils20.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = ASTUtils22.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
     if (definition.node.type !== AST_NODE_TYPES68.ImportSpecifier) continue;
@@ -15813,7 +16124,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES71, ASTUtils as ASTUtils21 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES71, ASTUtils as ASTUtils23 } from "@typescript-eslint/utils";
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -15894,7 +16205,7 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils21.findVariable(scope, identifier.name);
+      const variable = ASTUtils23.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
@@ -15904,7 +16215,7 @@ var require_fetch_timeout_default = createRule({
       return callee.type === AST_NODE_TYPES71.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES71.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES71.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = ASTUtils21.findVariable(
+      const variable = ASTUtils23.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -16993,7 +17304,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-import { ASTUtils as ASTUtils22 } from "@typescript-eslint/utils";
+import { ASTUtils as ASTUtils24 } from "@typescript-eslint/utils";
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "react-hook-form useForm call without defaultValues",
   rationale: "Without an explicit initial value, fields can change from uncontrolled to controlled as data arrives, reset behavior becomes ambiguous, and the form's initial shape no longer documents the values users can edit.",
@@ -17047,13 +17358,13 @@ var require_use_form_default_values_default = createRule({
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "useForm") continue;
-          const variable = ASTUtils22.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = ASTUtils24.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
           if (variable) importedHooks.add(variable);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== "Identifier") return;
-        const variable = ASTUtils22.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = ASTUtils24.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
         const options = node.arguments[0];
         if (!variable || !importedHooks.has(variable) || options !== void 0 && options.type !== "ObjectExpression" || hasDefaultValues(options)) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -17131,7 +17442,7 @@ var require_use_server_in_actions_file_default = createRule({
 // src/rules/require-zod-form-validation.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES76,
-  ASTUtils as ASTUtils23
+  ASTUtils as ASTUtils25
 } from "@typescript-eslint/utils";
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
@@ -17199,7 +17510,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => ASTUtils23.findVariable(
+    const resolvedBinding = (identifier) => ASTUtils25.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -17496,7 +17807,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils24 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils26 } from "@typescript-eslint/utils";
 var STEPDOWN_DOCUMENTATION = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -17701,7 +18012,7 @@ function methodName(node) {
   return !node.computed && node.key.type === AST_NODE_TYPES77.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils24.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils26.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
   if (node.object.type !== AST_NODE_TYPES77.ThisExpression && !isClassReference) return null;
   if (node.property.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${node.property.name}`;
@@ -17754,11 +18065,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils24.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils26.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
   if (node.type === AST_NODE_TYPES77.ClassExpression && node.parent.type === AST_NODE_TYPES77.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES77.Identifier) {
-    const outer = ASTUtils24.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    const outer = ASTUtils26.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -17794,7 +18105,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (binding.type !== AST_NODE_TYPES77.Identifier) return;
-      const variable = ASTUtils24.findVariable(context.sourceCode.getScope(binding), binding.name);
+      const variable = ASTUtils26.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -17824,7 +18135,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils24.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils26.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
@@ -18405,7 +18716,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 // src/rules/require-pascal-case-zod-schema-name.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES80,
-  ASTUtils as ASTUtils25
+  ASTUtils as ASTUtils27
 } from "@typescript-eslint/utils";
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
@@ -18425,8 +18736,8 @@ var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   ]
 };
 var PASCAL_SCHEMA_NAME_RE = /^[A-Z][A-Za-z0-9]*Schema$/;
-var BENCHMARK_PATH_RE = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
-var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
+var BENCHMARK_PATH_RE2 = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
+var NON_SCHEMA_TERMINALS2 = /* @__PURE__ */ new Set([
   "parse",
   "parseAsync",
   "safeParse",
@@ -18539,7 +18850,7 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "transform"
 ]);
 var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES80.Identifier ? callee.property.name : null;
-var calleeChainRoot = (node) => {
+var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
     if (current.type === AST_NODE_TYPES80.Identifier) {
@@ -18556,7 +18867,7 @@ var calleeChainRoot = (node) => {
     return null;
   }
 };
-var chainMemberNames = (node) => {
+var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
@@ -18606,7 +18917,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils25.findVariable(
+      return ASTUtils27.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -18616,7 +18927,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       if (binding !== null) zodBindings.add(binding);
     }
     function isZodChain(node) {
-      const root = calleeChainRoot(node);
+      const root = calleeChainRoot2(node);
       if (root === null) return false;
       const binding = resolvedBinding(root);
       return binding !== null && zodBindings.has(binding);
@@ -18632,16 +18943,16 @@ var require_pascal_case_zod_schema_name_default = createRule({
         return false;
       }
       const terminal = terminalMethodName(init.callee);
-      if (terminal === null || NON_SCHEMA_TERMINALS.has(terminal)) return false;
-      const names = chainMemberNames(init.callee);
+      if (terminal === null || NON_SCHEMA_TERMINALS2.has(terminal)) return false;
+      const names = chainMemberNames2(init.callee);
       if (names.length === 0) return false;
       if (isZodChain(init.callee)) {
         return ZOD_SCHEMA_FACTORIES.has(names[0] ?? "") || ZOD_FACTORY_NAMESPACES.has(names[0] ?? "") && ZOD_SCHEMA_FACTORIES.has(names[1] ?? "");
       }
-      const root = calleeChainRoot(init.callee);
+      const root = calleeChainRoot2(init.callee);
       return root !== null && isSchemaBinding(root) && SCHEMA_RETURNING_METHODS.has(terminal);
     }
-    if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+    if (isTestFile(context.filename) || BENCHMARK_PATH_RE2.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     return {
@@ -18844,14 +19155,14 @@ var RULES = {
   "require-static-next-matcher": require_static_next_matcher_default,
   "require-zod-form-validation": require_zod_form_validation_default,
   "store-insert-requires-on-conflict": store_insert_requires_on_conflict_default,
-  stepdown: stepdown_default,
+  "stepdown": stepdown_default,
   "source-coupled-test": source_coupled_test_default,
   "sole-export-matches-filename": sole_export_matches_filename_default,
   "require-pascal-case-zod-schema-name": require_pascal_case_zod_schema_name_default
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.1"
+  version: "15.17.2"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",