@sarj/eslint-plugin 15.17.1 → 15.17.3

package/dist/index.cjs

@@ -5890,7 +5890,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 }
@@ -5935,7 +5935,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") {
@@ -6031,6 +6034,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
@@ -6052,12 +6059,18 @@ var no_raw_fetch_outside_clients_default = createRule({
       (statement) => statement.type === import_utils33.AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(statement.source.value)
     );
     const hasUseClientDirective = context.sourceCode.ast.body.some(
-      (statement) => statement.type === import_utils33.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils33.AST_NODE_TYPES.Literal && statement.expression.value === "use client"
+      (statement) => statement.type === import_utils33.AST_NODE_TYPES.ExpressionStatement && statement.directive === "use client"
     );
-    const hasNextImport = context.sourceCode.ast.body.some(
-      (statement) => statement.type === import_utils33.AST_NODE_TYPES.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 === import_utils33.AST_NODE_TYPES.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 === import_utils33.AST_NODE_TYPES.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 = import_utils33.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
@@ -6090,15 +6103,15 @@ var no_raw_fetch_outside_clients_default = createRule({
     function isInternalApiUrl(node) {
       const resolved = resolveNode2(node ?? void 0);
       if (resolved?.type === import_utils33.AST_NODE_TYPES.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 === import_utils33.AST_NODE_TYPES.TemplateLiteral) {
         const prefix = resolved.quasis[0]?.value.cooked;
-        return typeof prefix === "string" && /^\/(?!\/)(?:[^/]+\/)*api(?:\/|$)/.test(prefix);
-      }
-      if (resolved?.type === import_utils33.AST_NODE_TYPES.CallExpression && resolved.callee.type === import_utils33.AST_NODE_TYPES.Identifier && resolved.callee.name === "withBase") {
-        const first = resolved.arguments[0];
-        return first !== void 0 && first.type !== import_utils33.AST_NODE_TYPES.SpreadElement ? isInternalApiUrl(first) : false;
+        return typeof prefix === "string" && internalApiPrefixes.some(
+          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
+        );
       }
       return resolved?.type === import_utils33.AST_NODE_TYPES.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
     }
@@ -6118,7 +6131,7 @@ var no_raw_fetch_outside_clients_default = createRule({
       return resolved?.type === import_utils33.AST_NODE_TYPES.LogicalExpression && resolved.operator === "||" && (isMutationMethod2(resolved.left) || isMutationMethod2(resolved.right));
     }
     function serverActionOwns(node) {
-      if (node.callee.type !== import_utils33.AST_NODE_TYPES.Identifier || !hasNextEvidence || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+      if (node.callee.type !== import_utils33.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
         return false;
       }
       const url = node.arguments[0];
@@ -9775,25 +9788,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 import_utils55.ASTUtils.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 !== import_utils55.AST_NODE_TYPES.TSTypeReference) return false;
       const typeName = node.typeName;
       if (typeName.type === import_utils55.AST_NODE_TYPES.Identifier) {
-        const binding = resolve(typeName);
+        const binding = resolve2(typeName);
         return binding !== null && directBindings.has(binding);
       }
       if (typeName.type === import_utils55.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils55.AST_NODE_TYPES.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;
@@ -11197,6 +11210,10 @@ function unwrapTransparentExport(node) {
 
 // src/rules/prefer-shadcn-primitives.ts
 var import_utils66 = require("@typescript-eslint/utils");
+var import_typescript_estree = require("@typescript-eslint/typescript-estree");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_jsonc_parser = require("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.",
@@ -11204,22 +11221,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",
@@ -11231,7 +11261,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",
@@ -11240,10 +11270,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((0, import_node_path.dirname)(filename));
+  if (packageRoot === null) return { available: /* @__PURE__ */ new Set(), uiRoot: null };
+  const manifest = readJsonc((0, import_node_path.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) => [
+      (0, import_node_path.join)(uiRoot, `${moduleName}.${extension}`),
+      (0, import_node_path.join)(uiRoot, moduleName, `index.${extension}`)
+    ]));
+  }
+  const fingerprint = [
+    (0, import_node_path.join)(packageRoot, "components.json"),
+    (0, import_node_path.join)(packageRoot, "tsconfig.json"),
+    (0, import_node_path.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 = (0, import_node_fs.lstatSync)(path);
+    return stat.isFile() ? `${path}:${stat.size}:${stat.mtimeMs}` : `${path}:excluded`;
+  } catch {
+    return `${path}:missing`;
+  }
+}
+function isWithin2(root, candidate2) {
+  const path = (0, import_node_path.relative)(root, candidate2);
+  return path === "" || !path.startsWith(`..${import_node_path.sep}`) && path !== ".." && !(0, import_node_path.isAbsolute)(path);
+}
+function safeContainedDirectory(root, candidate2) {
+  try {
+    if (!(0, import_node_fs.lstatSync)(candidate2).isDirectory()) return null;
+    const realRoot = (0, import_node_fs.realpathSync)(root);
+    const realCandidate = (0, import_node_fs.realpathSync)(candidate2);
+    return isWithin2(realRoot, realCandidate) ? realCandidate : null;
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  const filesystemRoot = (0, import_node_path.parse)(dir).root;
+  for (; ; ) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "package.json"))) return dir;
+    const parent = (0, import_node_path.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 = (0, import_jsonc_parser.parse)(source, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    return errors.length === 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function readSmallRegularFile(path) {
+  try {
+    const stat = (0, import_node_fs.lstatSync)(path);
+    if (!stat.isFile() || stat.size > MAX_PROJECT_FILE_BYTES) return null;
+    return (0, import_node_fs.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 ((0, import_node_path.isAbsolute)(alias)) return null;
+  if (alias.startsWith(".")) return (0, import_node_path.resolve)(packageRoot, alias);
+  const configPath = ["tsconfig.json", "jsconfig.json"].map((name) => (0, import_node_path.join)(packageRoot, name)).find(import_node_fs.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 (0, import_node_path.resolve)(packageRoot, baseUrl, match);
+}
+function exportsPrimitive(path, exportName) {
+  try {
+    const source = readSmallRegularFile(path);
+    if (source === null) return false;
+    const program = (0, import_typescript_estree.parse)(source, { jsx: true, sourceType: "module" });
+    return program.body.some((statement) => {
+      if (statement.type !== import_utils66.AST_NODE_TYPES.ExportNamedDeclaration) return false;
+      if (statement.exportKind === "type") return false;
+      if (statement.specifiers.some(
+        (specifier) => specifier.type === import_utils66.AST_NODE_TYPES.ExportSpecifier && specifier.exportKind !== "type" && specifier.exported.type === import_utils66.AST_NODE_TYPES.Identifier && specifier.exported.name === exportName
+      )) {
+        return true;
+      }
+      const declaration = statement.declaration;
+      if (declaration?.type === import_utils66.AST_NODE_TYPES.VariableDeclaration) {
+        return declaration.declarations.some(
+          (item) => item.id.type === import_utils66.AST_NODE_TYPES.Identifier && item.id.name === exportName
+        );
+      }
+      return (declaration?.type === import_utils66.AST_NODE_TYPES.FunctionDeclaration || declaration?.type === import_utils66.AST_NODE_TYPES.ClassDeclaration) && declaration.id?.name === exportName;
+    });
+  } catch {
+    return false;
+  }
+}
 function rawElementName(node) {
   if (node.name.type !== import_utils66.AST_NODE_TYPES.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()) {
@@ -11312,15 +11507,19 @@ function isStaticallyAssociatedLabel(node) {
   return node.parent.type === import_utils66.AST_NODE_TYPES.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",
@@ -11334,7 +11533,8 @@ var prefer_shadcn_primitives_default = createRule({
       {
         type: "object",
         properties: {
-          assumeAvailable: { type: "boolean" }
+          assumeAvailable: { type: "boolean" },
+          detectProjectPrimitives: { type: "boolean" }
         },
         additionalProperties: false
       }
@@ -11346,15 +11546,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) {
@@ -11363,11 +11569,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",
@@ -11378,6 +11588,13 @@ var prefer_shadcn_primitives_default = createRule({
     };
   }
 });
+function realpathOrOriginal(path) {
+  try {
+    return (0, import_node_fs.realpathSync)(path);
+  } catch {
+    return path;
+  }
+}
 
 // src/rules/prefer-module-level-constant.ts
 var import_utils67 = require("@typescript-eslint/utils");
@@ -12048,99 +12265,367 @@ var prefer_module_level_schema_default = createRule({
 
 // src/rules/prefer-module-level-refined-schema.ts
 var import_utils69 = require("@typescript-eslint/utils");
+var BENCHMARK_PATH_RE = /(^|[/\\])(?:benchmarks?|bench)[/\\]/;
 var FACTORIES = /* @__PURE__ */ new Set([
   "array",
+  "base64",
+  "base64url",
   "bigint",
   "boolean",
+  "cidrv4",
+  "cidrv6",
+  "codec",
+  "custom",
   "date",
-  "number",
-  "string"
-]);
-var REFINEMENTS = /* @__PURE__ */ new Set([
-  "brand",
-  "check",
+  "datetime",
+  "duration",
   "email",
-  "finite",
-  "int",
-  "length",
-  "max",
-  "min",
-  "multipleOf",
-  "nonempty",
-  "positive",
-  "regex",
-  "refine",
-  "safe",
-  "superRefine",
-  "transform",
-  "trim",
+  "emoji",
+  "enum",
+  "file",
+  "function",
+  "hash",
+  "hex",
+  "hostname",
+  "instanceof",
+  "ipv4",
+  "ipv6",
+  "json",
+  "jwt",
+  "literal",
+  "map",
+  "nan",
+  "nativeEnum",
+  "never",
+  "null",
+  "nullable",
+  "nullish",
+  "number",
+  "optional",
+  "partialRecord",
+  "preprocess",
+  "promise",
+  "set",
+  "string",
+  "stringbool",
+  "symbol",
+  "templateLiteral",
+  "time",
+  "undefined",
   "url",
-  "uuid"
+  "uuid",
+  "void"
+]);
+var COMPOSITE_FACTORIES = /* @__PURE__ */ new Set([
+  "discriminatedUnion",
+  "intersection",
+  "looseObject",
+  "object",
+  "record",
+  "strictObject",
+  "tuple",
+  "union"
+]);
+var FACTORY_NAMESPACES = /* @__PURE__ */ new Set(["coerce", "iso"]);
+var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
+  "decode",
+  "decodeAsync",
+  "encode",
+  "encodeAsync",
+  "flattenError",
+  "formatError",
+  "implement",
+  "isNullable",
+  "isOptional",
+  "parse",
+  "parseAsync",
+  "prettifyError",
+  "registry",
+  "safeDecode",
+  "safeDecodeAsync",
+  "safeEncode",
+  "safeEncodeAsync",
+  "safeParse",
+  "safeParseAsync",
+  "spa",
+  "toJSONSchema",
+  "treeifyError"
+]);
+var MEMO_CALLEES2 = /* @__PURE__ */ new Set([
+  "lazy",
+  "memo",
+  "once",
+  "useMemo"
+]);
+var I18N_CALLEE_NAMES2 = /* @__PURE__ */ new Set([
+  "$t",
+  "defineMessage",
+  "gettext",
+  "msg",
+  "ngettext",
+  "t",
+  "translate"
+]);
+var I18N_RECEIVER_NAMES2 = /* @__PURE__ */ new Set([
+  "$i18n",
+  "i18n",
+  "intl"
+]);
+var FUNCTION_TYPES9 = /* @__PURE__ */ new Set([
+  import_utils69.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils69.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils69.AST_NODE_TYPES.FunctionExpression
 ]);
 var PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION = {
-  summary: "Declare closed, refined Zod scalar and array schemas at module scope.",
+  summary: "Declare closed Zod scalar, format, and wrapper schemas at module scope.",
   rationale: "A closed validation pipeline created inside a function is rebuilt on every invocation and obscures a reusable constraint.",
-  remediation: "Move the validation schema to module scope and call parse on the shared schema.",
+  remediation: "Move the validation schema to module scope, name it with a PascalCase Schema suffix, and call parse on the shared schema.",
   category: "performance",
-  limitations: ["Only direct Zod scalar/array chains with at least two refinement methods and no non-literal arguments are reported."],
+  limitations: [
+    "Composite object/record/tuple/union schemas are owned by prefer-module-level-schema.",
+    "Schemas that depend on function-local or mutable state, localized text, receiver state, lazy construction, or recognized memoization are excluded.",
+    "Literal string z.enum domains are owned by prefer-shared-zod-enum."
+  ],
   examples: [
-    { id: "module-refinement", title: "Share the validation schema", outcome: "no-match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; const BatchSize = z.number().int().min(1).max(1000); export function parse(value: unknown) { return BatchSize.parse(value); }" }], focusPath: "src/options.ts", expectedCount: 0, public: true },
-    { id: "local-refinement", title: "Do not rebuild a closed validation chain", outcome: "match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; export function parse(value: unknown) { return z.number().int().min(1).max(1000).parse(value); }" }], focusPath: "src/options.ts", expectedCount: 1, public: true }
+    {
+      id: "module-refinement",
+      title: "Share the validation schema",
+      outcome: "no-match",
+      files: [{
+        path: "src/options.ts",
+        source: "import { z } from 'zod'; const BatchSizeSchema = z.number().int().min(1).max(1000); export function parse(value: unknown) { return BatchSizeSchema.parse(value); }"
+      }],
+      focusPath: "src/options.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "local-refinement",
+      title: "Do not rebuild a closed validation chain",
+      outcome: "match",
+      files: [{
+        path: "src/options.ts",
+        source: "import { z } from 'zod'; export function parse(value: unknown) { return z.string().trim().min(1).max(128).parse(value); }"
+      }],
+      focusPath: "src/options.ts",
+      expectedCount: 1,
+      public: true
+    }
   ]
 };
-function enclosingFunction4(node) {
+function outermostEnclosingFunction2(node) {
+  let outermost;
   let current = node.parent ?? void 0;
   while (current !== void 0) {
-    if ([import_utils69.AST_NODE_TYPES.ArrowFunctionExpression, import_utils69.AST_NODE_TYPES.FunctionDeclaration, import_utils69.AST_NODE_TYPES.FunctionExpression].includes(current.type)) return current;
+    if (FUNCTION_TYPES9.has(current.type)) outermost = current;
     current = current.parent ?? void 0;
   }
-  return void 0;
+  return outermost;
 }
 function collectReferences2(scope, output) {
   output.push(...scope.references);
   for (const child of scope.childScopes) collectReferences2(child, output);
 }
+function subtreeSome2(root, predicate) {
+  let found = false;
+  const visit = (value) => {
+    if (found || value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+    const candidate2 = value;
+    if (typeof candidate2.type !== "string") return;
+    if (predicate(candidate2)) {
+      found = true;
+      return;
+    }
+    for (const key of Object.keys(candidate2)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      visit(candidate2[key]);
+    }
+  };
+  visit(root);
+  return found;
+}
+function readsReceiver2(node) {
+  return subtreeSome2(
+    node,
+    (inner) => inner.type === import_utils69.AST_NODE_TYPES.ThisExpression || inner.type === import_utils69.AST_NODE_TYPES.Super || inner.type === import_utils69.AST_NODE_TYPES.Identifier && inner.name === "arguments"
+  );
+}
+function buildsLocalizedText2(node) {
+  return subtreeSome2(node, (inner) => {
+    if (inner.type === import_utils69.AST_NODE_TYPES.TaggedTemplateExpression) return true;
+    if (inner.type !== import_utils69.AST_NODE_TYPES.CallExpression) return false;
+    const { callee } = inner;
+    if (callee.type === import_utils69.AST_NODE_TYPES.Identifier)
+      return I18N_CALLEE_NAMES2.has(callee.name);
+    return callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES2.has(callee.object.name);
+  });
+}
+function calleeChainRoot(node) {
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils69.AST_NODE_TYPES.Identifier) return current;
+    if (current.type === import_utils69.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+      continue;
+    }
+    if (current.type === import_utils69.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    return null;
+  }
+}
+function chainMemberNames(node) {
+  const names = [];
+  let current = node;
+  for (; ; ) {
+    if (current.type === import_utils69.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils69.AST_NODE_TYPES.Identifier)
+        return [];
+      names.push(current.property.name);
+      current = current.object;
+      continue;
+    }
+    if (current.type === import_utils69.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    break;
+  }
+  names.reverse();
+  return names;
+}
+function schemaExpression2(node) {
+  let current = node;
+  for (; ; ) {
+    const parent = current.parent ?? void 0;
+    if (parent?.type === import_utils69.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils69.AST_NODE_TYPES.Identifier && parent.parent?.type === import_utils69.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent) {
+      if (NON_SCHEMA_TERMINALS.has(parent.property.name)) return current;
+      current = parent.parent;
+      continue;
+    }
+    if (parent?.type === import_utils69.AST_NODE_TYPES.TSAsExpression || parent?.type === import_utils69.AST_NODE_TYPES.TSNonNullExpression || parent?.type === import_utils69.AST_NODE_TYPES.TSSatisfiesExpression || parent?.type === import_utils69.AST_NODE_TYPES.TSTypeAssertion) {
+      current = parent;
+      continue;
+    }
+    return current;
+  }
+}
 var prefer_module_level_refined_schema_default = createRule({
   name: "prefer-module-level-refined-schema",
   documentation: PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION,
-  meta: { type: "suggestion", docs: { description: "Declare closed, refined Zod scalar and array schemas at module scope." }, schema: [], messages: { hoistRefinedSchema: "Move this closed refined Zod schema to module scope and reuse it for parsing." } },
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Declare closed Zod scalar, format, and wrapper schemas at module scope."
+    },
+    schema: [],
+    messages: {
+      hoistRefinedSchema: "Move this closed Zod schema to module scope, give it a PascalCase Schema name, and reuse it for parsing."
+    }
+  },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
-    const namespaces = /* @__PURE__ */ new Set();
+    if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
+      return {};
+    const zodBindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return import_utils69.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function recordZodBinding(identifier) {
+      const binding = resolvedBinding(identifier);
+      if (binding !== null) zodBindings.add(binding);
+    }
+    function factoryName(node, allowed) {
+      if (node.callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression) return null;
+      const root = calleeChainRoot(node.callee);
+      if (root === null) return null;
+      const binding = resolvedBinding(root);
+      if (binding === null || !zodBindings.has(binding)) return null;
+      const names = chainMemberNames(node.callee);
+      if (names.length === 1 && allowed.has(names[0] ?? ""))
+        return names[0] ?? null;
+      if (names.length === 2 && FACTORY_NAMESPACES.has(names[0] ?? "") && allowed.has(names[1] ?? ""))
+        return names[1] ?? null;
+      return null;
+    }
+    function isSharedEnumDomain(node, factory) {
+      if (factory !== "enum") return false;
+      const [argument] = node.arguments;
+      return argument?.type === import_utils69.AST_NODE_TYPES.ArrayExpression && argument.elements.length >= 2 && argument.elements.every(
+        (element) => element?.type === import_utils69.AST_NODE_TYPES.Literal && typeof element.value === "string"
+      );
+    }
+    function isNestedInOwnedFactory(node) {
+      let current = node;
+      while (current.parent != null) {
+        current = current.parent;
+        if (FUNCTION_TYPES9.has(current.type)) return false;
+        if (current.type === import_utils69.AST_NODE_TYPES.CallExpression && (factoryName(current, FACTORIES) !== null || factoryName(current, COMPOSITE_FACTORIES) !== null))
+          return true;
+      }
+      return false;
+    }
+    function isMemoized(node) {
+      let current = node.parent ?? void 0;
+      while (current !== void 0) {
+        if (current.type === import_utils69.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils69.AST_NODE_TYPES.Identifier && MEMO_CALLEES2.has(current.callee.name) || current.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils69.AST_NODE_TYPES.Identifier && MEMO_CALLEES2.has(current.callee.property.name)))
+          return true;
+        current = current.parent ?? void 0;
+      }
+      return false;
+    }
+    function closesOverNothing(node, enclosing) {
+      const references = [];
+      collectReferences2(context.sourceCode.getScope(node), references);
+      const [start, end] = node.range;
+      const [functionStart, functionEnd] = enclosing.range;
+      for (const reference of references) {
+        const [referenceStart] = reference.identifier.range;
+        if (referenceStart < start || referenceStart >= end) continue;
+        const resolved = reference.resolved;
+        if (resolved === null) continue;
+        for (const definition of resolved.defs) {
+          if (definition.type === "ImportBinding") {
+            const parent = reference.identifier.parent;
+            if (parent?.type === import_utils69.AST_NODE_TYPES.CallExpression && parent.callee === reference.identifier && !zodBindings.has(resolved))
+              return false;
+            continue;
+          }
+          if (definition.node.type === import_utils69.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils69.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const")
+            return false;
+          const [definitionStart, definitionEnd] = definition.node.range;
+          if (definitionStart >= start && definitionEnd <= end) continue;
+          if (definitionStart >= functionStart && definitionEnd <= functionEnd)
+            return false;
+        }
+      }
+      return true;
+    }
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
-        for (const specifier of node.specifiers) if (specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") namespaces.add(specifier.local.name);
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z"))
+            recordZodBinding(specifier.local);
+        }
       },
       CallExpression(node) {
-        const enclosing = enclosingFunction4(node);
-        if (enclosing === void 0 || node.parent?.type !== import_utils69.AST_NODE_TYPES.MemberExpression || node.parent.object !== node) return;
-        if (node.callee.type !== import_utils69.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils69.AST_NODE_TYPES.Identifier || !namespaces.has(node.callee.object.name) || node.callee.property.type !== import_utils69.AST_NODE_TYPES.Identifier || !FACTORIES.has(node.callee.property.name)) return;
-        let current = node;
-        let refinements = 0;
-        while (current.parent?.type === import_utils69.AST_NODE_TYPES.MemberExpression && current.parent.object === current && !current.parent.computed && current.parent.property.type === import_utils69.AST_NODE_TYPES.Identifier && current.parent.parent?.type === import_utils69.AST_NODE_TYPES.CallExpression && current.parent.parent.callee === current.parent) {
-          const call = current.parent.parent;
-          if (["parse", "parseAsync", "safeParse", "safeParseAsync"].includes(current.parent.property.name)) break;
-          if (REFINEMENTS.has(current.parent.property.name)) refinements += 1;
-          current = call;
-        }
-        if (refinements < 2) return;
-        const references = [];
-        collectReferences2(context.sourceCode.getScope(current), references);
-        const [start, end] = current.range;
-        const [functionStart, functionEnd] = enclosing.range;
-        for (const reference of references) {
-          const [referenceStart] = reference.identifier.range;
-          if (referenceStart < start || referenceStart >= end || reference.resolved === null) continue;
-          for (const definition of reference.resolved.defs) {
-            if (definition.type === "ImportBinding") continue;
-            if (definition.node.type === import_utils69.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils69.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const") return;
-            const [definitionStart, definitionEnd] = definition.node.range;
-            if (definitionStart >= start && definitionEnd <= end) continue;
-            if (definitionStart >= functionStart && definitionEnd <= functionEnd) return;
-          }
-        }
+        const factory = factoryName(node, FACTORIES);
+        if (factory === null || isSharedEnumDomain(node, factory) || isNestedInOwnedFactory(node) || isMemoized(node))
+          return;
+        const enclosing = outermostEnclosingFunction2(node);
+        if (enclosing === void 0) return;
+        const expression = schemaExpression2(node);
+        if (readsReceiver2(expression) || buildsLocalizedText2(expression) || !closesOverNothing(expression, enclosing))
+          return;
         context.report({ node, messageId: "hoistRefinedSchema" });
       }
     };
@@ -12154,20 +12639,21 @@ var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
   rationale: "One multi-value literal expresses the same closed value domain without repeated schema wrappers.",
   remediation: "Replace the union with z.literal([value1, value2, ...]).",
   category: "maintainability",
+  autofix: "safe",
   limitations: [
-    "Bare `zod` imports are analyzed only when the rule option explicitly declares `zodMajorVersion: 4`; `zod/v4` imports are self-declaring."
+    "Bare zod imports are analyzed only when the rule option explicitly declares zodMajorVersion: 4; explicit zod/v4 entrypoints are self-declaring.",
+    "All-string domains are left to zod/prefer-enum-over-literal-union.",
+    "A finding containing comments is not autofixed because moving its trivia is ambiguous."
   ],
   examples: [
     {
       id: "multi-value",
       title: "Use one multi-value literal",
       outcome: "no-match",
-      files: [
-        {
-          path: "src/schema.ts",
-          source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
-        }
-      ],
+      files: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
+      }],
       focusPath: "src/schema.ts",
       expectedCount: 0,
       public: true
@@ -12176,80 +12662,116 @@ var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
       id: "literal-union",
       title: "Avoid repeated literal wrappers",
       outcome: "match",
-      files: [
-        {
-          path: "src/schema.ts",
-          source: "import { z } from 'zod'; export const Version = z.union([z.literal(1), z.literal(2), z.literal(3)]);"
-        }
-      ],
+      files: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.union([z.literal(1), z.literal(2), z.literal(3)]);"
+      }],
+      fixedFiles: [{
+        path: "src/schema.ts",
+        source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
+      }],
       focusPath: "src/schema.ts",
       expectedCount: 1,
       public: true
     }
   ]
 };
-function memberCall(node, object, method) {
-  return node.callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.object.name === object && node.callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.property.name === method;
+function isStaticPrimitive(node, context) {
+  if (node.type === import_utils70.AST_NODE_TYPES.Literal) {
+    return node.value === null || ["bigint", "boolean", "number", "string"].includes(typeof node.value);
+  }
+  if (node.type === import_utils70.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0)
+    return true;
+  if (node.type === import_utils70.AST_NODE_TYPES.Identifier && node.name === "undefined") {
+    const binding = import_utils70.ASTUtils.findVariable(
+      context.sourceCode.getScope(node),
+      node.name
+    );
+    return binding === null || binding.defs.length === 0;
+  }
+  return node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "-" && node.argument.type === import_utils70.AST_NODE_TYPES.Literal && ["bigint", "number"].includes(typeof node.argument.value);
+}
+function isStaticString(node) {
+  return node.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils70.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0;
 }
 var prefer_multi_value_zod_literal_default = createRule({
   name: "prefer-multi-value-zod-literal",
   documentation: PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION,
   meta: {
     type: "suggestion",
+    fixable: "code",
     docs: {
       description: "Use the Zod 4 multi-value literal API instead of a union of literal schemas."
     },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          zodMajorVersion: { type: "integer", minimum: 4, maximum: 4 }
-        }
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        zodMajorVersion: { type: "integer", minimum: 4, maximum: 4 }
       }
-    ],
+    }],
     messages: {
-      useMultiValueLiteral: "Replace this literal-schema union with `{{zod}}.literal([\u2026])`."
+      useMultiValueLiteral: "Replace this literal-schema union with {{zod}}.literal([\u2026])."
     }
   },
   defaultOptions: [{}],
   create(context, [options]) {
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
       return {};
-    const namespaces = /* @__PURE__ */ new Set();
-    const zod4Namespaces = /* @__PURE__ */ new Set();
+    const zodBindings = /* @__PURE__ */ new Set();
+    const zod4Bindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return import_utils70.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function directMemberCall(node, binding, method) {
+      if (node.callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils70.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils70.AST_NODE_TYPES.Identifier || node.callee.property.name !== method)
+        return false;
+      return resolvedBinding(node.callee.object) === binding;
+    }
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
+        const isExplicitV4 = /^zod\/v4(?:$|[-/])/.test(node.source.value);
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils70.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils70.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
-            namespaces.add(specifier.local.name);
-            if (node.source.value === "zod/v4" || node.source.value.startsWith("zod/v4/"))
-              zod4Namespaces.add(specifier.local.name);
+          if (specifier.type === import_utils70.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils70.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils70.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+            const binding = resolvedBinding(specifier.local);
+            if (binding === null) continue;
+            zodBindings.add(binding);
+            if (isExplicitV4) zod4Bindings.add(binding);
           }
         }
       },
       CallExpression(node) {
-        const namespace = [...namespaces].find(
-          (name) => memberCall(node, name, "union")
-        );
-        if (namespace === void 0 || options?.zodMajorVersion !== 4 && !zod4Namespaces.has(namespace) || node.arguments.length !== 1)
+        if (node.callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression || node.callee.object.type !== import_utils70.AST_NODE_TYPES.Identifier)
+          return;
+        const binding = resolvedBinding(node.callee.object);
+        if (binding === null || !zodBindings.has(binding) || !directMemberCall(node, binding, "union") || options?.zodMajorVersion !== 4 && !zod4Bindings.has(binding) || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument?.type !== import_utils70.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 3 || argument.elements.some((element) => {
-          if (element === null || element.type !== import_utils70.AST_NODE_TYPES.CallExpression || !memberCall(element, namespace, "literal") || element.arguments.length !== 1)
-            return true;
-          const [value] = element.arguments;
-          return value === void 0 || value.type === import_utils70.AST_NODE_TYPES.SpreadElement || ![
-            import_utils70.AST_NODE_TYPES.Literal,
-            import_utils70.AST_NODE_TYPES.TemplateLiteral
-          ].includes(value.type);
-        }))
+        if (argument?.type !== import_utils70.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2)
           return;
+        const values = [];
+        for (const element of argument.elements) {
+          if (element === null || element.type !== import_utils70.AST_NODE_TYPES.CallExpression || !directMemberCall(element, binding, "literal") || element.arguments.length !== 1)
+            return;
+          const [value] = element.arguments;
+          if (value === void 0 || !isStaticPrimitive(value, context)) return;
+          values.push(value);
+        }
+        if (values.every(isStaticString)) return;
+        const namespace = node.callee.object.name;
+        const hasComments = context.sourceCode.getCommentsInside(node).length > 0;
         context.report({
           node,
           messageId: "useMultiValueLiteral",
-          data: { zod: namespace }
+          data: { zod: namespace },
+          fix: hasComments ? null : (fixer) => fixer.replaceText(
+            node,
+            `${namespace}.literal([${values.map((value) => context.sourceCode.getText(value)).join(", ")}])`
+          )
         });
       }
     };
@@ -12401,11 +12923,11 @@ var prefer_native_random_uuid_default = createRule({
   create(context) {
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve(identifier) {
+    function resolve2(identifier) {
       return import_utils73.ASTUtils.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) {
@@ -12433,7 +12955,7 @@ var prefer_native_random_uuid_default = createRule({
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== import_utils73.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== import_utils73.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils73.AST_NODE_TYPES.Identifier || (resolve2(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
         if (node.id.type === import_utils73.AST_NODE_TYPES.Identifier) {
@@ -12450,14 +12972,14 @@ var prefer_native_random_uuid_default = createRule({
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
         if (node.callee.type === import_utils73.AST_NODE_TYPES.Identifier) {
-          const variable2 = resolve(node.callee);
+          const variable2 = resolve2(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
         if (node.callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils73.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils73.AST_NODE_TYPES.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);
       }
     };
@@ -12487,22 +13009,22 @@ function memberName4(node) {
   }
   return null;
 }
-function isCryptoLoader(node, resolve) {
+function isCryptoLoader(node, resolve2) {
   if (node.type !== import_utils74.AST_NODE_TYPES.CallExpression || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
   if (argument === void 0 || argument.type === import_utils74.AST_NODE_TYPES.SpreadElement || !isCryptoSpecifier(argument)) {
     return false;
   }
   if (node.callee.type === import_utils74.AST_NODE_TYPES.Identifier) {
-    return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve);
+    return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve2);
   }
-  return node.callee.type === import_utils74.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils74.AST_NODE_TYPES.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve) && memberName4(node.callee) === "getBuiltinModule";
+  return node.callee.type === import_utils74.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils74.AST_NODE_TYPES.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve2) && memberName4(node.callee) === "getBuiltinModule";
 }
 function isCryptoSpecifier(node) {
   return node.type === import_utils74.AST_NODE_TYPES.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) {
@@ -12520,14 +13042,14 @@ var prefer_node_crypto_hash_default = createRule({
   create(context) {
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve(identifier) {
+    function resolve2(identifier) {
       return import_utils74.ASTUtils.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 {
@@ -12542,7 +13064,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 === import_utils74.AST_NODE_TYPES.Identifier) {
@@ -12566,7 +13088,7 @@ var prefer_node_crypto_hash_default = createRule({
           create,
           directBindings,
           namespaceBindings,
-          resolve
+          resolve2
         ))
           return;
         context.report({ node, messageId: "preferNodeCryptoHash" });
@@ -12580,17 +13102,17 @@ function importedName5(node) {
 function isMemberCall(node, name) {
   return node.callee.type === import_utils74.AST_NODE_TYPES.MemberExpression && memberName4(node.callee) === name;
 }
-function isCreateHashCall(node, directBindings, namespaceBindings, resolve) {
+function isCreateHashCall(node, directBindings, namespaceBindings, resolve2) {
   if (node.callee.type === import_utils74.AST_NODE_TYPES.Identifier) {
-    const variable2 = resolve(node.callee);
+    const variable2 = resolve2(node.callee);
     return variable2 !== null && directBindings.has(variable2);
   }
   if (node.callee.type !== import_utils74.AST_NODE_TYPES.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 !== import_utils74.AST_NODE_TYPES.Identifier) return false;
-  const variable = resolve(node.callee.object);
+  const variable = resolve2(node.callee.object);
   return variable !== null && namespaceBindings.has(variable);
 }
 
@@ -13912,7 +14434,30 @@ var import_fs = require("fs");
 var import_path = require("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
@@ -13921,7 +14466,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 }
@@ -14049,7 +14597,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);
 }
@@ -14186,20 +14740,68 @@ var expandWorkspaceGlob = (root, glob) => {
   if (star === -1) return [(0, import_path.join)(root, glob)];
   const prefix = glob.slice(0, star).replace(/\/$/u, "");
   const parent = prefix === "" ? root : (0, import_path.join)(root, prefix);
-  if (!(0, import_fs.existsSync)(parent)) return [];
-  return (0, import_fs.readdirSync)(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => (0, import_path.join)(parent, entry.name));
+  if (!(0, import_fs.existsSync)(parent) || !(0, import_fs.lstatSync)(parent).isDirectory()) return [];
+  return (0, import_fs.readdirSync)(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => (0, import_path.join)(parent, entry.name));
 };
 var propName = (key) => {
   if (key.type === import_utils82.AST_NODE_TYPES.Identifier) return key.name;
   if (key.type === import_utils82.AST_NODE_TYPES.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 !== import_utils82.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils82.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils82.AST_NODE_TYPES.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((0, import_path.dirname)(filename));
+  if (packageRoot === null) return /* @__PURE__ */ new Set();
+  const candidates = CSS_DETECTION_FILES.map((relative2) => (0, import_path.join)(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 = (0, import_path.parse)(dir).root;
+  for (; ; ) {
+    if ((0, import_fs.existsSync)((0, import_path.join)(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = (0, import_path.dirname)(dir);
+    if (dir === root || parent === dir) return null;
+    dir = parent;
+  }
+};
+var fileFingerprint2 = (path) => {
+  try {
+    const stat = (0, import_fs.lstatSync)(path);
+    return stat.isFile() ? `${path}:${stat.size}:${stat.mtimeMs}` : `${path}:excluded`;
+  } catch {
+    return `${path}:missing`;
+  }
+};
+var readTokenStylesheet = (path) => {
+  try {
+    const stat = (0, import_fs.lstatSync)(path);
+    if (!stat.isFile() || stat.size > MAX_TOKEN_STYLESHEET_BYTES) return null;
+    return (0, import_fs.readFileSync)(path, "utf8");
+  } catch {
+    return null;
+  }
+};
 var prefer_semantic_colors_default = createRule({
   name: "prefer-semantic-colors",
   documentation: PREFER_SEMANTIC_COLORS_DOCUMENTATION,
@@ -14213,30 +14815,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 });
@@ -14244,6 +14850,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;
@@ -14291,8 +14917,8 @@ var prefer_semantic_colors_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils82.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
-          importsEmailOrPdfRenderer = true;
+        if (node.callee.type === import_utils82.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.arguments[0].value)) {
+          importsExternalRenderer = true;
         }
         if (node.callee.type === import_utils82.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
@@ -14327,13 +14953,13 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
-          importsEmailOrPdfRenderer = true;
+        if (node.source.type === import_utils82.AST_NODE_TYPES.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);
       }
     };
   }
@@ -14342,11 +14968,11 @@ var prefer_semantic_colors_default = createRule({
 // src/rules/prefer-server-actions.ts
 var import_utils83 = require("@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 }
@@ -14354,12 +14980,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;
@@ -14379,22 +15014,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;
@@ -14454,16 +15096,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 {};
     }
@@ -14471,22 +15124,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 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 hasUseServerDirective = context.sourceCode.ast.body.some(
+      (node) => node.type === "ExpressionStatement" && node.directive === "use server"
     );
-    const hasNextEvidence = hasNextImport || hasUseClientDirective && NEXT_MODULE_PATH_RE2.test(filename);
-    if (!hasNextEvidence) {
+    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")
+    );
+    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);
@@ -14503,7 +15162,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;
             }
           }
@@ -14514,7 +15173,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;
               }
             }
@@ -18436,8 +19095,8 @@ var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   ]
 };
 var PASCAL_SCHEMA_NAME_RE = /^[A-Z][A-Za-z0-9]*Schema$/;
-var BENCHMARK_PATH_RE = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
-var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
+var BENCHMARK_PATH_RE2 = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
+var NON_SCHEMA_TERMINALS2 = /* @__PURE__ */ new Set([
   "parse",
   "parseAsync",
   "safeParse",
@@ -18550,7 +19209,7 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "transform"
 ]);
 var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils100.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-var calleeChainRoot = (node) => {
+var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
     if (current.type === import_utils100.AST_NODE_TYPES.Identifier) {
@@ -18567,7 +19226,7 @@ var calleeChainRoot = (node) => {
     return null;
   }
 };
-var chainMemberNames = (node) => {
+var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
@@ -18627,7 +19286,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       if (binding !== null) zodBindings.add(binding);
     }
     function isZodChain(node) {
-      const root = calleeChainRoot(node);
+      const root = calleeChainRoot2(node);
       if (root === null) return false;
       const binding = resolvedBinding(root);
       return binding !== null && zodBindings.has(binding);
@@ -18643,16 +19302,16 @@ var require_pascal_case_zod_schema_name_default = createRule({
         return false;
       }
       const terminal = terminalMethodName(init.callee);
-      if (terminal === null || NON_SCHEMA_TERMINALS.has(terminal)) return false;
-      const names = chainMemberNames(init.callee);
+      if (terminal === null || NON_SCHEMA_TERMINALS2.has(terminal)) return false;
+      const names = chainMemberNames2(init.callee);
       if (names.length === 0) return false;
       if (isZodChain(init.callee)) {
         return ZOD_SCHEMA_FACTORIES.has(names[0] ?? "") || ZOD_FACTORY_NAMESPACES.has(names[0] ?? "") && ZOD_SCHEMA_FACTORIES.has(names[1] ?? "");
       }
-      const root = calleeChainRoot(init.callee);
+      const root = calleeChainRoot2(init.callee);
       return root !== null && isSchemaBinding(root) && SCHEMA_RETURNING_METHODS.has(terminal);
     }
-    if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+    if (isTestFile(context.filename) || BENCHMARK_PATH_RE2.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     return {
@@ -18855,14 +19514,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",