@sarj/eslint-plugin 15.17.2 → 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");
@@ -12706,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) {
@@ -12738,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) {
@@ -12755,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);
       }
     };
@@ -12792,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) {
@@ -12825,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 {
@@ -12847,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) {
@@ -12871,7 +13088,7 @@ var prefer_node_crypto_hash_default = createRule({
           create,
           directBindings,
           namespaceBindings,
-          resolve
+          resolve2
         ))
           return;
         context.report({ node, messageId: "preferNodeCryptoHash" });
@@ -12885,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);
 }
 
@@ -14217,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
@@ -14226,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 }
@@ -14354,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);
 }
@@ -14491,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,
@@ -14518,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 });
@@ -14549,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;
@@ -14596,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) {
@@ -14632,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);
       }
     };
   }
@@ -14647,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 }
@@ -14659,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;
@@ -14684,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;
@@ -14759,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 {};
     }
@@ -14776,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 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);
@@ -14808,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;
             }
           }
@@ -14819,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;
               }
             }
@@ -19167,7 +19521,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.2"
+  version: "15.17.3"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",