@sarj/eslint-plugin 15.17.1 → 15.17.2

package/dist/index.cjs

@@ -12048,99 +12048,367 @@ var prefer_module_level_schema_default = createRule({
 
 // src/rules/prefer-module-level-refined-schema.ts
 var import_utils69 = require("@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([
+  import_utils69.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils69.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils69.AST_NODE_TYPES.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 ([import_utils69.AST_NODE_TYPES.ArrowFunctionExpression, import_utils69.AST_NODE_TYPES.FunctionDeclaration, import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.ThisExpression || inner.type === import_utils69.AST_NODE_TYPES.Super || inner.type === import_utils69.AST_NODE_TYPES.Identifier && inner.name === "arguments"
+  );
+}
+function buildsLocalizedText2(node) {
+  return subtreeSome2(node, (inner) => {
+    if (inner.type === import_utils69.AST_NODE_TYPES.TaggedTemplateExpression) return true;
+    if (inner.type !== import_utils69.AST_NODE_TYPES.CallExpression) return false;
+    const { callee } = inner;
+    if (callee.type === import_utils69.AST_NODE_TYPES.Identifier)
+      return I18N_CALLEE_NAMES2.has(callee.name);
+    return callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES2.has(callee.object.name);
+  });
+}
+function calleeChainRoot(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils69.AST_NODE_TYPES.Identifier) return current;
+    if (current.type === import_utils69.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+      continue;
+    }
+    if (current.type === import_utils69.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    return null;
+  }
+}
+function chainMemberNames(node) {
+  const names = [];
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils69.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils69.AST_NODE_TYPES.Identifier)
+        return [];
+      names.push(current.property.name);
+      current = current.object;
+      continue;
+    }
+    if (current.type === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils69.AST_NODE_TYPES.Identifier && parent.parent?.type === import_utils69.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent) {
+      if (NON_SCHEMA_TERMINALS.has(parent.property.name)) return current;
+      current = parent.parent;
+      continue;
+    }
+    if (parent?.type === import_utils69.AST_NODE_TYPES.TSAsExpression || parent?.type === import_utils69.AST_NODE_TYPES.TSNonNullExpression || parent?.type === import_utils69.AST_NODE_TYPES.TSSatisfiesExpression || parent?.type === import_utils69.AST_NODE_TYPES.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 import_utils69.ASTUtils.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 !== import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.ArrayExpression && argument.elements.length >= 2 && argument.elements.every(
+        (element) => element?.type === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils69.AST_NODE_TYPES.Identifier && MEMO_CALLEES2.has(current.callee.name) || current.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.CallExpression && parent.callee === reference.identifier && !zodBindings.has(resolved))
+              return false;
+            continue;
+          }
+          if (definition.node.type === import_utils69.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") namespaces.add(specifier.local.name);
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils69.AST_NODE_TYPES.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 !== import_utils69.AST_NODE_TYPES.MemberExpression || node.parent.object !== node) return;
-        if (node.callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils69.AST_NODE_TYPES.Identifier || !namespaces.has(node.callee.object.name) || node.callee.property.type !== import_utils69.AST_NODE_TYPES.Identifier || !FACTORIES.has(node.callee.property.name)) return;
-        let current = node;
-        let refinements = 0;
-        while (current.parent?.type === import_utils69.AST_NODE_TYPES.MemberExpression && current.parent.object === current && !current.parent.computed && current.parent.property.type === import_utils69.AST_NODE_TYPES.Identifier && current.parent.parent?.type === import_utils69.AST_NODE_TYPES.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 === import_utils69.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils69.AST_NODE_TYPES.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" });
       }
     };
@@ -12154,20 +12422,21 @@ var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
   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
@@ -12176,80 +12445,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 === import_utils70.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.object.name === object && node.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.property.name === method;
+function isStaticPrimitive(node, context) {
+  if (node.type === import_utils70.AST_NODE_TYPES.Literal) {
+    return node.value === null || ["bigint", "boolean", "number", "string"].includes(typeof node.value);
+  }
+  if (node.type === import_utils70.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0)
+    return true;
+  if (node.type === import_utils70.AST_NODE_TYPES.Identifier && node.name === "undefined") {
+    const binding = import_utils70.ASTUtils.findVariable(
+      context.sourceCode.getScope(node),
+      node.name
+    );
+    return binding === null || binding.defs.length === 0;
+  }
+  return node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "-" && node.argument.type === import_utils70.AST_NODE_TYPES.Literal && ["bigint", "number"].includes(typeof node.argument.value);
+}
+function isStaticString(node) {
+  return node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils70.AST_NODE_TYPES.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 import_utils70.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function directMemberCall(node, binding, method) {
+      if (node.callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils70.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils70.AST_NODE_TYPES.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 === import_utils70.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils70.AST_NODE_TYPES.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 === import_utils70.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils70.AST_NODE_TYPES.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 !== import_utils70.AST_NODE_TYPES.MemberExpression || node.callee.object.type !== import_utils70.AST_NODE_TYPES.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 !== import_utils70.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 3 || argument.elements.some((element) => {
-          if (element === null || element.type !== import_utils70.AST_NODE_TYPES.CallExpression || !memberCall(element, namespace, "literal") || element.arguments.length !== 1)
-            return true;
-          const [value] = element.arguments;
-          return value === void 0 || value.type === import_utils70.AST_NODE_TYPES.SpreadElement || ![
-            import_utils70.AST_NODE_TYPES.Literal,
-            import_utils70.AST_NODE_TYPES.TemplateLiteral
-          ].includes(value.type);
-        }))
+        if (argument?.type !== import_utils70.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2)
           return;
+        const values = [];
+        for (const element of argument.elements) {
+          if (element === null || element.type !== import_utils70.AST_NODE_TYPES.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(", ")}])`
+          )
         });
       }
     };
@@ -18436,8 +18741,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",
@@ -18550,7 +18855,7 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "transform"
 ]);
 var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils100.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-var calleeChainRoot = (node) => {
+var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
     if (current.type === import_utils100.AST_NODE_TYPES.Identifier) {
@@ -18567,7 +18872,7 @@ var calleeChainRoot = (node) => {
     return null;
   }
 };
-var chainMemberNames = (node) => {
+var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
@@ -18627,7 +18932,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);
@@ -18643,16 +18948,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 {
@@ -18855,14 +19160,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",