@sarj/eslint-plugin 15.17.2 → 15.17.3

package/dist/index.js

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