oxlint-plugin-arch 0.6.0 → 0.6.2

package/dist/presets/index.js

@@ -1042,15 +1042,35 @@ function presetReactConfig(context) {
     ]))));
   }
   if (Object.keys(css).length && options.shadcn !== false) {
+    const allow = ["layout", "opacity", "truncate"];
+    const padding = ["p", "px", "py", "ps", "pe", "pt", "pr", "pb", "pl"];
+    const gap = ["gap", "gap-x", "gap-y"];
+    const safeArea = padding.flatMap((group) => ["top", "right", "bottom", "left"].flatMap((side) => [
+      `${group}-[env(safe-area-inset-${side})]`,
+      ...group === "p" ? [] : [`${group}-[max(--spacing(*),env(safe-area-inset-${side}))]`]
+    ]));
     policies.shadcn = [
       presetOverride(webFiles, {
-        "shadcn/no-restyle": ["error", { allow: ["layout", "opacity"] }],
-        "shadcn/no-arbitrary-values": ["error", { allow: ["layout"] }],
+        "shadcn/no-restyle": [
+          "error",
+          {
+            allow,
+            contracts: [
+              { pattern: "^(CardContent|PopoverContent)$", allow: [...allow, ...padding] },
+              { pattern: "^TabsContent$", allow: [...allow, ...gap, ...padding] },
+              { pattern: "^(Tabs|HoverCardContent|SidebarHeader|BreadcrumbList)$", allow: [...allow, ...gap] }
+            ]
+          }
+        ],
+        "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea] }],
         "shadcn/require-static-classes": "error",
         "modules/dynamic-classes": "error"
       }, ui),
       presetOverride(webFiles, {
         "shadcn/no-unknown-classes": ["error", { allow: [] }]
+      }),
+      presetOverride(presetScopes(web, "components/ui/sonner.tsx"), {
+        "shadcn/no-unknown-classes": ["error", { allow: ["toaster", "toast"] }]
       })
     ];
   }
