oxlint-plugin-arch 0.13.0 → 0.13.1

package/dist/preset/preset.constants.d.ts

@@ -73,6 +73,10 @@ export declare const presetEffectImports: {
     'ts-pattern': string;
     dayjs: string;
 };
+export declare const presetEffectServerImports: {
+    ai: string;
+    '@ai-sdk/**': string;
+};
 export declare const presetRecipeMark: unique symbol;
 export declare const presetDetectBackend: string[];
 export declare const presetDetectSkip: string[];

package/dist/preset/preset.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/preset/preset.ts
-import { globSync } from "node:fs";
+import { globSync as globSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { matchesGlob as matchesGlob2, posix as posix9 } from "node:path";
 
@@ -511,6 +511,10 @@ var presetEffectImports = {
   "ts-pattern": "Use effect/Match.",
   dayjs: "Use effect/DateTime."
 };
+var presetEffectServerImports = {
+  ai: "Use effect/ai.",
+  "@ai-sdk/**": "Use effect/ai."
+};
 var presetRecipeMark = Symbol("recipe");
 var presetDetectBackend = ["@orpc/server", "hono", "kysely", "drizzle-orm", "express", "fastify", "elysia"];
 var presetDetectSkip = ["node_modules", "dist", "build", "coverage", "public", ".output", ".next", ".vinext", ".turbo", ".wrangler", "target"];
@@ -588,7 +592,7 @@ var presetTemplates = {
 };
 
 // src/preset/preset.utils.ts
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, globSync, readFileSync, statSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { posix, resolve } from "node:path";
 class PresetError extends Error {
@@ -703,6 +707,23 @@ function presetIntersect(glob, scope) {
 function presetGlobEscape(path) {
   return path.replaceAll(/[[\]]/g, (bracket) => `[${bracket}]`);
 }
+function presetFileOverlaps(root, build, keys) {
+  const matched = new Map;
+  for (const key of keys) {
+    for (const path of globSync(key.pattern, { cwd: root, exclude: (name) => posix.basename(name) === "node_modules" })) {
+      matched.set(path, [...matched.get(path) ?? [], key]);
+    }
+  }
+  const reach = new Map(keys.map((key) => [key, [...matched.values()].filter((found) => found.includes(key)).length]));
+  const merged = [...matched].flatMap(([path, found]) => {
+    if (found.length < 2) {
+      return [];
+    }
+    const ordered = found.toSorted((left, right) => (reach.get(right) ?? 0) - (reach.get(left) ?? 0));
+    return [build(presetGlobEscape(path), ordered.reduce((folder, key) => Object(presetMerge(folder, key.folder)), {}))];
+  });
+  return [...keys, ...merged];
+}
 function presetAliases(root, aliases) {
   return Object.fromEntries(Object.entries(aliases ?? {}).map(([alias, path]) => [alias.replace(/\/$/, ""), resolve(root, path)]));
 }
@@ -848,7 +869,7 @@ function presetEffectServerKeys(at) {
       rules: {
         "arch/types-declarations": ["error", { modules: true }],
         "arch/types-inline": ["error", { variables: true, assertions: true, arguments: true }],
-        "arch/comments-code": ["error", { why: false, jsdoc: true, allow: ["^\\s*SAFETY: "] }]
+        "arch/comments-code": ["error", { why: false, jsdoc: true, allow: ["^\\s*SAFETY: "], steps: true }]
       }
     },
     [at("domains")]: {
@@ -884,8 +905,8 @@ function presetEffectServerKeys(at) {
       rules: { "arch/files-exports": ["error", { stem: "folder", patterns: ["{domain}Query[A-Z]\\w*"], types: true }] }
     },
     [at("domains/*/*.constants.ts")]: { rules: { "arch/files-no-functions": ["error", { reexports: false }] } },
-    [at("domains/*/*.layer.ts")]: { rules: { "arch/effect-layer-file": "error" } },
-    [at("domains/*/*.driver.ts")]: { rules: { "arch/effect-layer-file": "error" } },
+    [at("domains/*/*.layer.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
+    [at("domains/*/*.driver.ts")]: { rules: { "arch/effect-layer-file": ["error", { suffix: "Layer" }] } },
     [at("domains/*/*.workflows.ts")]: {
       deny: {
         calls: presetEffectWorkflowCalls,
@@ -956,9 +977,10 @@ function presetEffectUnit(root, key, value) {
   const keys = server || contract ? presetFilled(server ? presetEffectServerKeys(at) : presetEffectContractKeys(at), presetEffectExists(root, key)) : {};
   const errors = Object.fromEntries(presetEffectErrors.map((name) => [name, "Tagged errors live in <d>.errors.ts."]));
   const placement = server || contract ? { types: { placement: false } } : {};
+  const imports = server || contract ? { ...presetEffectImports, ...presetEffectServerImports } : presetEffectImports;
   return {
     ...keys,
-    ".": presetMerge({ ...placement, deny: { imports: presetEffectImports, calls: errors } }, keys["."] ?? {}),
+    ".": presetMerge({ ...placement, deny: { imports, calls: errors } }, keys["."] ?? {}),
     [at("**/*.errors.ts")]: { deny: { calls: Object.fromEntries(presetEffectErrors.map((name) => [name, false])) } }
   };
 }
@@ -1500,17 +1522,19 @@ var effectGroup = (project, settings) => {
       "arch/code-switch": ["error", { message: "Branch with Match." }],
       "arch/naming-exports": "off",
       "arch/code-function-nesting": ["error", { max: 4 }],
-      "arch/code-inline": ["error", { max, nesting: 2, keep: ["^[A-Z]", "^layer"], allow: "^(?:decode|encode)[A-Z]", services: ["of"] }],
+      "arch/code-inline": ["error", { max, nesting: 2, callbacks: true, keep: ["^[A-Z]", "^layer"], allow: "^(?:decode|encode)[A-Z]", services: ["of"] }],
       "arch/code-yield-argument": "error",
       "arch/effect-layers": "error",
       "arch/effect-merge-pipe": "error",
       "arch/effect-values-first": "error",
       "arch/layout-arrow-body": ["error", { max }],
-      "arch/layout-call-arguments": ["error", { split: false, hug: { max }, join: { max, nesting: 2, keep: ["Layer.mergeAll"] } }],
-      "arch/layout-call-depth": ["error", { max: 2 }],
+      "arch/layout-call-arguments": ["error", { split: false, pipe: { min: 2 }, hug: { max }, join: { max, nesting: 2, keep: ["Layer.mergeAll"] } }],
+      "arch/layout-call-depth": ["error", { max: 2, callbacks: true }],
       "arch/layout-items": "error",
+      "arch/layout-object": ["error", { min: 3, scope: "call-args", params: true, nested: true, siblings: true, inner: 2 }],
       "arch/layout-pipe": "error",
-      "arch/layout-ternary": ["error", { fit: false, branch: { max: 3 } }]
+      "arch/layout-ternary": ["error", { max: 100, branch: { max: 3 } }],
+      "arch/layout-type-arguments": ["error", { min: 3 }]
     }),
     presetOverride(files, {
       "arch/code-justified-call": [
@@ -1978,7 +2002,10 @@ var shadcnGroup = (project) => {
 
 // src/preset/groups/sql.ts
 var sqlGroup = (project) => [
-  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), { "arch/backend-sql-like": "error" })
+  presetOverride(presetServiceScopes(project.serviceFolders, project.serviceRoots, "**/*.ts"), {
+    "arch/backend-sql-like": "error",
+    "arch/layout-chain": ["error", { groups: [{ min: 3, methods: ["selectFrom", "insertInto", "updateTable", "deleteFrom", "mergeInto", "with"] }] }]
+  })
 ];
 
 // src/preset/groups/style.ts
@@ -2079,6 +2106,9 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/preset/groups/tests.ts
 var testsGroup = (project, settings) => {
@@ -2528,7 +2558,11 @@ function presetProject(config) {
   if (dead) {
     throw new PresetError(`Folder \`${dead.key}\` sits inside the skipped folder \`${dead.parent?.key}\`.`);
   }
-  const fileKeys = fileEntries.flatMap(([key, value]) => {
+  const keyFor = (pattern, folder) => {
+    const reached = live.filter((scope) => presetIntersect(pattern, scope.key).length > 0).map((scope) => ({ key: scope.key, parent: scope, depth: scope.depth, folder, effective: presetEffective(folder, scope.effective) }));
+    return { pattern, folder, scopes: reached };
+  };
+  const fileKeys = presetFileOverlaps(root, keyFor, fileEntries.flatMap(([key, value]) => {
     if (value === false) {
       return [];
     }
@@ -2540,10 +2574,8 @@ function presetProject(config) {
     if (Object(folder.layout).operations !== undefined) {
       throw new PresetError(`Set layout.operations on an app or package folder, not on \`${key}\`.`);
     }
-    const pattern = presetGlobEscape(key);
-    const reached = live.filter((scope) => presetIntersect(pattern, scope.key).length > 0).map((scope) => ({ key: scope.key, parent: scope, depth: scope.depth, folder, effective: presetEffective(folder, scope.effective) }));
-    return [{ pattern, folder, scopes: reached }];
-  });
+    return [keyFor(presetGlobEscape(key), folder)];
+  }));
   const units = presetUnits(root, scopes, ignored);
   const unitKeys = new Set(units.map((unit) => unit.scope.key));
   const misplaced = live.find((scope) => !unitKeys.has(scope.key) && Object(scope.folder.layout).operations !== undefined);
@@ -2845,7 +2877,7 @@ function preset(config) {
   const level = presetLevel(root);
   const expanded = new Map;
   const expand = (fileKey) => {
-    const paths = expanded.get(fileKey.pattern) ?? globSync(fileKey.pattern, { cwd: project.root, exclude: (path) => posix9.basename(path) === "node_modules" });
+    const paths = expanded.get(fileKey.pattern) ?? globSync2(fileKey.pattern, { cwd: project.root, exclude: (path) => posix9.basename(path) === "node_modules" });
     expanded.set(fileKey.pattern, paths);
     return paths;
   };

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

@@ -11,6 +11,7 @@ export declare function presetSeverity(rules: PresetTypes.PresetRules, level: Pr
 export declare function presetPackageName(root: string, directory: string): string | undefined;
 export declare function presetIntersect(glob: string, scope: string): string[];
 export declare function presetGlobEscape(path: string): string;
+export declare function presetFileOverlaps(root: string, build: (pattern: string, folder: PresetTypes.PresetFolder) => PresetTypes.PresetFileKey, keys: PresetTypes.PresetFileKey[]): PresetTypes.PresetFileKey[];
 export declare function presetAliases(root: string, aliases: Record<string, string> | undefined): Record<string, string>;
 export declare function presetRuntime(project: PresetTypes.PresetProject, settings: Required<PresetTypes.PresetFrameworkOptions>, framework: PresetTypes.PresetFramework, rule: string): OxlintOverride[];
 export declare function presetManifest(root: string, directory: string): PresetTypes.PresetManifest;

package/dist/rules/layout/layout-type-arguments.d.ts

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

package/dist/types/boundaries.types.d.ts

@@ -6,13 +6,27 @@ export interface BoundariesOptions {
     roles?: string[];
     surfaces?: string[];
     services?: string[];
-    portable?: boolean;
+    portable?: boolean | string;
+    conventions?: BoundariesConventions;
     backendPackages: string[];
     appPackages: string[];
     aliases: Record<string, string>;
     entrypoints: string[];
     uiPackages?: string[];
 }
+export interface BoundariesConventions {
+    services?: string;
+    registry?: string;
+    types?: string;
+    lib?: string;
+    contracts?: string[];
+    implementations?: string[];
+    implementationFolders?: string[];
+    operations?: string[];
+    operationFolders?: string[];
+    domainFiles?: string[];
+    clients?: string[];
+}
 export interface BoundariesImport {
     options: BoundariesOptions;
     file: string;
@@ -25,7 +39,18 @@ export interface BoundariesImport {
     web?: string;
     backendImport: boolean;
 }
+export interface BoundariesRuntimeConventions {
+    server?: string[];
+    rsc?: string[];
+    actions?: string[];
+    client?: string[];
+    clientOnly?: string[];
+    hooks?: string[];
+    shared?: string[];
+    lib?: string;
+}
 export interface BoundariesNextOptions extends Partial<Pick<BoundariesOptions, 'web' | 'backend' | 'aliases' | 'backendPackages'>> {
+    conventions?: BoundariesRuntimeConventions;
     server?: string[];
     client?: string[];
     dynamic?: string[];

package/dist/types/code.types.d.ts

@@ -69,6 +69,7 @@ export interface CodeTrivialFunctionsGuardState {
 export interface CodeInlineOptions {
     max?: number;
     nesting?: number;
+    callbacks?: boolean;
     allow?: OptionsPattern;
     keep?: OptionsPattern;
     services?: string[];

package/dist/types/comments.types.d.ts

@@ -4,6 +4,7 @@ export interface CommentsOptions {
     allow?: string[];
     jsdoc?: boolean;
     members?: 'off' | 'also' | 'only';
+    steps?: boolean;
 }
 export interface CommentsLines {
     starts: number[];

package/dist/types/dillon-anti-slop.types.d.ts

@@ -53,3 +53,9 @@ export interface DillonAntiSlopConstBinding {
     readonly declarator: ESTree.VariableDeclarator;
     readonly init: ESTree.Expression;
 }
+export interface DillonAntiSlopSymbolNamesOptions {
+    terms?: string[];
+}
+export interface DillonAntiSlopSafetyCommentOptions {
+    comment?: string;
+}

package/dist/types/effect.types.d.ts

@@ -22,6 +22,7 @@ export interface EffectLayerFileOptions {
     layer?: string;
     make?: string;
     prefix?: string;
+    suffix?: string;
     builders?: string[];
     layers?: OptionsPattern;
     services?: OptionsPattern;

package/dist/types/layout.types.d.ts

@@ -9,6 +9,10 @@ export interface LayoutCallArgumentsOptions {
     min?: number;
     indent?: SourceIndent;
     split?: boolean;
+    pipe?: {
+        min: number;
+        methods?: string[];
+    };
     hug?: {
         max: number;
     };
@@ -55,6 +59,10 @@ export interface LayoutObjectOptions {
     min?: number;
     scope?: LayoutObjectScope;
     indent?: SourceIndent;
+    params?: boolean;
+    nested?: boolean;
+    siblings?: boolean;
+    inner?: number;
     join?: {
         max: number;
         keep?: string[];
@@ -66,6 +74,13 @@ export interface LayoutPaddingOptions {
     multiline?: boolean;
 }
 export type LayoutPaddingKind = 'variable' | 'block' | 'control' | 'return' | 'other';
+export interface LayoutPipeOptions {
+    methods?: string[];
+}
+export interface LayoutTypeArgumentsOptions {
+    min?: number;
+    indent?: SourceIndent;
+}
 export interface LayoutTernaryOptions {
     max?: number;
     indent?: SourceIndent;
@@ -79,6 +94,7 @@ export interface LayoutItemsOptions {
 }
 export interface LayoutCallDepthOptions {
     max?: number;
+    callbacks?: boolean;
 }
 export interface LayoutArrowBodyOptions {
     max?: number;

package/dist/types/naming.types.d.ts

@@ -49,4 +49,8 @@ export interface NamingFolderOptions {
     prefixes?: string[];
     after?: string;
 }
+export interface NamingTypesOptions {
+    pattern?: OptionsPattern;
+    message?: string;
+}
 export {};

package/dist/types/react.types.d.ts

@@ -17,3 +17,16 @@ export interface ReactPropsTarget {
     fn: AstFunction;
     typeArgument?: ESTree.TSType;
 }
+export interface ReactDynamicClassesOptions {
+    attributes?: string[];
+    message?: string;
+}
+export interface ReactEmptyEffectOptions {
+    hooks?: string[];
+    message?: string;
+}
+export interface ReactMemoOptions {
+    names?: string[];
+    sources?: string[];
+    message?: string;
+}

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

@@ -30,3 +30,7 @@ export interface TypesDuplicateOptions {
     structs?: string[];
     min?: number;
 }
+export interface TypesLocalAliasOptions {
+    allow?: OptionsPattern;
+    message?: string;
+}

package/dist/utils/ast.utils.d.ts

@@ -20,6 +20,5 @@ export declare function astSelectorRule(selector: string, message: string): impo
 export declare function astIsOneLine(node: ESTree.Node): boolean;
 export declare function astIsInlineFunction(node: ESTree.Node): node is AstFunction;
 export declare function astIsCall(node: ESTree.Node): node is AstCall;
-export declare function astIsPipe(node: AstCall): boolean;
 export declare function astSome(value: unknown, test: (node: ESTree.Node) => boolean, enter?: (node: ESTree.Node) => boolean): boolean;
-export declare function astCallDepth(value: unknown): number;
+export declare function astCallDepth(value: unknown, callbacks?: boolean): number;

package/dist/utils/boundaries.utils.d.ts

@@ -1,5 +1,10 @@
-import type { BoundariesOptions } from '../types/boundaries.types.ts';
+import type { BoundariesOptions, BoundariesRuntimeConventions } from '../types/boundaries.types.ts';
 import type * as PluginsTypes from '@oxlint/plugins';
+export declare function boundariesConventionsFor(options: {
+    conventions?: BoundariesRuntimeConventions;
+}): Required<BoundariesRuntimeConventions>;
+export declare function boundariesHasSuffix(suffixes: readonly string[], path: string, optionalExtension?: boolean): boolean;
+export declare function boundariesIsClientOnly(conventions: Required<BoundariesRuntimeConventions>, target: string): boolean;
 export declare const boundariesServerGlobals: string[];
 export declare const boundariesBrowserGlobals: string[];
 export declare const boundariesRuntimeProperties: {
@@ -63,6 +68,65 @@ export declare const boundariesRuntimeProperties: {
             type: string;
         };
     };
+    conventions: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            server: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            rsc: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            actions: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            client: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            clientOnly: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            hooks: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            shared: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            lib: {
+                type: string;
+                minLength: number;
+            };
+        };
+    };
 };
 export declare const boundariesServerPackages: string[];
 export declare const boundariesRuntimeMessages: {
@@ -75,11 +139,15 @@ export declare function boundariesExportVisitors(check: (node: PluginsTypes.ESTr
 };
 export declare function boundariesLiteralSource(node: PluginsTypes.ESTree.ImportExpression): string | undefined;
 export declare function boundariesReport(context: PluginsTypes.Context, node: PluginsTypes.ESTree.Node, source: string, reason: string): void;
-export declare function boundariesImportExpression(context: PluginsTypes.Context, node: PluginsTypes.ESTree.ImportExpression, allowComputed: boolean, check: (source: string) => void): void;
-export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, file: string): boolean;
+export declare function boundariesRuntimeImportVisitors(context: PluginsTypes.Context, check: (node: PluginsTypes.ESTree.Node, source: string, typeOnly: boolean, reExport: boolean) => void, allowComputed: () => boolean): {
+    ExportNamedDeclaration(node: PluginsTypes.ESTree.ExportNamedDeclaration): void;
+    ExportAllDeclaration(node: PluginsTypes.ESTree.ExportAllDeclaration): void;
+    ImportExpression(node: PluginsTypes.ESTree.ImportExpression): void;
+};
+export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, conventions: Required<BoundariesRuntimeConventions>, file: string): boolean;
 export declare function boundariesDeclaredVariable(start: PluginsTypes.Scope | null, name: string): PluginsTypes.Variable | null;
 export declare function boundariesMatchesImport(prefixes: string[] | undefined, source: string): boolean;
 export declare function boundariesIsBackendImport(options: Pick<BoundariesOptions, 'backend' | 'backendPackages'>, target: string, source: string): boolean;
 export declare function boundariesIsServerPlatformImport(source: string, packages: readonly string[]): boolean;
 export declare function boundariesMemberName(node: PluginsTypes.ESTree.Node | null | undefined): string | null;
-export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string): string;
+export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string, services?: string): string;

package/dist/utils/options.utils.d.ts

@@ -9,3 +9,4 @@ export declare function optionsPatternsTest(patterns: RegExp[], value: string):
 export declare function optionsGlob(pattern: string): RegExp;
 export declare function optionsPatternLabel(pattern: OptionsPattern | undefined): string;
 export declare function optionsAssertMockingApis(patterns: string[]): void;
+export declare function optionsEscape(value: string): string;

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

@@ -152,6 +152,9 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/utils/ast.utils.ts
 var astSkippedKeys = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
@@ -339,9 +342,6 @@ function astIsInlineFunction(node) {
 function astIsCall(node) {
   return node.type === "CallExpression" || node.type === "NewExpression";
 }
-function astIsPipe(node) {
-  return node.callee.type === "MemberExpression" && astMemberName(node.callee) === "pipe";
-}
 function astChildren(node) {
   return Object.entries(node).filter(([key]) => !astSkippedKeys.has(key)).map(([, child]) => child);
 }
@@ -351,17 +351,20 @@ function astSome(value, test, enter = () => true) {
   }
   return astIsNode(value) && (test(value) || enter(value) && astChildren(value).some((child) => astSome(child, test, enter)));
 }
-function astCallDepth(value) {
+function astCallDepth(value, callbacks = false) {
   if (Array.isArray(value)) {
-    return Math.max(0, ...value.map(astCallDepth));
+    return Math.max(0, ...value.map((item) => astCallDepth(item, callbacks)));
   }
-  if (!astIsNode(value) || astIsInlineFunction(value)) {
+  if (!astIsNode(value)) {
     return 0;
   }
+  if (astIsInlineFunction(value)) {
+    return callbacks ? astCallDepth(value.body, callbacks) : 0;
+  }
   if (astIsCall(value)) {
-    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments), astCallDepth(value.callee));
+    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments, callbacks), astCallDepth(value.callee, callbacks));
   }
-  return astCallDepth(astChildren(value));
+  return astCallDepth(astChildren(value), callbacks);
 }
 
 // src/vendor/dillon-anti-slop/shared/type-reference-name.ts
@@ -1247,7 +1250,6 @@ var noRuntimeTypeofRule = defineRule8({
 
 // src/vendor/dillon-anti-slop/rules/no-shape-in-symbol-names.ts
 import { defineRule as defineRule9 } from "@oxlint/plugins";
-var FORBIDDEN_SYMBOL_NAME = "shape";
 function namesForeignApi(node) {
   const parent = node.parent;
   if (!parent) {
@@ -1279,22 +1281,29 @@ var noForbiddenTermInSymbolNamesRule = defineRule9({
     docs: {
       description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.'
     },
+    schema: [{ type: "object", additionalProperties: false, properties: { terms: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 } } }],
     messages: {
-      forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.'
+      forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "{{term}}" describes structure rather than ownership.'
     }
   },
   createOnce(context) {
+    let terms = [];
     const reportForbiddenSymbolName = (node) => {
-      if (!node.name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME) || namesForeignApi(node)) {
+      const lower = node.name.toLowerCase();
+      const term = terms.find((candidate) => lower.includes(candidate));
+      if (term === undefined || namesForeignApi(node)) {
         return;
       }
       context.report({
         node,
         messageId: "forbiddenSymbolName",
-        data: { name: node.name }
+        data: { name: node.name, term }
       });
     };
     return {
+      before() {
+        terms = (optionsFirst(context, {}).terms ?? ["shape"]).map((term) => term.toLowerCase());
+      },
       Identifier: reportForbiddenSymbolName,
       PrivateIdentifier: reportForbiddenSymbolName,
       JSXIdentifier: reportForbiddenSymbolName
@@ -1750,18 +1759,22 @@ var requireSafetyCommentForTypeAssertionRule = defineRule15({
     docs: {
       description: "Require a nearby SAFETY comment for every TypeScript type assertion except const assertions."
     },
+    schema: [{ type: "object", additionalProperties: false, properties: { comment: { type: "string", minLength: 1 } } }],
     messages: {
-      missingSafetyComment: "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement."
+      missingSafetyComment: "This type assertion has no `{{comment}}` justification. State the checked invariant immediately before the assertion or its containing statement."
     }
   },
   createOnce(context) {
+    let comment = "SAFETY:";
+    let marker = /(?<![\p{L}\p{N}_])SAFETY\s*:/u;
     const checkAssertion = (node) => {
       if (expressionsIsConstAssertion(node)) {
         return;
       }
       let current = node;
+      const justified = (candidate) => candidate.end <= node.start && marker.test(candidate.value);
       for (;; ) {
-        if (context.sourceCode.getCommentsBefore(current).some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))) {
+        if (context.sourceCode.getCommentsBefore(current).some(justified)) {
           return;
         }
         const parent = current.parent;
@@ -1770,9 +1783,18 @@ var requireSafetyCommentForTypeAssertionRule = defineRule15({
         }
         current = parent;
       }
-      context.report({ node, messageId: "missingSafetyComment" });
+      context.report({
+        node,
+        messageId: "missingSafetyComment",
+        data: { comment }
+      });
     };
     return {
+      before() {
+        comment = optionsFirst(context, {}).comment ?? "SAFETY:";
+        const word = optionsEscape(comment.replace(/:\s*$/, ""));
+        marker = new RegExp(`(?<![\\p{L}\\p{N}_])${word}\\s*:`, "u");
+      },
       TSAsExpression: checkAssertion,
       TSTypeAssertion: checkAssertion
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -14,6 +14,9 @@ The TanStack preset selects the enabled rules; this directory implements them
 and is not a separate preset. Upstream intentionally distributes source for
 vendoring and does not publish an official npm package.
 
+Local options: `terms` on `no-shape-in-symbol-names` and `comment` on
+`require-safety-comment-for-type-assertion`; their defaults keep upstream behavior.
+
 Local behavior fixes recognize `SAFETY:` comments on exported declarations and
 export-default assertions, while retaining statement boundaries for other
 assertions.