oxlint-plugin-arch 0.6.3 → 0.8.0

package/dist/rules/dillon-anti-slop/rules/no-module-mocking.d.ts

@@ -1 +1,8 @@
+/**
+ * Disallow Vitest and Jest module mocking, plus any other configured test-double APIs.
+ *
+ * Example: `vi.mock('./mailer')` fails; with `deny: ['*.spyOn']`,
+ * `vi.spyOn(mailer, 'send')` fails too. `checkDestructured` also catches
+ * `const { spyOn } = vi; spyOn(mailer, 'send')`.
+ */
 export declare const noModuleMockingRule: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/index.js

@@ -790,6 +790,11 @@ function layoutNewline(text) {
 ` : `
 `;
 }
+// src/utils/helpers/mocking.ts
+function mockingApiPatternsAssert(patterns) {
+  if (patterns.some((pattern) => !/^(?:\*|(?:vi|jest|\*)\.(?:[A-Za-z_$][\w$]*|\*))$/.test(pattern)))
+    throw new Error("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
+}
 // src/utils/helpers/options.ts
 function optionsFirst(context, fallback) {
   return context.options[0] ?? fallback;
@@ -935,6 +940,49 @@ function routesInspectFunction(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
+// src/utils/helpers/runtime.ts
+import { builtinModules } from "node:module";
+var runtimeServerGlobals = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
+var runtimeBrowserGlobals = [
+  "window",
+  "document",
+  "navigator",
+  "localStorage",
+  "sessionStorage",
+  "location",
+  "history",
+  "screen",
+  "HTMLElement",
+  "Element",
+  "HTMLInputElement",
+  "ResizeObserver",
+  "MutationObserver",
+  "IntersectionObserver",
+  "FileReader",
+  "matchMedia",
+  "getComputedStyle",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "alert",
+  "confirm",
+  "prompt"
+];
+function runtimeMatchesImport(values, source) {
+  return Boolean(values?.some((value) => source === value || source.startsWith(value + "/")));
+}
+function runtimeIsBackendImport(options, target, source) {
+  return options.backend.some((path) => target.startsWith(path + "/")) || options.backendPackages.some((name) => source === name || source.startsWith(name + "/") && /\/(?:server|rpc)(?:\/|$)/.test(source.slice(name.length)));
+}
+function runtimeIsServerPlatformImport(source) {
+  return builtinModules.includes(source) || source === "@orpc/server" || /^(?:node:|bun(?::|$)|cloudflare:)/.test(source) || /^react-dom\/server(?:\.|\/|$)/.test(source);
+}
+function runtimeMemberName(node) {
+  if (node?.type !== "MemberExpression")
+    return null;
+  if (!node.computed && node.property.type === "Identifier")
+    return node.property.name;
+  return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+}
 // src/utils/helpers/sanitizers.ts
 function sanitizersCallsConfigured(node, names) {
   let found = false;
@@ -1589,7 +1637,6 @@ var directives = defineRule7({
 });
 
 // src/rules/module-policy/tanstack-runtime.ts
-import { builtinModules } from "node:module";
 import { defineRule as defineRule8 } from "@oxlint/plugins";
 var tanstackRuntime = defineRule8({
   meta: {
@@ -1667,10 +1714,8 @@ var tanstackRuntime = defineRule8({
       if (typeOnly)
         return;
       const target = boundaryResolveTarget(options2, file, source);
-      const matches = (values) => values?.some((value) => source === value || source.startsWith(value + "/"));
-      const backend = options2.backend.some((path) => target.startsWith(path + "/")) || options2.backendPackages.some((name) => source === name || source.startsWith(name + "/") && /\/(?:server|rpc)(?:\/|$)/.test(source.slice(name.length)));
-      const server = Boolean(renderer) || builtinModules.includes(source) || source === "@orpc/server" || backend || /\.server(?:\.[cm]?[jt]sx?)?$/.test(target) || /^(?:node:|bun(?::|$)|cloudflare:)/.test(source) || /^@tanstack\/(?:react|solid|vue)-start\/(?:server|server-only)(?:\/|$)/.test(source) || /^react-dom\/server(?:\.|\/|$)/.test(source) || matches(options2.serverImports);
-      const client = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || /^(?:react-dom\/client|@tanstack\/(?:react|solid|vue)-start\/client-only)(?:\/|$)/.test(source) || matches(options2.clientImports);
+      const server = Boolean(renderer) || runtimeIsServerPlatformImport(source) || runtimeIsBackendImport(options2, target, source) || /\.server(?:\.[cm]?[jt]sx?)?$/.test(target) || /^@tanstack\/(?:react|solid|vue)-start\/(?:server|server-only)(?:\/|$)/.test(source) || runtimeMatchesImport(options2.serverImports, source);
+      const client = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || /^(?:react-dom\/client|@tanstack\/(?:react|solid|vue)-start\/client-only)(?:\/|$)/.test(source) || runtimeMatchesImport(options2.clientImports, source);
       if (client && (serverFile || rscFile || shared) && boundary(node.start)?.side !== "client") {
         const references = node.type === "ImportDeclaration" ? context.sourceCode.getDeclaredVariables(node).flatMap((variable) => variable.references.filter((reference) => runtimeIdentifiers.has(reference.identifier.range[0]))) : [];
         if (!shared && references.length && references.every((reference) => boundary(reference.identifier.range[0])?.side === "client"))
@@ -1699,34 +1744,9 @@ var tanstackRuntime = defineRule8({
       report(node, source, "use an inline imported TanStack server boundary; static isomorphic server imports belong only to the configured RPC owner");
     }
     function global(node) {
-      const serverNames = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
-      const browserNames = [
-        "window",
-        "document",
-        "navigator",
-        "localStorage",
-        "sessionStorage",
-        "location",
-        "history",
-        "screen",
-        "HTMLElement",
-        "Element",
-        "HTMLInputElement",
-        "ResizeObserver",
-        "MutationObserver",
-        "IntersectionObserver",
-        "FileReader",
-        "matchMedia",
-        "getComputedStyle",
-        "requestAnimationFrame",
-        "cancelAnimationFrame",
-        "alert",
-        "confirm",
-        "prompt"
-      ];
       const member = node.parent.type === "MemberExpression" && node.parent.object === node && node.name === "globalThis" ? node.parent : undefined;
-      const name = member && !member.computed && member.property.type === "Identifier" ? member.property.name : member?.computed && member.property.type === "Literal" && typeof member.property.value === "string" ? member.property.value : node.name;
-      if (!serverNames.includes(name) && !browserNames.includes(name))
+      const name = runtimeMemberName(member) ?? node.name;
+      if (!runtimeServerGlobals.includes(name) && !runtimeBrowserGlobals.includes(name))
         return;
       let scope = context.sourceCode.getScope(node);
       while (scope) {
@@ -1738,9 +1758,9 @@ var tanstackRuntime = defineRule8({
       const references = context.sourceCode.getScope(node).references;
       if (!references.some((reference) => reference.identifier.range[0] === node.start && runtimeIdentifiers.has(reference.identifier.range[0])))
         return;
-      if (serverNames.includes(name) && (shared || !serverPosition(node.start)))
+      if (runtimeServerGlobals.includes(name) && (shared || !serverPosition(node.start)))
         report(node, name, "server globals require a server execution boundary");
-      if (browserNames.includes(name) && (serverFile || rscFile) && boundary(node.start)?.side !== "client")
+      if (runtimeBrowserGlobals.includes(name) && (serverFile || rscFile) && boundary(node.start)?.side !== "client")
         report(node, name, "browser globals are unavailable during server execution");
     }
     return {
@@ -2023,6 +2043,158 @@ var memoization = defineRule10({
   }
 });
 
+// src/rules/module-policy/next-runtime.ts
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var nextRuntime = defineRule11({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          web: { type: "array", items: { type: "string" } },
+          backend: { type: "array", items: { type: "string" } },
+          aliases: { type: "object", additionalProperties: { type: "string" } },
+          backendPackages: { type: "array", items: { type: "string" } },
+          serverImports: { type: "array", items: { type: "string" } },
+          clientImports: { type: "array", items: { type: "string" } },
+          allowComputedImportsIn: { type: "array", items: { type: "string" } }
+        },
+        required: ["web", "backend", "aliases", "backendPackages"]
+      }
+    ],
+    messages: {
+      runtime: "{{source}} is not valid here: {{reason}}.",
+      directive: "'{{directive}}' does not match this {{side}} module; rename the file or remove the directive.",
+      action: "Server actions modules must start with 'use server'.",
+      computed: "Use a literal dynamic import so runtime ownership can be checked, or declare this exact file in allowComputedImportsIn after reviewing its targets."
+    }
+  },
+  createOnce(context) {
+    let options2;
+    let file = "";
+    let server = false;
+    let client = false;
+    let shared = false;
+    const reactNamespaces = new Set;
+    function report(node, source, reason) {
+      context.report({ node, messageId: "runtime", data: { source, reason } });
+    }
+    function check(node, source, typeOnly) {
+      if (typeOnly)
+        return;
+      const target = boundaryResolveTarget(options2, file, source);
+      const serverOnly = runtimeIsServerPlatformImport(source) || runtimeIsBackendImport(options2, target, source) || /\.(?:server|rsc)(?:\.[cm]?[jt]sx?)?$/.test(target) || /^(?:server-only|next\/headers|next\/cache|next\/server)$/.test(source) || runtimeMatchesImport(options2.serverImports, source);
+      const clientOnly = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || /^(?:client-only|react-dom\/client)$/.test(source) || runtimeMatchesImport(options2.clientImports, source);
+      if (clientOnly && (server || shared)) {
+        report(node, source, "browser-only dependencies do not belong in server, RSC or shared modules");
+      } else if (serverOnly && !server) {
+        report(node, source, shared ? "shared utilities/constants/lib cannot import server-only dependencies" : "server-only dependencies belong in .server, .rsc or server action modules");
+      }
+    }
+    function resolve3(node) {
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.set.get(node.name);
+        if (variable?.defs.length)
+          return variable;
+        scope = scope.upper;
+      }
+      return null;
+    }
+    function clientHook(name) {
+      return /^use[A-Z]/.test(name) && !["useId", "use"].includes(name);
+    }
+    function inType(node) {
+      return ["TSTypeQuery", "TSQualifiedName", "TSTypeReference"].includes(node.parent?.type ?? "");
+    }
+    function globalReferences() {
+      const scope = context.sourceCode.scopeManager.scopes[0];
+      if (!scope)
+        return [];
+      const implicit = [...scope.set.values()].filter((variable) => !variable.defs.length);
+      return [...scope.through, ...implicit.flatMap((variable) => variable.references)].map((reference) => reference.identifier).filter((node) => node.type === "Identifier" && !inType(node));
+    }
+    function global(reference) {
+      const owned = reference.name === "globalThis" ? runtimeMemberName(reference.parent) : null;
+      const name = owned ?? reference.name;
+      const serverGlobal = runtimeServerGlobals.includes(name);
+      const browserGlobal = runtimeBrowserGlobals.includes(name);
+      if (!serverGlobal && !browserGlobal)
+        return;
+      const node = owned ? reference.parent : reference;
+      const env = node.parent;
+      const key = env?.parent;
+      const publicEnv = name === "process" && runtimeMemberName(env) === "env" && env?.type === "MemberExpression" && env.object === node && key?.type === "MemberExpression" && key.object === env && (runtimeMemberName(key) ?? "").startsWith("NEXT_PUBLIC_");
+      if (serverGlobal && !server && !publicEnv && (client || shared))
+        report(node, name, "server globals are unavailable in browser and shared modules");
+      if (browserGlobal && server)
+        report(node, name, "browser globals are unavailable during server execution");
+    }
+    return {
+      Program(program) {
+        options2 = optionsFirst(context);
+        reactNamespaces.clear();
+        file = context.filename.replaceAll("\\", "/");
+        const directives2 = program.body.filter((statement) => statement.type === "ExpressionStatement" && ("directive" in statement) && Boolean(statement.directive)).map((statement) => ({ node: statement, value: statement.directive ?? "" }));
+        const useServer = directives2.find((entry) => entry.value === "use server");
+        const useClient = directives2.find((entry) => entry.value === "use client");
+        const serverName = /\.(?:server|rsc|action)\.[cm]?[jt]sx?$/.test(file);
+        const clientName = /\.client\.[cm]?[jt]sx?$/.test(file);
+        shared = /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options2.web.some((path) => file.startsWith(path + "/lib/"));
+        server = serverName || Boolean(useServer);
+        client = clientName || Boolean(useClient);
+        if (useClient && serverName)
+          context.report({ node: useClient.node, messageId: "directive", data: { directive: "use client", side: "server" } });
+        if (useServer && clientName)
+          context.report({ node: useServer.node, messageId: "directive", data: { directive: "use server", side: "client" } });
+        if (/\.action\.[cm]?[jt]sx?$/.test(file) && !useServer)
+          context.report({ node: program, messageId: "action" });
+        if (useClient)
+          server = false;
+      },
+      ImportDeclaration(node) {
+        const typeOnly = node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+        check(node, node.source.value, typeOnly);
+        if (typeOnly || !(server || shared) || node.source.value !== "react")
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier")
+            reactNamespaces.add(specifier);
+          else if (specifier.importKind !== "type" && specifier.imported.type === "Identifier" && clientHook(specifier.imported.name))
+            report(specifier, specifier.imported.name, "client hooks do not belong in server, RSC or shared modules");
+        }
+      },
+      MemberExpression(node) {
+        const name = runtimeMemberName(node);
+        if (!name || !clientHook(name) || node.object.type !== "Identifier")
+          return;
+        const binding = resolve3(node.object)?.defs[0]?.node;
+        if (binding && reactNamespaces.has(binding))
+          report(node, `${node.object.name}.${name}`, "client hooks do not belong in server, RSC or shared modules");
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source)
+          check(node, node.source.value, node.exportKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.exportKind === "type"));
+      },
+      ExportAllDeclaration(node) {
+        check(node, node.source.value, node.exportKind === "type");
+      },
+      ImportExpression(node) {
+        if (node.source.type === "Literal" && typeof node.source.value === "string")
+          check(node, node.source.value, false);
+        else if (!options2.allowComputedImportsIn?.includes(file))
+          context.report({ node, messageId: "computed" });
+      },
+      "Program:exit"() {
+        for (const reference of globalReferences())
+          global(reference);
+      }
+    };
+  }
+});
+
 // src/rules/module-policy/index.ts
 var module_policy_default = eslintCompatPlugin({
   meta: { name: "modules" },
@@ -2039,6 +2211,7 @@ var module_policy_default = eslintCompatPlugin({
     "local-type-alias": syntaxRule("TSTypeAliasDeclaration", "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface."),
     "no-unknown": syntaxRule("TSUnknownKeyword", "Use an owned domain type rather than unknown."),
     memoization,
+    "next-runtime": nextRuntime,
     "pascal-interface": syntaxRule("TSInterfaceDeclaration:not([id.name=/^[A-Z][a-zA-Z0-9]*$/])", "Use PascalCase for interfaces."),
     "reasoned-directives": directives,
     "rpc-database": syntaxRule("CallExpression[callee.property.name=/^(selectFrom|insertInto|updateTable|deleteFrom|mergeInto|executeQuery)$/]", "RPC handlers delegate database work to services."),

package/dist/rules/module-policy/next-runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks Next.js runtime ownership from file names and directives: `.server`/`.rsc` and `'use server'` modules stay off
+ * the browser, `.client` and `'use client'` modules stay off server-only APIs, and shared modules use neither.
+ *
+ * Example: `chat.client.ts` importing `next/headers` fails; `chat.server.ts` importing it passes.
+ */
+export declare const nextRuntime: import("@oxlint/plugins").Rule;

package/dist/types/module-policy.types.d.ts

@@ -26,6 +26,11 @@ export interface ModuleRuntimeOptions extends Pick<ModuleBoundaryOptions, 'web'
     clientImports?: string[];
     allowComputedImportsIn?: string[];
 }
+export interface ModuleNextRuntimeOptions extends Pick<ModuleBoundaryOptions, 'web' | 'backend' | 'aliases' | 'backendPackages'> {
+    serverImports?: string[];
+    clientImports?: string[];
+    allowComputedImportsIn?: string[];
+}
 export interface ModuleTestModifiersOptions {
     additionalTestFunctions?: string[];
 }

package/dist/types/preset.types.d.ts

@@ -3,14 +3,21 @@ export type PresetPolicy = boolean | ((current: OxlintOverride[]) => OxlintOverr
 export type PresetPolicyName = 'typePlacement' | 'typeSafety' | 'serviceStructure' | 'fileLayout' | 'naming' | 'comments' | 'formatting' | 'statementLayout' | 'imports' | 'react' | 'effects' | 'memoization' | 'routes' | 'forms' | 'schemas' | 'boundaries' | 'tests' | 'trivialFunctions' | 'mutableState' | 'backend' | 'tailwind' | 'shadcn' | 'rpcClientOwnership';
 export type PresetRole = 'web' | 'server' | 'runner' | 'scripts' | 'packages';
 export type PresetFolderLayout = 'flat' | 'domain';
+export type PresetFramework = 'tanstack-start' | 'next';
 export interface PresetArchitectureEntry {
     role: PresetRole;
     layout?: Record<string, PresetFolderLayout>;
+    /** Web roots only: selects the route and runtime-boundary policies. */
+    framework?: PresetFramework;
+    /** Web, server and runner roots only: the source folder inside the root; `src` when omitted, `.` for the root itself. */
+    sourceDir?: string;
 }
 export type PresetArchitecture = Record<string, PresetRole | PresetArchitectureEntry>;
 export interface PresetResolvedRoot {
     role: PresetRole;
     layout: Record<string, PresetFolderLayout>;
+    framework?: PresetFramework;
+    sourceDir?: string;
 }
 export interface PresetFolderScope {
     path: string;
@@ -19,8 +26,13 @@ export interface PresetFolderScope {
 }
 export interface PresetOptions {
     root?: string;
+    /** Default framework for web roots that do not set their own; `tanstack-start` when omitted. */
+    framework?: PresetFramework;
     architecture?: PresetArchitecture;
     severity?: 'error' | 'warn';
+    /** Per-rule levels applied after `severity`, for rules the preset enables. */
+    ruleSeverities?: Record<string, 'error' | 'warn' | 'off'>;
+    formatting?: PresetFormattingOptions;
     limits?: PresetLimitsOptions;
     modules?: PresetModulesOptions;
     imports?: PresetImportsOptions;
@@ -34,11 +46,16 @@ export interface PresetOptions {
     ruleExclusions?: Record<string, string[]>;
     cliFiles?: string[];
     tanstackStart?: PresetTanstackStartOptions;
+    next?: PresetNextOptions;
     tailwind?: false | PresetTailwindOptions;
     shadcn?: false | PresetShadcnOptions;
 }
 export interface PresetPolicyOptions extends Partial<Record<PresetPolicyName, PresetPolicy>> {
 }
+export interface PresetFormattingOptions {
+    semi?: 'always' | 'never';
+    quotes?: 'single' | 'double';
+}
 export interface PresetLimitsOptions {
     maxFileLines?: number;
     maxFunctionComplexity?: number;
@@ -46,11 +63,32 @@ export interface PresetLimitsOptions {
 export interface PresetModulesOptions {
     customFileRoles?: string[];
     migrationFiles?: string[];
+    /** Type files allowed outside `types/`; they follow the backend `types/` contract. */
+    colocatedTypeFiles?: string[];
 }
 export interface PresetTestsOptions {
     profile?: 'standard' | 'fixtures';
     additionalTestFunctions?: string[];
     additionalAssertionFunctions?: string[];
+    /** Test-double APIs banned in test files; `modules` (module mocking only) when omitted. */
+    mocking?: PresetTestMockingPreset | PresetTestMockingOptions;
+}
+export type PresetTestMockingPreset = 'modules' | 'strict';
+export interface PresetTestMockingApi {
+    api: string;
+    message?: string;
+}
+export interface PresetTestMockingException {
+    files: string[];
+    /** API patterns allowed in these files; `*` allows every API. */
+    apis: string[];
+}
+export interface PresetTestMockingOptions {
+    preset?: PresetTestMockingPreset;
+    /** API patterns added to the preset list, such as `vi.*` or `jest.spyOn`. */
+    deny?: Array<string | PresetTestMockingApi>;
+    /** Per-file exceptions, added after the preset's own. */
+    allow?: PresetTestMockingException[];
 }
 export interface PresetImportsOptions {
     backendEntryPoints?: string[];
@@ -77,6 +115,11 @@ export interface PresetTanstackStartOptions {
     additionalClientOnlyImports?: string[];
     computedImportAllowedFiles?: string[];
 }
+export interface PresetNextOptions {
+    additionalServerOnlyImports?: string[];
+    additionalClientOnlyImports?: string[];
+    computedImportAllowedFiles?: string[];
+}
 export interface PresetTailwindOptions {
     cssEntryPoint?: string;
     cssEntryPointsByRoot?: Record<string, string>;
@@ -107,7 +150,12 @@ export interface PresetContext {
     css: Record<string, string>;
     baseImports: PresetImportRestriction[];
     web: string[];
+    /** Web `src` roots per framework. */
+    tanstackWeb: string[];
+    nextWeb: string[];
     backend: string[];
+    /** Server and runner architecture roots, without their source folder. */
+    backendRoots: string[];
     app: string[];
     appFiles: string[];
     webFiles: string[];

package/dist/utils/helpers/declarations.d.ts

@@ -14,7 +14,7 @@ export declare function declarationsRuntimeName(node: DeclarationsRuntime): stri
 export declare function declarationsRuntimeKind(node: DeclarationsRuntime): 'class' | 'enum' | 'function' | 'variable';
 export declare function declarationsIsTrivialExpression(node: ESTree.Expression): boolean;
 export declare function declarationsIsTrivialFunction(node: AstRuntimeFunction): boolean;
-export declare const declarationsKinds: readonly ["function", "const", "let", "var", "class", "type", "interface", "enum"];
+export declare const declarationsKinds: readonly ['function', 'const', 'let', 'var', 'class', 'type', 'interface', 'enum'];
 export type DeclarationsKind = (typeof declarationsKinds)[number];
 export interface DeclarationsNamed {
     name: string;

package/dist/utils/helpers/index.d.ts

@@ -5,11 +5,13 @@ export * from './exports.ts';
 export * from './factories.ts';
 export * from './guards.ts';
 export * from './layout.ts';
+export * from './mocking.ts';
 export * from './naming.ts';
 export * from './options.ts';
 export * from './orpc.ts';
 export * from './react-components.ts';
 export * from './routes.ts';
+export * from './runtime.ts';
 export * from './sanitizers.ts';
 export * from './schemas.ts';
 export * from './trivial.ts';

package/dist/utils/helpers/layout.d.ts

@@ -5,9 +5,9 @@ export declare const layoutIndentSchema: {
         minimum: number;
         enum?: undefined;
     } | {
+        minimum?: undefined;
         type: string;
         enum: string[];
-        minimum?: undefined;
     })[];
 };
 export declare function layoutLineIndent(text: string, offset: number): string;

package/dist/utils/helpers/mocking.d.ts

@@ -0,0 +1,2 @@
+/** Throws unless every pattern is `*` or `<vi|jest|*>.<method|*>`. */
+export declare function mockingApiPatternsAssert(patterns: string[]): void;

package/dist/utils/helpers/naming.d.ts

@@ -6,7 +6,7 @@ export declare function namingFolderPrefixes(folders: string[], separator: strin
 export declare function namingPascalCase(value: string): string;
 export declare function namingCamelCase(value: string): string;
 export declare function namingMatchTemplate(basename: string, template: string, placeholderPattern?: string): Record<string, string> | null;
-export declare const namingStemModes: readonly ["before-first-dot", "full-basename"];
+export declare const namingStemModes: readonly ['before-first-dot', 'full-basename'];
 export type NamingStemMode = (typeof namingStemModes)[number];
 export declare function namingNormalized(value: string, normalize: 'remove-separators' | 'none'): string;
 export declare function namingFileStem(basename: string, mode?: NamingStemMode, trailingRoles?: readonly string[], roleSeparators?: readonly string[]): string;

package/dist/utils/helpers/preset.d.ts

@@ -2,5 +2,6 @@ import type { OxlintOverride } from 'oxlint';
 import type { PresetRules } from '../../types/preset.types.ts';
 export declare function presetScopes(roots: string[], suffix?: string): string[];
 export declare function presetOverride(files: string[], rules: PresetRules, excludeFiles?: string[]): OxlintOverride;
+export declare function presetRuleSeverities(rules: PresetRules, severities: Record<string, 'error' | 'warn' | 'off'>): PresetRules;
 export declare function presetPackageName(root: string, directory: string): string | undefined;
 export declare function presetSeverity(rules: PresetRules, level: 'error' | 'warn'): PresetRules;

package/dist/utils/helpers/runtime.d.ts

@@ -0,0 +1,14 @@
+import type { ESTree } from '@oxlint/plugins';
+import type { ModuleBoundaryOptions } from '../../types/module-policy.types.ts';
+/** Globals that only exist on the server runtime. */
+export declare const runtimeServerGlobals: string[];
+/** Globals that only exist in the browser. */
+export declare const runtimeBrowserGlobals: string[];
+/** Whether `source` is one of the configured module prefixes or a subpath of one. */
+export declare function runtimeMatchesImport(values: string[] | undefined, source: string): boolean;
+/** Whether an import reaches a configured backend root or a backend package's server/RPC entry. */
+export declare function runtimeIsBackendImport(options: Pick<ModuleBoundaryOptions, 'backend' | 'backendPackages'>, target: string, source: string): boolean;
+/** Whether an import is a server platform module: Node built-ins, Bun, Cloudflare, oRPC server or React DOM server. */
+export declare function runtimeIsServerPlatformImport(source: string): boolean;
+/** The static name of a member access: `a.b` and `a['b']` give `b`; anything else gives `null`. */
+export declare function runtimeMemberName(node: ESTree.Node | null | undefined): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.6.3",
+  "version": "0.8.0",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,14 @@
       "types": "./dist/presets/index.d.ts",
       "default": "./dist/presets/index.js"
     },
+    "./presets/react-modules-preset": {
+      "types": "./dist/presets/react-modules-preset.d.ts",
+      "default": "./dist/presets/react-modules-preset.js"
+    },
+    "./presets/next-react-modules-preset": {
+      "types": "./dist/presets/next-react-modules-preset.d.ts",
+      "default": "./dist/presets/next-react-modules-preset.js"
+    },
     "./presets/tanstack-start-react-modules-preset": {
       "types": "./dist/presets/tanstack-start-react-modules-preset.d.ts",
       "default": "./dist/presets/tanstack-start-react-modules-preset.js"
@@ -30,12 +38,12 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build src/index.ts src/presets/index.ts src/presets/tanstack-start-react-modules-preset.ts src/rules/dillon-anti-slop/index.ts src/rules/module-policy/index.ts --root src --outdir dist --target node --format esm --packages external && tsc --project tsconfig.build.json",
+    "build": "bun build src/index.ts src/presets/index.ts src/presets/react-modules-preset.ts src/presets/next-react-modules-preset.ts src/presets/tanstack-start-react-modules-preset.ts src/rules/dillon-anti-slop/index.ts src/rules/module-policy/index.ts --root src --outdir dist --target node --format esm --packages external && tsc --project tsconfig.build.json",
     "check": "bun run lint && bun run build && bun run typecheck && bun run test && bun run check:examples",
     "lint": "oxlint src examples scripts",
     "test": "vitest run src/tests",
-    "typecheck": "tsc --noEmit",
-    "check:examples": "oxlint examples/minimal.oxlint.config.ts -c examples/minimal.oxlint.config.ts --disable-nested-config && oxlint examples/full.oxlint.config.ts -c examples/full.oxlint.config.ts --disable-nested-config && oxlint examples/dist.oxlint.config.ts -c examples/dist.oxlint.config.ts --disable-nested-config && oxlint examples/monorepo.oxlint.config.ts -c examples/monorepo.oxlint.config.ts --disable-nested-config && oxlint --print-config -c examples/preset.oxlint.config.ts > /dev/null",
+    "typecheck": "tsrs --noEmit",
+    "check:examples": "oxlint examples/minimal.oxlint.config.ts -c examples/minimal.oxlint.config.ts --disable-nested-config && oxlint examples/full.oxlint.config.ts -c examples/full.oxlint.config.ts --disable-nested-config && oxlint examples/dist.oxlint.config.ts -c examples/dist.oxlint.config.ts --disable-nested-config && oxlint examples/monorepo.oxlint.config.ts -c examples/monorepo.oxlint.config.ts --disable-nested-config && oxlint --print-config -c examples/preset.oxlint.config.ts > /dev/null && oxlint --print-config -c examples/mixed-frameworks.oxlint.config.ts > /dev/null",
     "prepublishOnly": "bun run check",
     "release": "bash scripts/release.sh",
     "release:patch": "bash scripts/release.sh patch --yes",
@@ -44,36 +52,37 @@
   },
   "dependencies": {
     "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
-    "@oxlint/plugins": "1.85.0",
+    "@oxlint/plugins": "1.89.0",
     "@regru/eslint-plugin-prefer-early-return": "1.0.0",
-    "@shadcn/lint": "0.1.5",
+    "@shadcn/lint": "0.2.3",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-perfectionist": "5.12.1",
+    "eslint-plugin-perfectionist": "5.13.0",
     "eslint-plugin-react": "7.37.5",
     "eslint-plugin-react-you-might-not-need-an-effect": "1.0.2",
     "eslint-plugin-svg-jsx": "1.3.0",
-    "eslint-plugin-tsdoc": "0.5.3",
+    "eslint-plugin-tsdoc": "0.5.4",
     "eslint-plugin-unused-imports": "4.4.1",
-    "oxlint-plugin-eslint": "1.85.0",
-    "oxlint-tailwindcss": "1.14.0"
+    "oxlint-plugin-eslint": "1.89.0",
+    "oxlint-tailwindcss": "1.16.0"
   },
   "peerDependencies": {
     "oxlint": ">=1.85.0",
     "oxlint-tsgolint": ">=7.0.2003"
   },
   "devDependencies": {
-    "@orpc/server": "1.15.4",
-    "@tanstack/react-router": "1.170.41",
-    "@types/node": "26.0.1",
+    "@orpc/server": "1.16.1",
+    "@tanstack/react-router": "1.170.45",
+    "@types/node": "26.6.5",
     "@types/react": "19.3.0",
-    "bumpp": "10.4.1",
-    "oxlint": "1.85.0",
-    "oxlint-tsgolint": "7.0.2003",
-    "react": "19.3.0",
+    "bumpp": "12.3.0",
+    "oxlint": "1.89.0",
+    "oxlint-tsgolint": "7.0.2004",
+    "react": "19.3.1",
     "tailwindcss": "4.3.3",
-    "typescript": "6.0.3",
-    "vitest": "4.1.9",
-    "zod": "4.6.5"
+    "tsrs": "0.18.0-ts7.1.0-dev.20260929",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5",
+    "zod": "4.6.7"
   },
   "packageManager": "bun@1.3.14",
   "license": "MIT",

package/src/rules/dillon-anti-slop/UPSTREAM.md

@@ -17,3 +17,9 @@ vendoring and does not publish an official npm package.
 Local behavior fixes recognize `SAFETY:` comments on exported declarations and
 export-default assertions, while retaining statement boundaries for other
 assertions. Covered by `src/tests/safety-comment.test.ts` and preset fixtures.
+
+Local option changes let `no-module-mocking` take `deny` and `allow` API
+patterns and `checkDestructured`, so the preset can also ban stubs such as
+`vi.spyOn`. With no options
+it reports the same calls as before. Covered by
+`src/tests/no-module-mocking.test.ts` and preset tests.