@@ -1119,7 +1139,6 @@ function presetBoundariesConfig(context) {
 
 // src/configs/plugins.ts
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
 var require2 = createRequire(import.meta.url);
 function presetPluginsConfig(context) {
   const { options, web, css } = context;
@@ -1136,15 +1155,15 @@ function presetPluginsConfig(context) {
     require2.resolve("@eslint-community/eslint-plugin-eslint-comments"),
     {
       name: "arch",
-      specifier: fileURLToPath(new URL("../index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch")
     },
     {
       name: "dillon-anti-slop",
-      specifier: fileURLToPath(new URL("../rules/dillon-anti-slop/index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch/rules/dillon-anti-slop")
     },
     {
       name: "modules",
-      specifier: fileURLToPath(new URL("../rules/module-policy/index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch/rules/module-policy")
     }
   ];
   const settings = {
@@ -1213,9 +1232,9 @@ function presetResolveContext(options) {
         throw new Error("Folder layout mode must be flat or domain.");
       layout[folder] = mode;
     }
-    const folders = Object.keys(layout);
-    for (const [index, folder] of folders.entries()) {
-      const overlaps = folders.slice(0, index).some((other) => folder.startsWith(other + "/") || other.startsWith(folder + "/"));
+    const folders2 = Object.keys(layout);
+    for (const [index, folder] of folders2.entries()) {
+      const overlaps = folders2.slice(0, index).some((other) => folder.startsWith(other + "/") || other.startsWith(folder + "/"));
       if (overlaps) {
         throw new Error("Layout folders must not overlap.");
       }

package/dist/presets/tanstack-start-react-modules-preset.js

@@ -1042,15 +1042,35 @@ function presetReactConfig(context) {
     ]))));
   }
   if (Object.keys(css).length && options.shadcn !== false) {
+    const allow = ["layout", "opacity", "truncate"];
+    const padding = ["p", "px", "py", "ps", "pe", "pt", "pr", "pb", "pl"];
+    const gap = ["gap", "gap-x", "gap-y"];
+    const safeArea = padding.flatMap((group) => ["top", "right", "bottom", "left"].flatMap((side) => [
+      `${group}-[env(safe-area-inset-${side})]`,
+      ...group === "p" ? [] : [`${group}-[max(--spacing(*),env(safe-area-inset-${side}))]`]
+    ]));
     policies.shadcn = [
       presetOverride(webFiles, {
-        "shadcn/no-restyle": ["error", { allow: ["layout", "opacity"] }],
-        "shadcn/no-arbitrary-values": ["error", { allow: ["layout"] }],
+        "shadcn/no-restyle": [
+          "error",
+          {
+            allow,
+            contracts: [
+              { pattern: "^(CardContent|PopoverContent)$", allow: [...allow, ...padding] },
+              { pattern: "^TabsContent$", allow: [...allow, ...gap, ...padding] },
+              { pattern: "^(Tabs|HoverCardContent|SidebarHeader|BreadcrumbList)$", allow: [...allow, ...gap] }
+            ]
+          }
+        ],
+        "shadcn/no-arbitrary-values": ["error", { allow: ["layout", ...safeArea] }],
         "shadcn/require-static-classes": "error",
         "modules/dynamic-classes": "error"
       }, ui),
       presetOverride(webFiles, {
         "shadcn/no-unknown-classes": ["error", { allow: [] }]
+      }),
+      presetOverride(presetScopes(web, "components/ui/sonner.tsx"), {
+        "shadcn/no-unknown-classes": ["error", { allow: ["toaster", "toast"] }]
       })
     ];
   }
@@ -1119,7 +1139,6 @@ function presetBoundariesConfig(context) {
 
 // src/configs/plugins.ts
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
 var require2 = createRequire(import.meta.url);
 function presetPluginsConfig(context) {
   const { options, web, css } = context;
@@ -1136,15 +1155,15 @@ function presetPluginsConfig(context) {
     require2.resolve("@eslint-community/eslint-plugin-eslint-comments"),
     {
       name: "arch",
-      specifier: fileURLToPath(new URL("../index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch")
     },
     {
       name: "dillon-anti-slop",
-      specifier: fileURLToPath(new URL("../rules/dillon-anti-slop/index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch/rules/dillon-anti-slop")
     },
     {
       name: "modules",
-      specifier: fileURLToPath(new URL("../rules/module-policy/index.js", import.meta.url))
+      specifier: require2.resolve("oxlint-plugin-arch/rules/module-policy")
     }
   ];
   const settings = {
@@ -1213,9 +1232,9 @@ function presetResolveContext(options) {
         throw new Error("Folder layout mode must be flat or domain.");
       layout[folder] = mode;
     }
-    const folders = Object.keys(layout);
-    for (const [index, folder] of folders.entries()) {
-      const overlaps = folders.slice(0, index).some((other) => folder.startsWith(other + "/") || other.startsWith(folder + "/"));
+    const folders2 = Object.keys(layout);
+    for (const [index, folder] of folders2.entries()) {
+      const overlaps = folders2.slice(0, index).some((other) => folder.startsWith(other + "/") || other.startsWith(folder + "/"));
       if (overlaps) {
         throw new Error("Layout folders must not overlap.");
       }

package/dist/rules/dillon-anti-slop/index.d.ts

@@ -0,0 +1,2 @@
+declare const dillonAntiSlopPlugin: import("@oxlint/plugins").Plugin;
+export default dillonAntiSlopPlugin;

package/dist/rules/dillon-anti-slop/index.js

@@ -349,8 +349,8 @@ function classifyWideningTarget(type, environment) {
   if (alias === undefined)
     return null;
   if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions = aliasSubstitution(alias, unwrapped, new Map);
-    return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, new Set([name])) ? { kind: "generic container" } : null;
+    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
+    return substitutions2 !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions2, new Set([name])) ? { kind: "generic container" } : null;
   }
   const substitutions = aliasSubstitution(alias, unwrapped, new Map);
   if (substitutions === null)

package/dist/rules/dillon-anti-slop/rules/no-chained-type-assertions.d.ts

@@ -0,0 +1 @@
+export declare const noChainedTypeAssertionsRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-conditional-empty-object-spread.d.ts

@@ -0,0 +1 @@
+export declare const noConditionalEmptyObjectSpreadRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-known-value-widening.d.ts

@@ -0,0 +1 @@
+export declare const noKnownValueWideningRule: import("@oxlint/plugins").Rule;

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

@@ -0,0 +1 @@
+export declare const noModuleMockingRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-object-parameters.d.ts

@@ -0,0 +1 @@
+export declare const noObjectParametersRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-reflect-apply.d.ts

@@ -0,0 +1 @@
+export declare const noReflectApplyRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-reflect-get.d.ts

@@ -0,0 +1 @@
+export declare const noReflectGetRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-runtime-typeof.d.ts

@@ -0,0 +1 @@
+export declare const noRuntimeTypeofRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-shape-in-symbol-names.d.ts

@@ -0,0 +1 @@
+export declare const noForbiddenTermInSymbolNamesRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-unknown-parameters.d.ts

@@ -0,0 +1 @@
+export declare const noUnknownParametersRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-unknown-returns.d.ts

@@ -0,0 +1 @@
+export declare const noUnknownReturnsRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-unknown-type-aliases.d.ts

@@ -0,0 +1 @@
+export declare const noUnknownTypeAliasesRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-unsafe-dictionary-type.d.ts

@@ -0,0 +1 @@
+export declare const noUnsafeDictionaryTypeRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/no-widen-then-assert.d.ts

@@ -0,0 +1 @@
+export declare const noWidenThenAssertRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/rules/require-safety-comment-for-type-assertion.d.ts

@@ -0,0 +1 @@
+export declare const requireSafetyCommentForTypeAssertionRule: import("@oxlint/plugins").Rule;

package/dist/rules/dillon-anti-slop/shared/dictionary-types.d.ts

@@ -0,0 +1,19 @@
+import type { ESTree } from "@oxlint/plugins";
+export type UnsafeDictionary = {
+    readonly kind: "unsafe-dictionary";
+    readonly unsafeValue: "any" | "empty-object" | "object" | "union" | "unknown";
+};
+export type WideningTargetKind = "anonymous object" | "generic container" | "object" | "open dictionary" | "unknown";
+export type WideningTarget = {
+    readonly kind: WideningTargetKind;
+};
+export type TypeEnvironment = {
+    readonly aliases: ReadonlyMap<string, ESTree.TSTypeAliasDeclaration>;
+    readonly interfaces: ReadonlyMap<string, readonly ESTree.TSInterfaceDeclaration[]>;
+    readonly shadowedBuiltIns: ReadonlySet<string>;
+};
+export declare function createTypeEnvironment(program: ESTree.Program): TypeEnvironment;
+export declare function classifyUnsafeDictionaryValue(valueType: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+export declare function classifyUnsafeDictionary(type: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+export declare function classifyWideningTarget(type: ESTree.TSType, environment: TypeEnvironment): WideningTarget | null;
+export declare function isKnownEvidenceExpression(expression: ESTree.Expression): boolean;

package/dist/rules/dillon-anti-slop/shared/lexical-type-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { ESTree } from "@oxlint/plugins";
+type VisitorKeys = Readonly<Record<string, readonly string[]>>;
+export declare function lexicalTypeParameterNames(node: ESTree.Node, visitorKeys: VisitorKeys): ReadonlySet<string>;
+export {};

package/dist/rules/dillon-anti-slop/shared/reflect-method.d.ts

@@ -0,0 +1,2 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+export declare function isGlobalReflectMethodCall(sourceCode: SourceCode, callee: ESTree.Expression, methodName: string): boolean;

package/dist/rules/module-policy/domain-constants.d.ts

@@ -0,0 +1,2 @@
+/** Move module data to domain constants; for example, a service's label table belongs in chat.constants.ts. */
+export declare const domainConstants: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/import-boundaries.d.ts

@@ -0,0 +1,2 @@
+/** Reject imports across configured application boundaries, including type-only imports. */
+export declare const importBoundaries: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@oxlint/plugins").Plugin;
+export default _default;

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

@@ -162,7 +162,7 @@ function trivialExpression(node) {
   }
   if (!node.body || node.body.type !== "BlockStatement")
     return null;
-  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
   if (statements.length !== 1)
     return null;
   const statement = statements[0];
@@ -305,7 +305,7 @@ function declarationsIsTrivialFunction(node) {
   if (!node.body || node.body.type !== "BlockStatement") {
     return false;
   }
-  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
   if (statements.length === 0) {
     return true;
   }
@@ -367,8 +367,8 @@ function declarationsInsideForLoop(node) {
 }
 function declarationsNamedFromNode(node) {
   if (node.type === "VariableDeclarator") {
-    const kind = declarationsNamedKind(node, [node.parent]);
-    return kind && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind } : undefined;
+    const kind2 = declarationsNamedKind(node, [node.parent]);
+    return kind2 && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind: kind2 } : undefined;
   }
   const kind = declarationsNamedKind(node, []);
   const name = "id" in node && node.id && "name" in node.id ? node.id.name : undefined;
@@ -1081,32 +1081,32 @@ var serviceFunctions = defineRule3({
     }
     return {
       Program(program) {
-        const options = optionsFirst(context, {});
+        const options2 = optionsFirst(context, {});
         const candidates = declarationsFileLevelFunctionCandidates(program);
         const exported = exportsCollectFunctions(program);
         operation = exported.length === 1 ? exported[0].node : undefined;
-        operations = new Set(options.frontend && !options.singleExport ? exported.map((entry) => entry.node) : operation ? [operation] : []);
-        if (options.frontend && !options.singleExport) {
+        operations = new Set(options2.frontend && !options2.singleExport ? exported.map((entry) => entry.node) : operation ? [operation] : []);
+        if (options2.frontend && !options2.singleExport) {
           for (const method of declarationsPublicServiceMethods(program))
             operations.add(method.node);
         }
-        allowLocalHelpers = options.frontend || (options.allowLocalHelpers ?? false);
-        allowReturnedMethods = options.allowReturnedMethods ?? false;
-        message = options.message ?? (options.frontend ? "Frontend service modules expose public domain operations. Keep operation-only helpers inside their public operation and genuinely shared helpers in domain .utils.ts; file-level private functions are forbidden." : allowLocalHelpers ? "Keep this helper inside the one exported operation; domain .utils.ts is only for genuinely shared logic." : "This service contract does not allow private helpers. Keep its existing factory/operation contract; domain .utils.ts is only for genuinely shared logic. Do not add a fake factory or public helper export.");
-        if (options.singleExport) {
+        allowLocalHelpers = options2.frontend || (options2.allowLocalHelpers ?? false);
+        allowReturnedMethods = options2.allowReturnedMethods ?? false;
+        message = options2.message ?? (options2.frontend ? "Frontend service modules expose public domain operations. Keep operation-only helpers inside their public operation and genuinely shared helpers in domain .utils.ts; file-level private functions are forbidden." : allowLocalHelpers ? "Keep this helper inside the one exported operation; domain .utils.ts is only for genuinely shared logic." : "This service contract does not allow private helpers. Keep its existing factory/operation contract; domain .utils.ts is only for genuinely shared logic. Do not add a fake factory or public helper export.");
+        if (options2.singleExport) {
           const bindings = exportsCollect(program);
           if (bindings.length !== 1 || !operation || bindings[0].default || bindings[0].reExport || bindings[0].typeOnly) {
             context.report({
               node: program,
               messageId: "exports",
               data: {
-                message: options.message ?? "Export exactly one named operation. Do not export helpers, types, constants or re-exports."
+                message: options2.message ?? "Export exactly one named operation. Do not export helpers, types, constants or re-exports."
               }
             });
           }
         }
         for (const candidate of candidates) {
-          if ((options.frontend && !options.singleExport || candidates.length === 1) && exported.some((entry) => entry.name === candidate.name)) {
+          if ((options2.frontend && !options2.singleExport || candidates.length === 1) && exported.some((entry) => entry.name === candidate.name)) {
             continue;
           }
           context.report({ node: candidate.node, messageId: "helper", data: { message, name: candidate.name } });
@@ -1188,8 +1188,8 @@ var domainConstants = defineRule4({
         const declaration = node.parent;
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const" || declaration.parent.type !== "Program" && declaration.parent.type !== "ExportNamedDeclaration")
           return;
-        const options = optionsFirst(context, {});
-        if (node.id.type === "Identifier" && /^[A-Z][A-Z0-9_]+$/.test(node.id.name) || options.includeData && node.init && data(node.init)) {
+        const options2 = optionsFirst(context, {});
+        if (node.id.type === "Identifier" && /^[A-Z][A-Z0-9_]+$/.test(node.id.name) || options2.includeData && node.init && data(node.init)) {
           const file = context.filename.replaceAll("\\", "/");
           const owner = file.includes("/services/") && dirname2(file).split("/").at(-1) !== "services" ? basename(dirname2(file)) : basename(file).split(".")[0].replace(/-(?:action|query)$/, "");
           context.report({
@@ -1285,9 +1285,9 @@ function testTablesRegistration(call, names, functions) {
   if (callee.type === "CallExpression") {
     const builder = astDottedName(callee.callee);
     if (builder?.endsWith(".for") || builder?.endsWith(".each")) {
-      const argument = callee.arguments[0];
-      if (argument && argument.type !== "SpreadElement")
-        table = argument;
+      const argument2 = callee.arguments[0];
+      if (argument2 && argument2.type !== "SpreadElement")
+        table = argument2;
     }
     callee = callee.callee;
   }
@@ -1408,20 +1408,20 @@ var testAssertions = defineRule6({
   createOnce(context) {
     return {
       "Program:exit"(program) {
-        const options = optionsFirst(context, {});
-        const tests = ["test", "it", ...options.additionalTestFunctions ?? []];
+        const options2 = optionsFirst(context, {});
+        const tests = ["test", "it", ...options2.additionalTestFunctions ?? []];
         const functions = new Map;
         const values = new Map;
         const patterns = [
           ...testAssertionFunctions,
           "assert.*",
-          ...options.additionalAssertionFunctions ?? []
+          ...options2.additionalAssertionFunctions ?? []
         ].map(testTablesAssertionPattern);
         const aliases = new Map;
         const shadowed = new Set;
         const calls = [];
         const allowed = new Set;
-        const assertionRoots = new Set([...testAssertionFunctions, ...options.additionalAssertionFunctions ?? []].map((name) => name.split(".")[0]));
+        const assertionRoots = new Set([...testAssertionFunctions, ...options2.additionalAssertionFunctions ?? []].map((name) => name.split(".")[0]));
         astVisit(program, [], (node) => {
           if (node.type === "CallExpression")
             calls.push(node);
@@ -1617,14 +1617,14 @@ var tanstackRuntime = defineRule8({
     }
   },
   createOnce(context) {
-    let options;
+    let options2;
     let file = "";
     let serverFile = false;
     let rscFile = false;
     let shared = false;
     const runtimeIdentifiers = new Set;
     const imports = new Map;
-    const boundaries = [];
+    const boundaries2 = [];
     function imported(node) {
       const entry = imports.get(node.name);
       if (!entry)
@@ -1652,12 +1652,12 @@ var tanstackRuntime = defineRule8({
       return;
     }
     function boundary(position) {
-      return boundaries.filter((entry) => position >= entry.start && position < entry.end).sort((a, b) => b.start - a.start)[0];
+      return boundaries2.filter((entry) => position >= entry.start && position < entry.end).sort((a, b) => b.start - a.start)[0];
     }
     function serverPosition(position, staticImport = false) {
       const entry = boundary(position);
       if (entry)
-        return entry.side === "server" && (!staticImport || entry.kind !== "createIsomorphicFn" || options.rpcClients.includes(file));
+        return entry.side === "server" && (!staticImport || entry.kind !== "createIsomorphicFn" || options2.rpcClients.includes(file));
       return serverFile;
     }
     function report(node, source, reason) {
@@ -1666,11 +1666,11 @@ var tanstackRuntime = defineRule8({
     function check(node, source, typeOnly, reExport = false, renderer) {
       if (typeOnly)
         return;
-      const target = boundaryResolveTarget(options, file, source);
+      const target = boundaryResolveTarget(options2, file, source);
       const matches = (values) => values?.some((value) => source === value || source.startsWith(value + "/"));
-      const backend = options.backend.some((path) => target.startsWith(path + "/")) || options.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(options.serverImports);
-      const client = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || /^(?:react-dom\/client|@tanstack\/(?:react|solid|vue)-start\/client-only)(?:\/|$)/.test(source) || matches(options.clientImports);
+      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);
       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"))
@@ -1745,14 +1745,14 @@ var tanstackRuntime = defineRule8({
     }
     return {
       Program(program) {
-        options = optionsFirst(context);
+        options2 = optionsFirst(context);
         file = context.filename.replaceAll("\\", "/");
         serverFile = /\.server\.[cm]?[jt]sx?$/.test(file);
         rscFile = /\.rsc\.[cm]?[jt]sx?$/.test(file);
-        shared = /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options.web.some((path) => file.startsWith(path + "/lib/"));
+        shared = /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options2.web.some((path) => file.startsWith(path + "/lib/"));
         runtimeIdentifiers.clear();
         imports.clear();
-        boundaries.length = 0;
+        boundaries2.length = 0;
         for (const statement of program.body) {
           if (statement.type !== "ImportDeclaration" || statement.importKind === "type")
             continue;
@@ -1795,7 +1795,7 @@ var tanstackRuntime = defineRule8({
           const side = kind === "createServerOnlyFn" || kind === "createServerFn" && method === "handler" || ["createIsomorphicFn", "createMiddleware"].includes(kind ?? "") && method === "server" ? "server" : kind === "createClientOnlyFn" || ["createIsomorphicFn", "createMiddleware"].includes(kind ?? "") && method === "client" ? "client" : undefined;
           const callback = node.arguments[0];
           if (kind && side && callback && (callback.type === "FunctionExpression" || callback.type === "ArrowFunctionExpression"))
-            boundaries.push({ start: callback.start, end: callback.end, side, kind });
+            boundaries2.push({ start: callback.start, end: callback.end, side, kind });
         });
       },
       ImportDeclaration(node) {
@@ -1829,7 +1829,7 @@ var tanstackRuntime = defineRule8({
       ImportExpression(node) {
         if (node.source.type === "Literal" && typeof node.source.value === "string")
           check(node, node.source.value, false);
-        else if (!options.allowComputedImportsIn?.includes(file))
+        else if (!options2.allowComputedImportsIn?.includes(file))
           context.report({ node, messageId: "computed" });
       },
       MemberExpression(node) {
@@ -1874,19 +1874,19 @@ var importBoundaries = defineRule9({
   },
   createOnce(context) {
     function check(node, source, typeOnly, reExport = false) {
-      const options = optionsFirst(context);
+      const options2 = optionsFirst(context);
       const file = context.filename.replaceAll("\\", "/");
       const contains = (directory, candidate) => candidate === directory || candidate.startsWith(`${directory}/`);
-      const roots = [...options.web, ...options.backend].sort((a, b) => b.length - a.length);
+      const roots = [...options2.web, ...options2.backend].sort((a, b) => b.length - a.length);
       const owner = roots.find((path) => contains(path, file));
-      const web = owner && options.web.includes(owner) ? owner : undefined;
-      const target = boundaryResolveTarget(options, file, source);
-      const backendImport = options.backend.some((path) => contains(path, target)) || options.backendPackages.some((name) => source === name || source.startsWith(`${name}/`));
+      const web = owner && options2.web.includes(owner) ? owner : undefined;
+      const target = boundaryResolveTarget(options2, file, source);
+      const backendImport = options2.backend.some((path) => contains(path, target)) || options2.backendPackages.some((name) => source === name || source.startsWith(`${name}/`));
       let reason;
-      if (web && backendImport && !options.publicEntrypoints.includes(source)) {
+      if (web && backendImport && !options2.publicEntrypoints.includes(source)) {
         reason = "frontend code uses only public backend entry points";
       }
-      if ((Array.isArray(options.packages) ? options.packages : [options.packages]).some((path) => path && contains(path, file)) && (backendImport || options.web.some((path) => contains(path, target)) || options.appPackages.some((name) => source === name || source.startsWith(`${name}/`)))) {
+      if ((Array.isArray(options2.packages) ? options2.packages : [options2.packages]).some((path) => path && contains(path, file)) && (backendImport || options2.web.some((path) => contains(path, target)) || options2.appPackages.some((name) => source === name || source.startsWith(`${name}/`)))) {
         reason = "shared packages do not import app internals";
       }
       if (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) && !typeOnly) {
@@ -1898,7 +1898,7 @@ var importBoundaries = defineRule9({
       if (file.endsWith(".client.ts") && !typeOnly && /^(react|react-dom)(\/|$)/.test(source)) {
         reason = "client services are React-free; use hooks for React behavior";
       }
-      if (options.fileRoles?.length) {
+      if (options2.fileRoles?.length) {
         const targetOwner = roots.find((path) => contains(path, target));
         const domain = (path, appRoot) => {
           const relative = path.slice(appRoot.length + 1);
@@ -1911,7 +1911,7 @@ var importBoundaries = defineRule9({
         };
         const sameDomain = owner && targetOwner && owner === targetOwner && domain(file, owner) && domain(file, owner) === domain(target, targetOwner);
         const targetStem = target.replace(/\.[cm]?[jt]sx?$/, "");
-        const concept = options.fileRoles.some((role) => targetStem.endsWith(`.${role}`));
+        const concept = options2.fileRoles.some((role) => targetStem.endsWith(`.${role}`));
         const publicSurface = /\.(?:service|client|server|rsc|utils)$/.test(targetStem) && !/\/(?:[^/]+)-(?:action|query)\./.test(targetStem);
         const privateTarget = concept || targetOwner && domain(target, targetOwner) && !publicSurface && !/\.(?:types|constants)$/.test(targetStem);
         if (privateTarget && !sameDomain) {
@@ -1921,11 +1921,11 @@ var importBoundaries = defineRule9({
           reason = "public service and utility surfaces must not re-export private domain internals";
         }
       }
-      if (options.portableLib && web && contains(`${web}/lib`, file)) {
+      if (options2.portableLib && web && contains(`${web}/lib`, file)) {
         const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
         const appService = roots.some((path) => contains(`${path}/services`, portableTarget));
-        const backendTarget = options.backend.some((path) => contains(path, portableTarget));
-        const appPackage = options.appPackages.some((name) => source === name || source.startsWith(`${name}/`));
+        const backendTarget = options2.backend.some((path) => contains(path, portableTarget));
+        const appPackage = options2.appPackages.some((name) => source === name || source.startsWith(`${name}/`));
         const appType = roots.some((path) => contains(`${path}/types`, portableTarget));
         const stem = basename2(file).replace(/\.[cm]?[jt]sx?$/, "").replace(/\.utils$/, "");
         const ownType = typeOnly && !reExport && portableTarget.replace(/\.[cm]?[jt]sx?$/, "") === `${web}/types/${stem}.types`;
@@ -1972,9 +1972,9 @@ var importBoundaries = defineRule9({
         }
       },
       TSImportType(node) {
-        const options = optionsFirst(context);
+        const options2 = optionsFirst(context);
         const file = context.filename.replaceAll("\\", "/");
-        if (options.portableLib && options.web.some((path) => file.startsWith(`${path}/lib/`))) {
+        if (options2.portableLib && options2.web.some((path) => file.startsWith(`${path}/lib/`))) {
           check(node, node.source.value, true);
         }
       }

package/dist/rules/module-policy/memoization.d.ts

@@ -0,0 +1,2 @@
+/** Reject React memoization imports and member calls while leaving unrelated cache.memo calls alone. */
+export declare const memoization: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/reasoned-directives.d.ts

@@ -0,0 +1,2 @@
+/** Require a rule name and a reason in lint disables, such as no-console -- CLI output. */
+export declare const directives: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/service-functions.d.ts

@@ -0,0 +1,2 @@
+/** Keep backend operations strict; frontend modules may expose several operations with helpers nested inside them. */
+export declare const serviceFunctions: import("@oxlint/plugins").Rule;

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

@@ -0,0 +1,2 @@
+/** Only the matching factory-derived Service alias stays local; ChatDeps belongs in domain types. */
+export declare const serviceTypes: import("@oxlint/plugins").Rule;

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

@@ -0,0 +1,2 @@
+/** Check direct runtime dependencies and imported TanStack boundaries; compilation still owns graph isolation. */
+export declare const tanstackRuntime: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/test-assertions.d.ts

@@ -0,0 +1,2 @@
+/** Check assertion presence and placement, including assertions called through static table rows. */
+export declare const testAssertions: import("@oxlint/plugins").Rule;

package/dist/rules/module-policy/test-modifiers.d.ts

@@ -0,0 +1,2 @@
+/** Reject focused, skipped and placeholder tests, including renamed imports such as check.only. */
+export declare const testModifiers: import("@oxlint/plugins").Rule;

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

@@ -0,0 +1,34 @@
+export interface ModuleBoundaryOptions {
+    web: string[];
+    backend: string[];
+    packages: string | string[];
+    fileRoles?: string[];
+    portableLib?: boolean;
+    backendPackages: string[];
+    appPackages: string[];
+    aliases: Record<string, string>;
+    publicEntrypoints: string[];
+}
+export interface ModuleServiceFunctionsOptions {
+    frontend?: boolean;
+    allowLocalHelpers?: boolean;
+    allowReturnedMethods?: boolean;
+    singleExport?: boolean;
+    message?: string;
+}
+export interface ModuleDomainConstantsOptions {
+    allowServiceMethods?: boolean;
+    includeData?: boolean;
+}
+export interface ModuleRuntimeOptions extends Pick<ModuleBoundaryOptions, 'web' | 'backend' | 'aliases' | 'backendPackages'> {
+    rpcClients: string[];
+    serverImports?: string[];
+    clientImports?: string[];
+    allowComputedImportsIn?: string[];
+}
+export interface ModuleTestModifiersOptions {
+    additionalTestFunctions?: string[];
+}
+export interface ModuleTestAssertionsOptions extends ModuleTestModifiersOptions {
+    additionalAssertionFunctions?: string[];
+}

package/dist/types/test-analysis.types.d.ts

@@ -0,0 +1,11 @@
+import type { ESTree } from '@oxlint/plugins';
+import type { AstRuntimeFunction } from '../utils/helpers/ast.ts';
+export interface TestRegistration {
+    call: ESTree.CallExpression;
+    callback: AstRuntimeFunction;
+    table?: ESTree.Expression;
+}
+export interface TestTableRow {
+    bindings: Map<ESTree.Node, AstRuntimeFunction>;
+    callbacks: AstRuntimeFunction[];
+}