@sarj/eslint-plugin 15.17.1 → 15.17.3

package/dist/index.js

@@ -5849,7 +5849,7 @@ var NO_RAW_FETCH_OUTSIDE_CLIENTS_DOCUMENTATION = {
   rationale: "Scattered fetch calls bypass shared transport policy and are harder to stub and observe consistently.",
   remediation: "Move the request into a client module and call that abstraction from application code.",
   category: "architecture",
-  limitations: ["Tests, client-layer paths, constructed handoffs, and pre-signed URL transfers are excluded."],
+  limitations: ["Tests, client-layer paths, constructed handoffs, and pre-signed URL transfers are excluded. Configure the same literal Next.js basePath here and on prefer-server-actions so one rule owns each internal mutation."],
   examples: [
     { id: "client-call", title: "Use a client abstraction", outcome: "no-match", files: [{ path: "src/routes/handler.ts", source: "const response = await billingClient.getInvoice(id);" }], focusPath: "src/routes/handler.ts", expectedCount: 0, public: true },
     { id: "raw-fetch", title: "Do not call global fetch here", outcome: "match", files: [{ path: "src/routes/handler.ts", source: "const response = await fetch('/api/invoices');" }], focusPath: "src/routes/handler.ts", expectedCount: 1, public: true }
@@ -5894,7 +5894,10 @@ var ANALYTICS_SEGMENTS2 = /* @__PURE__ */ new Set([
 ]);
 var SERVER_ACTION_SKIP_FILE_RE = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
 var NON_REACT_FRAMEWORK_RE = /^(?:@angular\/|@nestjs\/|vue$|vue\/|svelte$|svelte\/|solid-js$|solid-js\/|@ember\/|rxjs$|rxjs\/)/;
-var NEXT_MODULE_PATH_RE = /(?:^|[/\\])(?:app|pages)[/\\]/u;
+var BASE_PATH_RE = /^\/(?!$)(?!.*[?#])(?:[^/]+\/)*[^/]+$/u;
+function isValidBasePath(basePath) {
+  return BASE_PATH_RE.test(basePath) && !basePath.split("/").some((segment) => segment === "." || segment === "..");
+}
 function isGlobalFetchCall(node, resolvesToGlobal) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
@@ -5990,6 +5993,10 @@ var no_raw_fetch_outside_clients_default = createRule({
             type: "array",
             items: { type: "string" },
             description: "Regular-expression sources matched against the filename. Replaces the defaults."
+          },
+          basePath: {
+            type: "string",
+            pattern: "^/(?!$)(?!.*[?#])(?!(?:.*/)?\\.\\.?(?:/|$))(?:[^/]+/)*[^/]+$"
           }
         },
         additionalProperties: false
@@ -6011,12 +6018,18 @@ var no_raw_fetch_outside_clients_default = createRule({
       (statement) => statement.type === AST_NODE_TYPES24.ImportDeclaration && typeof statement.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(statement.source.value)
     );
     const hasUseClientDirective = context.sourceCode.ast.body.some(
-      (statement) => statement.type === AST_NODE_TYPES24.ExpressionStatement && statement.expression.type === AST_NODE_TYPES24.Literal && statement.expression.value === "use client"
+      (statement) => statement.type === AST_NODE_TYPES24.ExpressionStatement && statement.directive === "use client"
     );
-    const hasNextImport = context.sourceCode.ast.body.some(
-      (statement) => statement.type === AST_NODE_TYPES24.ImportDeclaration && typeof statement.source.value === "string" && (statement.source.value === "next" || statement.source.value.startsWith("next/"))
+    const hasUseServerDirective = context.sourceCode.ast.body.some(
+      (statement) => statement.type === AST_NODE_TYPES24.ExpressionStatement && statement.directive === "use server"
     );
-    const hasNextEvidence = hasNextImport || hasUseClientDirective && NEXT_MODULE_PATH_RE.test(filename);
+    const importsServerOnly = context.sourceCode.ast.body.some(
+      (statement) => statement.type === AST_NODE_TYPES24.ImportDeclaration && typeof statement.source.value === "string" && (statement.source.value === "server-only" || statement.source.value === "next/server")
+    );
+    const internalApiPrefixes = ["/api"];
+    if (options?.basePath !== void 0 && isValidBasePath(options.basePath)) {
+      internalApiPrefixes.push(`${options.basePath}/api`);
+    }
     function resolvesToGlobal(identifier) {
       const variable = ASTUtils7.findVariable(
         context.sourceCode.getScope(identifier),
@@ -6049,15 +6062,15 @@ var no_raw_fetch_outside_clients_default = createRule({
     function isInternalApiUrl(node) {
       const resolved = resolveNode2(node ?? void 0);
       if (resolved?.type === AST_NODE_TYPES24.Literal) {
-        return typeof resolved.value === "string" && /^\/(?!\/)(?:[^/]+\/)*api(?:\/|$)/.test(resolved.value);
+        return typeof resolved.value === "string" && internalApiPrefixes.some(
+          (prefix) => resolved.value === prefix || resolved.value.startsWith(`${prefix}/`)
+        );
       }
       if (resolved?.type === AST_NODE_TYPES24.TemplateLiteral) {
         const prefix = resolved.quasis[0]?.value.cooked;
-        return typeof prefix === "string" && /^\/(?!\/)(?:[^/]+\/)*api(?:\/|$)/.test(prefix);
-      }
-      if (resolved?.type === AST_NODE_TYPES24.CallExpression && resolved.callee.type === AST_NODE_TYPES24.Identifier && resolved.callee.name === "withBase") {
-        const first = resolved.arguments[0];
-        return first !== void 0 && first.type !== AST_NODE_TYPES24.SpreadElement ? isInternalApiUrl(first) : false;
+        return typeof prefix === "string" && internalApiPrefixes.some(
+          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
+        );
       }
       return resolved?.type === AST_NODE_TYPES24.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
     }
@@ -6077,7 +6090,7 @@ var no_raw_fetch_outside_clients_default = createRule({
       return resolved?.type === AST_NODE_TYPES24.LogicalExpression && resolved.operator === "||" && (isMutationMethod2(resolved.left) || isMutationMethod2(resolved.right));
     }
     function serverActionOwns(node) {
-      if (node.callee.type !== AST_NODE_TYPES24.Identifier || !hasNextEvidence || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+      if (node.callee.type !== AST_NODE_TYPES24.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
         return false;
       }
       const url = node.arguments[0];
@@ -9737,25 +9750,25 @@ var no_unsafe_mock_casting_default = createRule({
     }
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve(identifier) {
+    function resolve2(identifier) {
       return ASTUtils10.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
     }
     function record(identifier, destination) {
-      const binding = resolve(identifier);
+      const binding = resolve2(identifier);
       if (binding !== null) destination.add(binding);
     }
     function isMockTypeReference(node) {
       if (node.type !== AST_NODE_TYPES40.TSTypeReference) return false;
       const typeName = node.typeName;
       if (typeName.type === AST_NODE_TYPES40.Identifier) {
-        const binding = resolve(typeName);
+        const binding = resolve2(typeName);
         return binding !== null && directBindings.has(binding);
       }
       if (typeName.type === AST_NODE_TYPES40.TSQualifiedName && typeName.left.type === AST_NODE_TYPES40.Identifier && MOCK_TYPE_NAMES.has(typeName.right.name)) {
-        const binding = resolve(typeName.left);
+        const binding = resolve2(typeName.left);
         return binding !== null && namespaceBindings.has(binding);
       }
       return false;
@@ -11169,6 +11182,10 @@ function unwrapTransparentExport(node) {
 
 // src/rules/prefer-shadcn-primitives.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES50 } from "@typescript-eslint/utils";
+import { parse as parseTypeScript } from "@typescript-eslint/typescript-estree";
+import { existsSync, lstatSync, readFileSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, parse as parsePath, relative, resolve, sep } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
 var PREFER_SHADCN_PRIMITIVES_DOCUMENTATION = {
   summary: "Require visible raw JSX controls to use the corresponding shared shadcn primitive.",
   rationale: "Shared primitives centralize interaction, accessibility, and visual behavior across the product.",
@@ -11176,22 +11193,35 @@ var PREFER_SHADCN_PRIMITIVES_DOCUMENTATION = {
   category: "style",
   limitations: [
     "Hidden and file inputs, unassociated labels, and non-control semantic elements are excluded.",
-    "Tests and the shared components/ui primitive implementation tree are excluded."
+    "Tests and the shared components/ui primitive implementation tree are excluded.",
+    "Package-local project detection is opt-in and fails closed unless components.json, one unambiguous tsconfig/jsconfig alias, the exact primitive module, and its expected export all exist."
   ],
   examples: [
     { id: "shared-button", title: "Use a shared button", outcome: "no-match", files: [{ path: "src/form.tsx", source: "import { Button } from '@/components/ui/button'; const action = <Button>Save</Button>;" }], focusPath: "src/form.tsx", expectedCount: 0, public: true },
     { id: "raw-button", title: "Do not use a raw button", outcome: "match", files: [{ path: "src/form.tsx", source: "import { Card } from '@/components/ui/card'; const action = <button>Save</button>;" }], focusPath: "src/form.tsx", expectedCount: 1, public: true }
   ]
 };
-var SHADCN_PRIMITIVES = {
-  button: "Button",
-  dialog: "Dialog or AlertDialog family",
-  input: "Input",
-  label: "Label",
-  progress: "Progress",
-  select: "Select family",
-  table: "Table family",
-  textarea: "Textarea"
+var RAW_PRIMITIVES = {
+  button: { capability: "Button", replacement: "Button" },
+  dialog: { capability: "Dialog", replacement: "Dialog or AlertDialog family" },
+  input: { capability: "Input", replacement: "Input" },
+  label: { capability: "Label", replacement: "Label" },
+  progress: { capability: "Progress", replacement: "Progress" },
+  select: { capability: "Select", replacement: "Select family" },
+  table: { capability: "Table", replacement: "Table family" },
+  textarea: { capability: "Textarea", replacement: "Textarea" }
+};
+var CAPABILITIES = {
+  Button: "button",
+  Checkbox: "checkbox",
+  Dialog: "dialog",
+  Input: "input",
+  Label: "label",
+  Progress: "progress",
+  RadioGroup: "radio-group",
+  Select: "select",
+  Table: "table",
+  Textarea: "textarea"
 };
 var LABELABLE_ELEMENTS = /* @__PURE__ */ new Set([
   "button",
@@ -11203,7 +11233,7 @@ var LABELABLE_ELEMENTS = /* @__PURE__ */ new Set([
   "textarea"
 ]);
 var SHARED_PRIMITIVE_IMPLEMENTATION_RE = /(?:^|\/)components\/ui(?:\/|$)/i;
-var SHARED_PRIMITIVE_IMPORT_RE = /(?:^|\/)components\/ui\/[^/]+$/i;
+var SHARED_PRIMITIVE_IMPORT_RE = /(?:^|\/)components\/ui\/([^/]+)$/i;
 var AMBIGUOUS_INPUT_TYPES = /* @__PURE__ */ new Set([
   "button",
   "color",
@@ -11212,10 +11242,175 @@ var AMBIGUOUS_INPUT_TYPES = /* @__PURE__ */ new Set([
   "reset",
   "submit"
 ]);
+var MAX_PROJECT_FILE_BYTES = 1048576;
+var PROJECT_PRIMITIVES_CACHE = /* @__PURE__ */ new Map();
+function detectProjectPrimitives(filename, requested) {
+  const packageRoot = findPackageRoot(dirname(filename));
+  if (packageRoot === null) return { available: /* @__PURE__ */ new Set(), uiRoot: null };
+  const manifest = readJsonc(join(packageRoot, "components.json"));
+  const alias = stringProperty(manifest, "aliases", "ui");
+  const unresolvedUiRoot = alias === null ? null : resolveAlias(packageRoot, alias);
+  if (unresolvedUiRoot === null) return { available: /* @__PURE__ */ new Set(), uiRoot: null };
+  const uiRoot = safeContainedDirectory(packageRoot, unresolvedUiRoot);
+  if (uiRoot === null) {
+    return { available: /* @__PURE__ */ new Set(), uiRoot: null };
+  }
+  const moduleCandidates = /* @__PURE__ */ new Map();
+  for (const [capability, moduleName] of Object.entries(CAPABILITIES)) {
+    if (!requested.has(capability)) continue;
+    moduleCandidates.set(capability, ["tsx", "ts", "jsx", "js"].flatMap((extension) => [
+      join(uiRoot, `${moduleName}.${extension}`),
+      join(uiRoot, moduleName, `index.${extension}`)
+    ]));
+  }
+  const fingerprint = [
+    join(packageRoot, "components.json"),
+    join(packageRoot, "tsconfig.json"),
+    join(packageRoot, "jsconfig.json"),
+    ...[...moduleCandidates.values()].flat()
+  ].map(fileFingerprint).join("|");
+  const cacheKey = `${packageRoot}:${[...requested].sort().join(",")}`;
+  const cached = PROJECT_PRIMITIVES_CACHE.get(cacheKey);
+  if (cached?.fingerprint === fingerprint) return cached.value;
+  const available = /* @__PURE__ */ new Set();
+  for (const [capability, candidates] of moduleCandidates) {
+    if (candidates.some(
+      (candidate2) => exportsPrimitive(candidate2, capability)
+    )) {
+      available.add(capability);
+    }
+  }
+  const value = { available, uiRoot };
+  PROJECT_PRIMITIVES_CACHE.set(cacheKey, { fingerprint, value });
+  return value;
+}
+function fileFingerprint(path) {
+  try {
+    const stat = lstatSync(path);
+    return stat.isFile() ? `${path}:${stat.size}:${stat.mtimeMs}` : `${path}:excluded`;
+  } catch {
+    return `${path}:missing`;
+  }
+}
+function isWithin2(root, candidate2) {
+  const path = relative(root, candidate2);
+  return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
+}
+function safeContainedDirectory(root, candidate2) {
+  try {
+    if (!lstatSync(candidate2).isDirectory()) return null;
+    const realRoot = realpathSync(root);
+    const realCandidate = realpathSync(candidate2);
+    return isWithin2(realRoot, realCandidate) ? realCandidate : null;
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  const filesystemRoot = parsePath(dir).root;
+  for (; ; ) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (dir === filesystemRoot || parent === dir) return null;
+    dir = parent;
+  }
+}
+function readJsonc(path) {
+  try {
+    const source = readSmallRegularFile(path);
+    if (source === null) return null;
+    const errors = [];
+    const value = parseJsonc(source, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    return errors.length === 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function readSmallRegularFile(path) {
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.size > MAX_PROJECT_FILE_BYTES) return null;
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function stringProperty(value, ...keys) {
+  let current = value;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null || !(key in current)) return null;
+    current = current[key];
+  }
+  return typeof current === "string" && current.trim() !== "" ? current : null;
+}
+function resolveAlias(packageRoot, alias) {
+  if (isAbsolute(alias)) return null;
+  if (alias.startsWith(".")) return resolve(packageRoot, alias);
+  const configPath = ["tsconfig.json", "jsconfig.json"].map((name) => join(packageRoot, name)).find(existsSync);
+  if (configPath === void 0) return null;
+  const config = readJsonc(configPath);
+  if (typeof config !== "object" || config === null) return null;
+  const compilerOptions = config["compilerOptions"];
+  if (typeof compilerOptions !== "object" || compilerOptions === null) return null;
+  const options = compilerOptions;
+  const baseUrl = typeof options["baseUrl"] === "string" ? options["baseUrl"] : ".";
+  const paths = options["paths"];
+  if (typeof paths !== "object" || paths === null) return null;
+  const matches = [];
+  for (const [pattern, rawTargets] of Object.entries(paths)) {
+    if (!Array.isArray(rawTargets) || rawTargets.length !== 1) {
+      continue;
+    }
+    const [target] = rawTargets;
+    if (typeof target !== "string") continue;
+    const star = pattern.indexOf("*");
+    if (star === -1) {
+      if (pattern === alias) matches.push(target);
+      continue;
+    }
+    const prefix = pattern.slice(0, star);
+    const suffix = pattern.slice(star + 1);
+    if (!alias.startsWith(prefix) || !alias.endsWith(suffix)) continue;
+    const substitution = alias.slice(prefix.length, alias.length - suffix.length);
+    matches.push(target.replace("*", substitution));
+  }
+  const [match] = matches;
+  if (matches.length !== 1 || match === void 0) return null;
+  return resolve(packageRoot, baseUrl, match);
+}
+function exportsPrimitive(path, exportName) {
+  try {
+    const source = readSmallRegularFile(path);
+    if (source === null) return false;
+    const program = parseTypeScript(source, { jsx: true, sourceType: "module" });
+    return program.body.some((statement) => {
+      if (statement.type !== AST_NODE_TYPES50.ExportNamedDeclaration) return false;
+      if (statement.exportKind === "type") return false;
+      if (statement.specifiers.some(
+        (specifier) => specifier.type === AST_NODE_TYPES50.ExportSpecifier && specifier.exportKind !== "type" && specifier.exported.type === AST_NODE_TYPES50.Identifier && specifier.exported.name === exportName
+      )) {
+        return true;
+      }
+      const declaration = statement.declaration;
+      if (declaration?.type === AST_NODE_TYPES50.VariableDeclaration) {
+        return declaration.declarations.some(
+          (item) => item.id.type === AST_NODE_TYPES50.Identifier && item.id.name === exportName
+        );
+      }
+      return (declaration?.type === AST_NODE_TYPES50.FunctionDeclaration || declaration?.type === AST_NODE_TYPES50.ClassDeclaration) && declaration.id?.name === exportName;
+    });
+  } catch {
+    return false;
+  }
+}
 function rawElementName(node) {
   if (node.name.type !== AST_NODE_TYPES50.JSXIdentifier) return null;
   const name = node.name.name;
-  return Object.hasOwn(SHADCN_PRIMITIVES, name) ? name : null;
+  return Object.hasOwn(RAW_PRIMITIVES, name) ? name : null;
 }
 function effectiveAttribute(node, attributeName) {
   for (const attribute of node.attributes.toReversed()) {
@@ -11284,15 +11479,19 @@ function isStaticallyAssociatedLabel(node) {
   return node.parent.type === AST_NODE_TYPES50.JSXElement && containsLabelableElement(node.parent);
 }
 function replacementFor(node, element) {
-  if (element !== "input") return SHADCN_PRIMITIVES[element];
+  if (element !== "input") return RAW_PRIMITIVES[element];
   const typeAttribute = effectiveAttribute(node, "type");
   if (typeAttribute.kind === "unknown") return null;
   const inputType = typeAttribute.kind === "known" ? typeAttribute.value.toLowerCase() : "text";
   if (inputType === "hidden" || inputType === "file") return null;
-  if (inputType === "checkbox") return "Checkbox";
-  if (inputType === "radio") return "RadioGroup family";
+  if (inputType === "checkbox") {
+    return { capability: "Checkbox", replacement: "Checkbox" };
+  }
+  if (inputType === "radio") {
+    return { capability: "RadioGroup", replacement: "RadioGroup family" };
+  }
   if (AMBIGUOUS_INPUT_TYPES.has(inputType)) return null;
-  return "Input";
+  return RAW_PRIMITIVES.input;
 }
 var prefer_shadcn_primitives_default = createRule({
   name: "prefer-shadcn-primitives",
@@ -11306,7 +11505,8 @@ var prefer_shadcn_primitives_default = createRule({
       {
         type: "object",
         properties: {
-          assumeAvailable: { type: "boolean" }
+          assumeAvailable: { type: "boolean" },
+          detectProjectPrimitives: { type: "boolean" }
         },
         additionalProperties: false
       }
@@ -11318,15 +11518,21 @@ var prefer_shadcn_primitives_default = createRule({
   defaultOptions: [{}],
   create(context, [options]) {
     const filename = context.filename.replaceAll("\\", "/");
-    if (isTestFile(filename) || SHARED_PRIMITIVE_IMPLEMENTATION_RE.test(filename)) {
+    if (isTestFile(filename) || isStoryFile(filename) || isGeneratedFile(filename, context.sourceCode.text) || SHARED_PRIMITIVE_IMPLEMENTATION_RE.test(filename)) {
       return {};
     }
-    let hasSharedPrimitiveImport = options?.assumeAvailable ?? false;
+    const detectsProject = options?.detectProjectPrimitives === true;
+    let hasSharedPrimitiveImport = false;
+    const importedCapabilities = /* @__PURE__ */ new Set();
     const candidates = [];
     return {
       ImportDeclaration(node) {
-        if (typeof node.source.value === "string" && SHARED_PRIMITIVE_IMPORT_RE.test(node.source.value)) {
-          hasSharedPrimitiveImport = true;
+        if (typeof node.source.value !== "string") return;
+        const match = SHARED_PRIMITIVE_IMPORT_RE.exec(node.source.value);
+        if (match?.[1] === void 0) return;
+        hasSharedPrimitiveImport = true;
+        for (const [capability, moduleName] of Object.entries(CAPABILITIES)) {
+          if (match[1].toLowerCase() === moduleName) importedCapabilities.add(capability);
         }
       },
       JSXOpeningElement(node) {
@@ -11335,11 +11541,15 @@ var prefer_shadcn_primitives_default = createRule({
         if (element === "label" && !isStaticallyAssociatedLabel(node)) return;
         const replacement = replacementFor(node, element);
         if (replacement === null) return;
-        candidates.push({ element, node, replacement });
+        candidates.push({ element, node, ...replacement });
       },
       "Program:exit"() {
-        if (!hasSharedPrimitiveImport) return;
-        for (const { element, node, replacement } of candidates) {
+        const requested = new Set(candidates.map(({ capability }) => capability));
+        const projectPrimitives = detectsProject && requested.size > 0 ? detectProjectPrimitives(context.filename, requested) : { available: /* @__PURE__ */ new Set(), uiRoot: null };
+        if (projectPrimitives.uiRoot !== null && isWithin2(projectPrimitives.uiRoot, realpathOrOriginal(context.filename))) return;
+        for (const { capability, element, node, replacement } of candidates) {
+          const available = options?.assumeAvailable === true || (detectsProject ? projectPrimitives.available.has(capability) || importedCapabilities.has(capability) : hasSharedPrimitiveImport);
+          if (!available) continue;
           context.report({
             node,
             messageId: "preferShadcnPrimitive",
@@ -11350,6 +11560,13 @@ var prefer_shadcn_primitives_default = createRule({
     };
   }
 });
+function realpathOrOriginal(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
 
 // src/rules/prefer-module-level-constant.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES51 } from "@typescript-eslint/utils";
@@ -12019,100 +12236,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 +12608,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 +12640,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 +12866,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.",
@@ -12373,11 +12901,11 @@ var prefer_native_random_uuid_default = createRule({
   create(context) {
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve(identifier) {
-      return ASTUtils15.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+    function resolve2(identifier) {
+      return ASTUtils17.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
-      const variable = resolve(identifier);
+      const variable = resolve2(identifier);
       if (variable !== null) destination.add(variable);
     }
     function report2(node) {
@@ -12405,7 +12933,7 @@ var prefer_native_random_uuid_default = createRule({
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== AST_NODE_TYPES57.CallExpression || node.init.callee.type !== AST_NODE_TYPES57.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== AST_NODE_TYPES57.CallExpression || node.init.callee.type !== AST_NODE_TYPES57.Identifier || (resolve2(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
         if (node.id.type === AST_NODE_TYPES57.Identifier) {
@@ -12422,14 +12950,14 @@ var prefer_native_random_uuid_default = createRule({
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
         if (node.callee.type === AST_NODE_TYPES57.Identifier) {
-          const variable2 = resolve(node.callee);
+          const variable2 = resolve2(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
         if (node.callee.type !== AST_NODE_TYPES57.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES57.Identifier || node.callee.property.type !== AST_NODE_TYPES57.Identifier || node.callee.property.name !== "v4") {
           return;
         }
-        const variable = resolve(node.callee.object);
+        const variable = resolve2(node.callee.object);
         if (variable !== null && namespaceBindings.has(variable)) report2(node);
       }
     };
@@ -12437,7 +12965,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.",
@@ -12459,22 +12987,22 @@ function memberName4(node) {
   }
   return null;
 }
-function isCryptoLoader(node, resolve) {
+function isCryptoLoader(node, resolve2) {
   if (node.type !== AST_NODE_TYPES58.CallExpression || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
   if (argument === void 0 || argument.type === AST_NODE_TYPES58.SpreadElement || !isCryptoSpecifier(argument)) {
     return false;
   }
   if (node.callee.type === AST_NODE_TYPES58.Identifier) {
-    return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve);
+    return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve2);
   }
-  return node.callee.type === AST_NODE_TYPES58.MemberExpression && node.callee.object.type === AST_NODE_TYPES58.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve) && memberName4(node.callee) === "getBuiltinModule";
+  return node.callee.type === AST_NODE_TYPES58.MemberExpression && node.callee.object.type === AST_NODE_TYPES58.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve2) && memberName4(node.callee) === "getBuiltinModule";
 }
 function isCryptoSpecifier(node) {
   return node.type === AST_NODE_TYPES58.Literal && (node.value === "crypto" || node.value === "node:crypto");
 }
-function isUnshadowedBuiltinIdentifier(identifier, resolve) {
-  const variable = resolve(identifier);
+function isUnshadowedBuiltinIdentifier(identifier, resolve2) {
+  const variable = resolve2(identifier);
   return variable === null || variable.defs.length === 0;
 }
 function propertyName4(node) {
@@ -12492,14 +13020,14 @@ var prefer_node_crypto_hash_default = createRule({
   create(context) {
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve(identifier) {
-      return ASTUtils16.findVariable(
+    function resolve2(identifier) {
+      return ASTUtils18.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
     }
     function record(identifier, destination) {
-      const variable = resolve(identifier);
+      const variable = resolve2(identifier);
       if (variable !== null) destination.add(variable);
     }
     return {
@@ -12514,7 +13042,7 @@ var prefer_node_crypto_hash_default = createRule({
         }
       },
       VariableDeclarator(node) {
-        if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve)) {
+        if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve2)) {
           return;
         }
         if (node.id.type === AST_NODE_TYPES58.Identifier) {
@@ -12538,7 +13066,7 @@ var prefer_node_crypto_hash_default = createRule({
           create,
           directBindings,
           namespaceBindings,
-          resolve
+          resolve2
         ))
           return;
         context.report({ node, messageId: "preferNodeCryptoHash" });
@@ -12552,17 +13080,17 @@ function importedName5(node) {
 function isMemberCall(node, name) {
   return node.callee.type === AST_NODE_TYPES58.MemberExpression && memberName4(node.callee) === name;
 }
-function isCreateHashCall(node, directBindings, namespaceBindings, resolve) {
+function isCreateHashCall(node, directBindings, namespaceBindings, resolve2) {
   if (node.callee.type === AST_NODE_TYPES58.Identifier) {
-    const variable2 = resolve(node.callee);
+    const variable2 = resolve2(node.callee);
     return variable2 !== null && directBindings.has(variable2);
   }
   if (node.callee.type !== AST_NODE_TYPES58.MemberExpression || memberName4(node.callee) !== "createHash") {
     return false;
   }
-  if (isCryptoLoader(node.callee.object, resolve)) return true;
+  if (isCryptoLoader(node.callee.object, resolve2)) return true;
   if (node.callee.object.type !== AST_NODE_TYPES58.Identifier) return false;
-  const variable = resolve(node.callee.object);
+  const variable = resolve2(node.callee.object);
   return variable !== null && namespaceBindings.has(variable);
 }
 
@@ -12680,7 +13208,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 +13338,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 +13455,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 +13501,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 +13560,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 +13614,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 +13728,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 {
@@ -13888,11 +14416,34 @@ var prefer_switch_for_repeated_equality_default = createRule({
 
 // src/rules/prefer-semantic-colors.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES66 } from "@typescript-eslint/utils";
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { dirname, join, parse } from "path";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2, parse } from "path";
 
 // src/rules/_tailwind.ts
-var tailwindBase = (token) => token.replace(/^(?:[a-z0-9-]+:)+/i, "").replace(/^!/, "");
+var tailwindVariantPrefix = (token) => {
+  let bracketDepth = 0;
+  let parenthesisDepth = 0;
+  let escaped = false;
+  let end = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    const character = token[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === "[") bracketDepth += 1;
+    else if (character === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    else if (character === "(") parenthesisDepth += 1;
+    else if (character === ")") parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+    else if (character === ":" && bracketDepth === 0 && parenthesisDepth === 0) end = index + 1;
+  }
+  return token.slice(0, end);
+};
+var tailwindBase = (token) => token.slice(tailwindVariantPrefix(token).length).replace(/^!/, "");
 var classTokens = (value) => value.split(/\s+/).filter(Boolean);
 
 // src/rules/prefer-semantic-colors.ts
@@ -13901,7 +14452,10 @@ var PREFER_SEMANTIC_COLORS_DOCUMENTATION = {
   rationale: "Semantic tokens keep themes and product meaning consistent while raw colors couple components to a palette value.",
   remediation: "Replace raw palette and literal colors with the closest semantic design-system token or CSS variable.",
   category: "style",
-  limitations: ["Email, PDF, icon artwork, masks, gradients, stories, and explicitly configured non-token projects have targeted exclusions."],
+  limitations: [
+    "Email, PDF, video-rendering, print-only, icon artwork, masks, gradients, stories, and explicitly configured non-token projects have targeted exclusions.",
+    "Opaque-foreground checks are opt-in and require both a same-variant semantic background class and its package-local declared foreground token."
+  ],
   examples: [
     { id: "semantic-text-color", title: "Use a semantic color token", outcome: "no-match", files: [{ path: "src/notice.tsx", source: 'const notice = <div className="text-destructive" />;' }], focusPath: "src/notice.tsx", expectedCount: 0, public: true },
     { id: "raw-text-color", title: "Do not use a raw palette color", outcome: "match", files: [{ path: "src/notice.tsx", source: 'const notice = <div className="text-red-500" />;' }], focusPath: "src/notice.tsx", expectedCount: 1, public: true }
@@ -14029,7 +14583,13 @@ var SVG_SHAPE_PRIMITIVES = /* @__PURE__ */ new Set([
   "tspan",
   "use"
 ]);
-var EMAIL_OR_PDF_MODULE_RE = /^@react-(?:email|pdf)\//;
+var EXTERNAL_RENDERER_MODULE_RE = /^(?:@react-(?:email|pdf)\/|remotion$|@remotion\/)/;
+var OPAQUE_FOREGROUND_RE = /^text-(?:white|black)(?:\/100)?$/;
+var SEMANTIC_BACKGROUND_RE = /^bg-([a-z][a-z0-9-]*)$/;
+var CSS_COMMENT_RE = /\/\*[\s\S]*?\*\//gu;
+var DECLARED_FOREGROUND_RE = /--(?:color-)?([a-z][a-z0-9-]*)-foreground\s*:/giu;
+var MAX_TOKEN_STYLESHEET_BYTES = 1048576;
+var SEMANTIC_DECLARATIONS_CACHE = /* @__PURE__ */ new Map();
 function isSvgLikeElementName(name) {
   return name === "svg" || SVG_DEFS_CONTAINERS.has(name) || /svg$/i.test(name);
 }
@@ -14044,12 +14604,12 @@ var isInsideIconFactoryPath = (node) => {
   return false;
 };
 var hasMarkerAt = (dir) => {
-  if (PRESENCE_MARKERS.some((rel) => existsSync(join(dir, rel)))) return true;
+  if (PRESENCE_MARKERS.some((rel) => existsSync2(join2(dir, rel)))) return true;
   for (const rel of CSS_DETECTION_FILES) {
-    const candidate2 = join(dir, rel);
-    if (!existsSync(candidate2)) continue;
+    const candidate2 = join2(dir, rel);
+    if (!existsSync2(candidate2)) continue;
     try {
-      const css = readFileSync(candidate2, "utf8");
+      const css = readFileSync2(candidate2, "utf8");
       if (SEMANTIC_TOKEN_RE.test(css) || THEME_BLOCK_RE.test(css)) return true;
     } catch {
     }
@@ -14058,10 +14618,10 @@ var hasMarkerAt = (dir) => {
 };
 var readWorkspaceGlobs = (dir) => {
   const globs = [];
-  const packageJson = join(dir, "package.json");
-  if (existsSync(packageJson)) {
+  const packageJson = join2(dir, "package.json");
+  if (existsSync2(packageJson)) {
     try {
-      const parsed = JSON.parse(readFileSync(packageJson, "utf8"));
+      const parsed = JSON.parse(readFileSync2(packageJson, "utf8"));
       const declared = typeof parsed === "object" && parsed !== null && "workspaces" in parsed ? parsed.workspaces : void 0;
       const list = Array.isArray(declared) ? declared : typeof declared === "object" && declared !== null && Array.isArray(declared.packages) ? declared.packages : [];
       for (const entry of list) if (typeof entry === "string") globs.push(entry);
@@ -14069,10 +14629,10 @@ var readWorkspaceGlobs = (dir) => {
     }
   }
   for (const name of ["pnpm-workspace.yaml", "pnpm-workspace.yml"]) {
-    const yaml = join(dir, name);
-    if (!existsSync(yaml)) continue;
+    const yaml = join2(dir, name);
+    if (!existsSync2(yaml)) continue;
     try {
-      for (const line of readFileSync(yaml, "utf8").split("\n")) {
+      for (const line of readFileSync2(yaml, "utf8").split("\n")) {
         const match = /^\s*-\s*["']?([^"'#\s]+)["']?\s*$/u.exec(line);
         if (match?.[1] !== void 0) globs.push(match[1]);
       }
@@ -14082,7 +14642,7 @@ var readWorkspaceGlobs = (dir) => {
   return globs;
 };
 var hasSemanticTokenSystem = (filename) => {
-  const dir = dirname(filename);
+  const dir = dirname2(filename);
   if (hasMarkerAtOrAbove(dir)) return true;
   const root = findWorkspaceRoot(dir);
   return root !== null && workspaceHasMarker(root);
@@ -14103,7 +14663,7 @@ var hasMarkerAtOrAbove = (startDir) => {
       answer = true;
       break;
     }
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (dir === root || parent === dir) {
       answer = false;
       break;
@@ -14125,11 +14685,11 @@ var findWorkspaceRoot = (startDir) => {
       break;
     }
     visited.push(dir);
-    if (WORKSPACE_ROOT_FILES.some((name) => existsSync(join(dir, name))) || readWorkspaceGlobs(dir).length > 0) {
+    if (WORKSPACE_ROOT_FILES.some((name) => existsSync2(join2(dir, name))) || readWorkspaceGlobs(dir).length > 0) {
       answer = dir;
       break;
     }
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (dir === root || parent === dir) {
       answer = null;
       break;
@@ -14163,23 +14723,71 @@ var workspaceHasMarker = (root) => {
 };
 var expandWorkspaceGlob = (root, glob) => {
   const star = glob.indexOf("*");
-  if (star === -1) return [join(root, glob)];
+  if (star === -1) return [join2(root, glob)];
   const prefix = glob.slice(0, star).replace(/\/$/u, "");
-  const parent = prefix === "" ? root : join(root, prefix);
-  if (!existsSync(parent)) return [];
-  return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => join(parent, entry.name));
+  const parent = prefix === "" ? root : join2(root, prefix);
+  if (!existsSync2(parent) || !lstatSync2(parent).isDirectory()) return [];
+  return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => join2(parent, entry.name));
 };
 var propName = (key) => {
   if (key.type === AST_NODE_TYPES66.Identifier) return key.name;
   if (key.type === AST_NODE_TYPES66.Literal && typeof key.value === "string") return key.value;
   return null;
 };
-var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
+var staticallyImportsExternalRenderer = (program) => program.body.some((statement) => {
   if (statement.type !== AST_NODE_TYPES66.ImportDeclaration && statement.type !== AST_NODE_TYPES66.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES66.ExportAllDeclaration) {
     return false;
   }
-  return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
+  return statement.source !== null && typeof statement.source.value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(statement.source.value);
 });
+var semanticForegroundRoles = (filename) => {
+  const packageRoot = nearestPackageRoot(dirname2(filename));
+  if (packageRoot === null) return /* @__PURE__ */ new Set();
+  const candidates = CSS_DETECTION_FILES.map((relative2) => join2(packageRoot, relative2));
+  const fingerprint = candidates.map(fileFingerprint2).join("|");
+  const cached = SEMANTIC_DECLARATIONS_CACHE.get(packageRoot);
+  if (cached?.fingerprint === fingerprint) return cached.value;
+  const foregroundRoles = /* @__PURE__ */ new Set();
+  for (const candidate2 of candidates) {
+    const css = readTokenStylesheet(candidate2);
+    if (css === null) continue;
+    const declarations = css.replace(CSS_COMMENT_RE, "");
+    for (const match of declarations.matchAll(DECLARED_FOREGROUND_RE)) {
+      if (match[1] !== void 0) foregroundRoles.add(match[1].toLowerCase());
+    }
+  }
+  SEMANTIC_DECLARATIONS_CACHE.set(packageRoot, { fingerprint, value: foregroundRoles });
+  return foregroundRoles;
+};
+var nearestPackageRoot = (startDir) => {
+  let dir = startDir;
+  const root = parse(dir).root;
+  for (; ; ) {
+    if (existsSync2(join2(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (dir === root || parent === dir) return null;
+    dir = parent;
+  }
+};
+var fileFingerprint2 = (path) => {
+  try {
+    const stat = lstatSync2(path);
+    return stat.isFile() ? `${path}:${stat.size}:${stat.mtimeMs}` : `${path}:excluded`;
+  } catch {
+    return `${path}:missing`;
+  }
+};
+var readTokenStylesheet = (path) => {
+  try {
+    const stat = lstatSync2(path);
+    if (!stat.isFile() || stat.size > MAX_TOKEN_STYLESHEET_BYTES) return null;
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+};
 var prefer_semantic_colors_default = createRule({
   name: "prefer-semantic-colors",
   documentation: PREFER_SEMANTIC_COLORS_DOCUMENTATION,
@@ -14193,30 +14801,34 @@ var prefer_semantic_colors_default = createRule({
         type: "object",
         additionalProperties: false,
         properties: {
-          requireSemanticTokens: { type: "boolean" }
+          requireSemanticTokens: { type: "boolean" },
+          opaqueForegroundPairs: { type: "boolean" }
         }
       }
     ],
     messages: {
       rawPalette: "Raw palette class '{{class}}' \u2014 use a semantic token (e.g. text-foreground, bg-primary, text-destructive, bg-muted).",
       arbitraryColor: "Hardcoded color '{{class}}' \u2014 use a semantic token, or var(--\u2026). For charts/brand add an eslint-disable with a reason.",
-      inlineColor: "Hardcoded color '{{value}}' \u2014 use a semantic token / CSS variable. For charts/standalone pages add an eslint-disable with a reason."
+      inlineColor: "Hardcoded color '{{value}}' \u2014 use a semantic token / CSS variable. For charts/standalone pages add an eslint-disable with a reason.",
+      opaqueForegroundPair: "'{{class}}' bypasses the declared '{{replacement}}' token paired with '{{background}}'."
     }
   },
   defaultOptions: [{}],
   create(context, [options]) {
     if (STORIES_FILE_RE.test(context.filename)) return {};
-    if (staticallyImportsEmailOrPdfRenderer(context.sourceCode.ast)) return {};
-    if (options?.requireSemanticTokens === true && !hasSemanticTokenSystem(context.filename)) {
-      return {};
-    }
-    let importsEmailOrPdfRenderer = false;
-    const pendingReports = [];
+    if (staticallyImportsExternalRenderer(context.sourceCode.ast)) return {};
+    if (options?.requireSemanticTokens === true && !hasSemanticTokenSystem(context.filename)) return {};
+    const foregroundRoles = options?.opaqueForegroundPairs === true ? semanticForegroundRoles(context.filename) : /* @__PURE__ */ new Set();
+    const checkOpaqueForegroundPairs = foregroundRoles.size > 0;
+    let importsExternalRenderer = false;
+    const pendingReports = /* @__PURE__ */ new Map();
     const report2 = (node, messageId, data) => {
-      pendingReports.push({ node, messageId, data });
+      const key = `${node.range[0]}:${node.range[1]}:${messageId}:${JSON.stringify(data)}`;
+      pendingReports.set(key, { node, messageId, data });
     };
     const reportClasses = (value, node) => {
-      for (const token of classTokens(value)) {
+      const tokens = classTokens(value);
+      for (const token of tokens) {
         const base = tailwindBase(token);
         if (RAW_PALETTE_RE.test(base)) {
           report2(node, "rawPalette", { class: token });
@@ -14224,6 +14836,26 @@ var prefer_semantic_colors_default = createRule({
           report2(node, "arbitraryColor", { class: token });
         }
       }
+      if (!checkOpaqueForegroundPairs || isInsideSvg(node)) return;
+      for (const token of tokens) {
+        const prefix = tailwindVariantPrefix(token);
+        if (prefix.split(":").includes("print")) continue;
+        const base = tailwindBase(token);
+        if (!OPAQUE_FOREGROUND_RE.test(base)) continue;
+        const semanticBackground = tokens.find((candidate2) => {
+          if (tailwindVariantPrefix(candidate2) !== prefix) return false;
+          const match = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(candidate2));
+          return match?.[1] !== void 0 && foregroundRoles.has(match[1]);
+        });
+        if (semanticBackground === void 0) continue;
+        const role = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(semanticBackground))?.[1];
+        if (role === void 0) continue;
+        report2(node, "opaqueForegroundPair", {
+          background: semanticBackground,
+          class: token,
+          replacement: `${prefix}text-${role}-foreground`
+        });
+      }
     };
     const checkClassNode = (node) => {
       if (node === null) return;
@@ -14271,8 +14903,8 @@ var prefer_semantic_colors_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES66.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES66.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
-          importsEmailOrPdfRenderer = true;
+        if (node.callee.type === AST_NODE_TYPES66.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES66.Literal && typeof node.arguments[0].value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.arguments[0].value)) {
+          importsExternalRenderer = true;
         }
         if (node.callee.type === AST_NODE_TYPES66.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
@@ -14307,13 +14939,13 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES66.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
-          importsEmailOrPdfRenderer = true;
+        if (node.source.type === AST_NODE_TYPES66.Literal && typeof node.source.value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.source.value)) {
+          importsExternalRenderer = true;
         }
       },
       "Program:exit"() {
-        if (importsEmailOrPdfRenderer) return;
-        for (const descriptor of pendingReports) context.report(descriptor);
+        if (importsExternalRenderer) return;
+        for (const descriptor of pendingReports.values()) context.report(descriptor);
       }
     };
   }
@@ -14322,11 +14954,11 @@ var prefer_semantic_colors_default = createRule({
 // src/rules/prefer-server-actions.ts
 import "@typescript-eslint/utils";
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
-  summary: "Prefer Next.js Server Actions over /api/* mutations.",
+  summary: "Prefer Next.js Server Actions over same-origin API mutations.",
   rationale: "Server Actions preserve typed application calls and avoid an internal JSON request-response boundary.",
   remediation: "Move the mutation into a Server Action and invoke that action from the React client.",
   category: "architecture",
-  limitations: ["Only statically recognizable /api/ mutations in modules with positive Next.js evidence are reported: an explicit next import, or an app/pages path with a top-level use-client directive."],
+  limitations: ["Only statically recognizable /api/ mutations, including one explicitly configured literal deployment base path, in use-client modules are reported; server boundaries and route handlers are excluded."],
   examples: [
     { id: "server-action-call", title: "Call a Server Action", outcome: "no-match", files: [{ path: "app/tasks/page.tsx", source: "import { createTask } from './actions'; await createTask(input);" }], focusPath: "app/tasks/page.tsx", expectedCount: 0, public: true },
     { id: "api-mutation", title: "Do not mutate through an API route", outcome: "match", files: [{ path: "app/tasks/page.tsx", source: "'use client'; await fetch('/api/tasks', { method: 'POST', body });" }], focusPath: "app/tasks/page.tsx", expectedCount: 1, public: true }
@@ -14334,12 +14966,21 @@ var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
 };
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
-var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
+var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|(?:^|\/)app(?:\/.*)?\/route\.[jt]sx?$|(?:^|\/)middleware\.[jt]sx?$|\/pages\/api\/)/;
 var NON_REACT_FRAMEWORK_RE2 = /^(?:@angular\/|@nestjs\/|vue$|vue\/|svelte$|svelte\/|solid-js$|solid-js\/|@ember\/|rxjs$|rxjs\/)/;
-var NEXT_MODULE_PATH_RE2 = /(?:^|[/\\])(?:app|pages)[/\\]/u;
+var BASE_PATH_RE2 = /^\/(?!$)(?!.*[?#])(?:[^/]+\/)*[^/]+$/u;
 function getScope(context, node) {
   return context.sourceCode.getScope(node);
 }
+function resolvesToGlobalFetch(context, identifier) {
+  let scope = getScope(context, identifier);
+  while (scope) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== void 0) return variable.defs.length === 0;
+    scope = scope.upper;
+  }
+  return true;
+}
 function resolveNode(node, context) {
   if (!node) return null;
   if (node.type !== "Identifier") return node;
@@ -14359,22 +15000,29 @@ function resolveNode(node, context) {
   }
   return node;
 }
-function isApiUrl(node, context) {
+function isApiUrl(node, context, apiPrefixes) {
   const resolved = resolveNode(node, context);
   if (!resolved) return false;
   if (resolved.type === "Literal" && typeof resolved.value === "string") {
-    return resolved.value.startsWith("/api/");
+    return apiPrefixes.some(
+      (prefix) => resolved.value === prefix.slice(0, -1) || resolved.value.startsWith(prefix)
+    );
   }
   if (resolved.type === "TemplateLiteral") {
     const firstQuasi = resolved.quasis[0];
     const cooked = firstQuasi?.value.cooked;
-    return typeof cooked === "string" && cooked.startsWith("/api/");
+    return typeof cooked === "string" && apiPrefixes.some(
+      (prefix) => cooked === prefix.slice(0, -1) || cooked.startsWith(prefix)
+    );
   }
   if (resolved.type === "BinaryExpression" && resolved.operator === "+") {
-    return isApiUrl(resolved.left, context);
+    return isApiUrl(resolved.left, context, apiPrefixes);
   }
   return false;
 }
+function isValidBasePath2(basePath) {
+  return BASE_PATH_RE2.test(basePath) && !basePath.split("/").some((segment) => segment === "." || segment === "..");
+}
 function isMutationMethod(node, context) {
   const resolved = resolveNode(node, context);
   if (!resolved) return false;
@@ -14434,16 +15082,27 @@ var prefer_server_actions_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Prefer Next.js Server Actions over /api/* mutations."
+      description: "Prefer Next.js Server Actions over same-origin API mutations."
     },
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          basePath: {
+            type: "string",
+            pattern: "^/(?!$)(?!.*[?#])(?!(?:.*/)?\\.\\.?(?:/|$))(?:[^/]+/)*[^/]+$"
+          }
+        }
+      }
+    ],
     messages: {
-      preferServerAction: "Mutation against /api/* \u2014 prefer a Next.js Server Action for type-safety and to avoid the JSON round-trip."
+      preferServerAction: "Mutation against a same-origin API route \u2014 prefer a Next.js Server Action for type-safety and to avoid the JSON round-trip."
     }
   },
-  defaultOptions: [],
-  create(context) {
-    const filename = context.filename;
+  defaultOptions: [{}],
+  create(context, [options]) {
+    const filename = context.filename.replaceAll("\\", "/");
     if (SKIP_FILE_REGEX.test(filename)) {
       return {};
     }
@@ -14451,22 +15110,28 @@ var prefer_server_actions_default = createRule({
       (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && NON_REACT_FRAMEWORK_RE2.test(node.source.value)
     );
     const hasUseClientDirective = context.sourceCode.ast.body.some(
-      (node) => node.type === "ExpressionStatement" && node.expression.type === "Literal" && node.expression.value === "use client"
+      (node) => node.type === "ExpressionStatement" && node.directive === "use client"
+    );
+    const hasUseServerDirective = context.sourceCode.ast.body.some(
+      (node) => node.type === "ExpressionStatement" && node.directive === "use server"
     );
-    const hasNextImport = context.sourceCode.ast.body.some(
-      (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && (node.source.value === "next" || node.source.value.startsWith("next/"))
+    const importsServerOnly = context.sourceCode.ast.body.some(
+      (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && (node.source.value === "server-only" || node.source.value === "next/server")
     );
-    const hasNextEvidence = hasNextImport || hasUseClientDirective && NEXT_MODULE_PATH_RE2.test(filename);
-    if (!hasNextEvidence) {
+    if (!hasUseClientDirective || hasUseServerDirective || importsServerOnly) {
       return {};
     }
+    const apiPrefixes = ["/api/"];
+    if (options?.basePath !== void 0 && isValidBasePath2(options.basePath)) {
+      apiPrefixes.push(`${options.basePath}/api/`);
+    }
     return {
       CallExpression(node) {
         if (isNonReactFramework) return;
         let isMutation = false;
-        if (node.callee.type === "Identifier" && node.callee.name === "fetch") {
+        if (node.callee.type === "Identifier" && node.callee.name === "fetch" && resolvesToGlobalFetch(context, node.callee)) {
           const urlArg = node.arguments[0];
-          if (urlArg && urlArg.type !== "SpreadElement" && isApiUrl(urlArg, context)) {
+          if (urlArg && urlArg.type !== "SpreadElement" && isApiUrl(urlArg, context, apiPrefixes)) {
             const initArg = node.arguments[1];
             if (initArg && initArg.type !== "SpreadElement") {
               const resolvedInit = resolveNode(initArg, context);
@@ -14483,7 +15148,7 @@ var prefer_server_actions_default = createRule({
             const hasHandlerArg = node.arguments.some(
               (arg) => arg.type !== "SpreadElement" && isFunctionArgument(arg, context)
             );
-            if (urlArg && urlArg.type !== "SpreadElement" && !hasHandlerArg && isApiUrl(urlArg, context)) {
+            if (urlArg && urlArg.type !== "SpreadElement" && !hasHandlerArg && isApiUrl(urlArg, context, apiPrefixes)) {
               isMutation = true;
             }
           }
@@ -14494,7 +15159,7 @@ var prefer_server_actions_default = createRule({
             if (configArg && configArg.type === "ObjectExpression") {
               const urlNode = getPropertyNode(configArg, "url");
               const methodNode = getPropertyNode(configArg, "method");
-              if (urlNode && isApiUrl(urlNode, context) && methodNode && isMutationMethod(methodNode, context)) {
+              if (urlNode && isApiUrl(urlNode, context, apiPrefixes) && methodNode && isMutationMethod(methodNode, context)) {
                 isMutation = true;
               }
             }
@@ -14786,7 +15451,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 +15477,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 +16478,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 +16559,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 +16569,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 +17658,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 +17712,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 +17796,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 +17864,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 +18161,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 +18366,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 +18419,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 +18459,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 +18489,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 +19070,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 +19090,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 +19204,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 +19221,7 @@ var calleeChainRoot = (node) => {
     return null;
   }
 };
-var chainMemberNames = (node) => {
+var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
@@ -18606,7 +19271,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 +19281,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 +19297,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 +19509,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.3"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",