oxlint-plugin-arch 0.12.4 → 0.12.5

package/dist/index.js

@@ -510,14 +510,15 @@ var backendRegistry = defineRule3({
           registry: { type: "string", minLength: 1 },
           services: { type: "string", minLength: 1 },
           skip: { type: "array", items: { type: "string" } },
-          object: { type: "string", minLength: 1 }
+          object: { type: "string", minLength: 1 },
+          file: { type: "string", minLength: 1, default: "{folder}.service.ts" }
         },
         required: ["registry", "services"]
       }
     ],
     messages: {
       unregistered: "Register the {{folder}} service here under '{{key}}'.",
-      missing: "Domain folder '{{folder}}' needs {{folder}}.service.ts; add it, or list the folder in skip."
+      missing: "Domain folder '{{folder}}' needs {{file}}; add it, or list the folder in skip."
     }
   },
   createOnce(context) {
@@ -559,11 +560,12 @@ var backendRegistry = defineRule3({
         const domains = entries.filter((entry) => entry.isDirectory() && !(options.skip ?? []).includes(entry.name)).map((entry) => entry.name);
         for (const folder of domains) {
           const key = namingCamelCase(folder);
-          if (!existsSync(join(options.services, folder, `${folder}.service.ts`))) {
+          const file = (options.file ?? "{folder}.service.ts").replaceAll("{folder}", folder);
+          if (!existsSync(join(options.services, folder, file))) {
             context.report({
               node: program,
               messageId: "missing",
-              data: { folder }
+              data: { folder, file }
             });
           } else if (![key, `${key}s`, key.replace(/y$/, "ies")].some((name) => keys.has(name))) {
             context.report({
@@ -1136,11 +1138,14 @@ var boundariesDeny = defineRule6({
 // src/rules/boundaries/boundaries-imports.ts
 import { defineRule as defineRule7 } from "@oxlint/plugins";
 import { basename, resolve as resolve2 } from "node:path";
-var boundariesPublicSurface = /\.(?:service|client|server|rsc|utils)$/;
+var boundariesSurfaces = ["service", "client", "server", "rsc", "utils"];
 var boundariesActionOrQuery = /\/(?:[^/]+)-(?:action|query)\./;
 function boundariesContains(directory, candidate) {
   return candidate === directory || candidate.startsWith(`${directory}/`);
 }
+function boundariesIsSurface(options, stem) {
+  return (options.surfaces ?? boundariesSurfaces).some((surface) => stem.endsWith(`.${surface}`));
+}
 function boundariesStripExtension(path) {
   return path.replace(/\.[cm]?[jt]sx?$/, "");
 }
@@ -1169,12 +1174,12 @@ function boundariesPrivateDomain({ options, file, target, reExport, roots, owner
   const targetDomain = targetOwner ? boundariesDomain(target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
   const sameDomain = owner && owner === targetOwner && fileDomain && fileDomain === targetDomain;
   const targetStem = boundariesStripExtension(target);
-  const publicSurface = boundariesPublicSurface.test(targetStem) && !boundariesActionOrQuery.test(targetStem);
+  const publicSurface = boundariesIsSurface(options, targetStem) && !boundariesActionOrQuery.test(targetStem);
   const privateTarget = roles.some((role) => targetStem.endsWith(`.${role}`)) || targetDomain && !publicSurface && !/\.(?:types|constants)$/.test(targetStem);
   if (!privateTarget) {
     return;
   }
-  if (reExport && /\.(?:service|client|server|rsc|utils)\.ts$/.test(file) && !boundariesActionOrQuery.test(file)) {
+  if (reExport && file.endsWith(".ts") && boundariesIsSurface(options, file.slice(0, -".ts".length)) && !boundariesActionOrQuery.test(file)) {
     return "public service and utility surfaces must not re-export private domain internals";
   }
   return sameDomain ? undefined : "private domain files stay in the same domain and application; use its service API or shared utilities";
@@ -1212,6 +1217,7 @@ var boundariesImports = defineRule7({
           backend: { type: "array", items: { type: "string" } },
           packages: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
           roles: { type: "array", items: { type: "string" } },
+          surfaces: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesSurfaces },
           services: { type: "array", items: { type: "string" } },
           portable: { type: "boolean" },
           backendPackages: { type: "array", items: { type: "string" } },
@@ -1307,11 +1313,9 @@ var boundariesNextDefaults = {
   serverPackages: [...boundariesServerPackages, "server-only", "next/headers", "next/cache", "next/server"],
   clientPackages: ["client-only", "react-dom/client"],
   hookPackages: ["react"],
-  publicEnv: "NEXT_PUBLIC_"
+  publicEnv: "NEXT_PUBLIC_",
+  serverHooks: ["useId", "use"]
 };
-function boundariesIsClientHook(name) {
-  return /^use[A-Z]/.test(name) && name !== "useId" && name !== "use";
-}
 var boundariesNext = defineRule8({
   meta: {
     type: "problem",
@@ -1319,7 +1323,11 @@ var boundariesNext = defineRule8({
       {
         type: "object",
         additionalProperties: false,
-        properties: { ...boundariesRuntimeProperties, publicEnv: { type: "string" } }
+        properties: {
+          ...boundariesRuntimeProperties,
+          publicEnv: { type: "string" },
+          serverHooks: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesNextDefaults.serverHooks }
+        }
       }
     ],
     messages: {
@@ -1335,6 +1343,7 @@ var boundariesNext = defineRule8({
     let client = false;
     let shared = false;
     const reactNamespaces = new Set;
+    const clientHook = (name) => /^use[A-Z]/.test(name) && !options.serverHooks.includes(name);
     function check(node, source, typeOnly) {
       if (typeOnly) {
         return;
@@ -1398,14 +1407,14 @@ var boundariesNext = defineRule8({
             reactNamespaces.add(specifier);
             continue;
           }
-          if (specifier.importKind !== "type" && specifier.imported.type === "Identifier" && boundariesIsClientHook(specifier.imported.name)) {
+          if (specifier.importKind !== "type" && specifier.imported.type === "Identifier" && clientHook(specifier.imported.name)) {
             boundariesReport(context, specifier, specifier.imported.name, boundariesClientHookReason);
           }
         }
       },
       MemberExpression(node) {
         const name = boundariesMemberName(node);
-        if (!name || !boundariesIsClientHook(name) || node.object.type !== "Identifier") {
+        if (!name || !clientHook(name) || node.object.type !== "Identifier") {
           return;
         }
         const binding = boundariesDeclaredVariable(context.sourceCode.getScope(node.object), node.object.name)?.defs[0]?.node;
@@ -1449,12 +1458,54 @@ var boundariesNext = defineRule8({
 });
 
 // src/rules/boundaries/boundaries-rpc-database.ts
-var boundariesQueryMethods = "/^(selectFrom|insertInto|updateTable|deleteFrom|mergeInto|executeQuery)$/";
-var boundariesRpcDatabase = astSelectorRule(`CallExpression[callee.computed=false][callee.property.name=${boundariesQueryMethods}], CallExpression[callee.computed=true][callee.property.value=${boundariesQueryMethods}]`, "RPC handlers delegate database work to services.");
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var boundariesRpcDatabaseMethods = ["selectFrom", "insertInto", "updateTable", "deleteFrom", "mergeInto", "executeQuery"];
+var boundariesRpcDatabase = defineRule9({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          message: { type: "string" },
+          methods: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesRpcDatabaseMethods }
+        }
+      }
+    ],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let message = "";
+    let methods = new Set;
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        message = options.message ?? "RPC handlers delegate database work to services.";
+        methods = new Set(options.methods ?? boundariesRpcDatabaseMethods);
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") {
+          return;
+        }
+        const property = callee.property;
+        const literal = property.type === "Literal" && typeof property.value === "string" ? property.value : undefined;
+        const name = callee.computed ? literal : astMemberName(callee);
+        if (name !== undefined && methods.has(name)) {
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message }
+          });
+        }
+      }
+    };
+  }
+});
 
 // src/rules/boundaries/boundaries-tanstack.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var boundariesRenderers = ["renderServerComponent", "renderToReadableStream"];
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 var boundariesChainMethods = ["handler", "server", "client", "middleware", "validator", "inputValidator"];
 var boundariesSplitFactories = ["createIsomorphicFn", "createMiddleware"];
 var boundariesRuntimeTypeWrappers = [
@@ -1490,12 +1541,13 @@ var boundariesTanstackDefaults = {
   clientPackages: ["react-dom/client", "@tanstack/react-start/client-only", "@tanstack/solid-start/client-only", "@tanstack/vue-start/client-only"],
   hookPackages: ["react", "@tanstack/react-query", "@tanstack/react-router"],
   startPackages: ["@tanstack/react-start"],
-  rscPackages: ["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"]
+  rscPackages: ["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"],
+  renderers: ["renderServerComponent", "renderToReadableStream"]
 };
-function boundariesIsClientHook2(name) {
+function boundariesIsClientHook(name) {
   return /^use[A-Z]/.test(name) && name !== "useId";
 }
-var boundariesTanstack = defineRule9({
+var boundariesTanstack = defineRule10({
   meta: {
     type: "problem",
     schema: [
@@ -1506,7 +1558,8 @@ var boundariesTanstack = defineRule9({
           ...boundariesRuntimeProperties,
           rpc: { type: "array", items: { type: "string" } },
           startPackages: { type: "array", items: { type: "string" } },
-          rscPackages: { type: "array", items: { type: "string" } }
+          rscPackages: { type: "array", items: { type: "string" } },
+          renderers: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.renderers }
         }
       }
     ],
@@ -1662,7 +1715,7 @@ var boundariesTanstack = defineRule9({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (options.rscPackages.includes(node.source.value) && specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && boundariesRenderers.includes(specifier.imported.name)) {
+          if (options.rscPackages.includes(node.source.value) && specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && options.renderers.includes(specifier.imported.name)) {
             check(node, node.source.value, false, false, specifier);
           }
         }
@@ -1670,7 +1723,7 @@ var boundariesTanstack = defineRule9({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !boundariesIsClientHook2(specifier.imported.name)) {
+          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !boundariesIsClientHook(specifier.imported.name)) {
             continue;
           }
           const references = runtimeReferences(node, specifier.local.name);
@@ -1689,10 +1742,10 @@ var boundariesTanstack = defineRule9({
           return;
         }
         const kind = imported(node.object);
-        if (kind === "rsc-renderers" && boundariesRenderers.includes(name) && (shared || !serverPosition(node.start, true))) {
+        if (kind === "rsc-renderers" && options.renderers.includes(name) && (shared || !serverPosition(node.start, true))) {
           boundariesReport(context, node, name, "server renderers require a server execution boundary");
         }
-        if ((serverFile || rscFile) && kind === "client-hooks" && boundariesIsClientHook2(name) && !clientSide(node.start)) {
+        if ((serverFile || rscFile) && kind === "client-hooks" && boundariesIsClientHook(name) && !clientSide(node.start)) {
           boundariesReport(context, node, name, boundariesClientHookReason2);
         }
       },
@@ -1724,8 +1777,8 @@ var boundariesTanstack = defineRule9({
 });
 
 // src/rules/boundaries/boundaries-token-owner.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
-var boundariesTokenOwner = defineRule10({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var boundariesTokenOwner = defineRule11({
   meta: {
     type: "problem",
     schema: [
@@ -1820,7 +1873,7 @@ var boundariesTokenOwner = defineRule10({
 });
 
 // src/rules/code/code-branch-once.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 function codeBranchOnceSubjects(node, source) {
   if (node.type === "LogicalExpression") {
     return [...codeBranchOnceSubjects(node.left, source), ...codeBranchOnceSubjects(node.right, source)];
@@ -1836,18 +1889,27 @@ function codeBranchOnceSubjects(node, source) {
   const literal = sides.some((side) => side.type === "Literal" && typeof side.value === "string");
   return member && literal ? [source.getText(member)] : [];
 }
-var codeBranchOnce = defineRule11({
+var codeBranchOnce = defineRule12({
   meta: {
     type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { min: { type: "integer", minimum: 2, default: 2 } }
+      }
+    ],
     messages: {
       once: "{{subject}} is compared to a string in {{count}} ternaries in this file. Branch on it once and return a record."
     }
   },
   createOnce(context) {
     let groups = new Map;
+    let min = 2;
     return {
       before() {
         groups = new Map;
+        min = optionsFirst(context, {}).min ?? 2;
       },
       ConditionalExpression(node) {
         for (const subject of new Set(codeBranchOnceSubjects(node.test, context.sourceCode))) {
@@ -1856,7 +1918,7 @@ var codeBranchOnce = defineRule11({
       },
       "Program:exit"() {
         for (const [subject, ternaries] of groups) {
-          for (const node of ternaries.length > 1 ? ternaries : []) {
+          for (const node of ternaries.length >= min ? ternaries : []) {
             context.report({
               node,
               messageId: "once",
@@ -1870,8 +1932,8 @@ var codeBranchOnce = defineRule11({
 });
 
 // src/rules/code/code-constructor.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var codeConstructor = defineRule12({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var codeConstructor = defineRule13({
   meta: {
     type: "problem",
     schema: [
@@ -1955,8 +2017,8 @@ var codeConstructor = defineRule12({
 var codeDoubleNegation = astSelectorRule('UnaryExpression[operator="!"] > UnaryExpression[operator="!"]', "Use Boolean(value) or an explicit comparison.");
 
 // src/rules/code/code-function-nesting.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var codeFunctionNesting = defineRule13({
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var codeFunctionNesting = defineRule14({
   meta: {
     type: "suggestion",
     schema: [
@@ -1997,7 +2059,7 @@ var codeFunctionNesting = defineRule13({
 });
 
 // src/rules/code/code-inline.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 
 // src/utils/source.utils.ts
 var sourceDirective = /^\s*(?:\/\s*<(?:reference\b|amd-[\w-]+\b)|@ts-(?:check|ignore|expect-error|nocheck)\b|(?:#|@)__(?:PURE|NO_SIDE_EFFECTS)__\b|@jsx(?:ImportSource|Runtime|Frag)?\b|@vite-ignore\b|(?:[#@]\s*)?sourceMappingURL=|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
@@ -2038,6 +2100,9 @@ function sourceLineEnd(text, offset) {
 `, offset);
   return end === -1 ? text.length : end;
 }
+function sourceJoinedWidth(text, start, joined, end) {
+  return start - sourceLineStart(text, start) + joined.length + text.slice(end, sourceLineEnd(text, end)).trimEnd().length;
+}
 function sourceItemGaps(open, items, close) {
   const edges = [open, ...items.flatMap((item) => item.range), close];
   return Array.from({ length: items.length + 1 }, (_, index) => [edges[index * 2] ?? open, edges[index * 2 + 1] ?? close]);
@@ -2066,7 +2131,20 @@ function codeInlineEnclosingCalls(node) {
   return outer && astIsOneLine(outer) ? 1 + codeInlineEnclosingCalls(outer) : 0;
 }
 var codeInlineWrapped = new Set(["ConditionalExpression", "LogicalExpression", "BinaryExpression", "ArrowFunctionExpression"]);
-var codeInline = defineRule14({
+var codeInlineEffects = new Set([
+  "CallExpression",
+  "NewExpression",
+  "AssignmentExpression",
+  "UpdateExpression",
+  "AwaitExpression",
+  "YieldExpression",
+  "TaggedTemplateExpression",
+  "ImportExpression"
+]);
+function codeInlineEffectBetween(program, start, end) {
+  return astSome(program, (node) => node.range[0] >= start && node.range[1] <= end && (codeInlineEffects.has(node.type) || node.type === "UnaryExpression" && node.operator === "delete"), (node) => node.range[1] > start && node.range[0] < end && !(node.range[0] >= start && (node.type === "FunctionDeclaration" || astIsInlineFunction(node))));
+}
+var codeInline = defineRule15({
   meta: {
     type: "suggestion",
     schema: [
@@ -2104,6 +2182,9 @@ var codeInline = defineRule14({
         return;
       }
       if (uses.length === 1) {
+        if (init && codeInlineEffectBetween(context.sourceCode.ast, node.range[1], uses[0].identifier.range[0])) {
+          return;
+        }
         context.report({
           node: id,
           messageId: "once",
@@ -2141,7 +2222,7 @@ var codeInline = defineRule14({
         deferred ||= current.type === "FunctionDeclaration" || astIsInlineFunction(current);
       }
       const wrapped = codeInlineWrapped.has(init.type) && use.parent.type === "MemberExpression" && use.parent.object === use;
-      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init) > (options.nesting ?? 2) || line.length - id.name.length + context.sourceCode.getText(init).length > (options.max ?? 160)) {
+      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init) > (options.nesting ?? 2) || line.length - id.name.length + context.sourceCode.getText(init).length > (options.max ?? 160) || codeInlineEffectBetween(context.sourceCode.ast, declarator.range[1], use.range[0])) {
         return;
       }
       context.report({
@@ -2176,8 +2257,8 @@ var codeInline = defineRule14({
 });
 
 // src/rules/code/code-justified-call.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var codeJustifiedCall = defineRule15({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var codeJustifiedCall = defineRule16({
   meta: {
     type: "problem",
     schema: [
@@ -2231,8 +2312,8 @@ var codeJustifiedCall = defineRule15({
 });
 
 // src/rules/code/code-literal-in.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var codeLiteralIn = defineRule16({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var codeLiteralIn = defineRule17({
   meta: {
     type: "suggestion",
     schema: [
@@ -2273,7 +2354,7 @@ var codeLiteralIn = defineRule16({
 });
 
 // src/rules/code/code-mutable-state.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 var functionScopes = new Set([
   "FunctionDeclaration",
   "FunctionExpression",
@@ -2290,7 +2371,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule17({
+var codeMutableState = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2348,7 +2429,7 @@ var codeMutableState = defineRule17({
 });
 
 // src/rules/code/code-object-params.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function isObjectParam(node) {
   if (node.type === "ObjectPattern") {
     return true;
@@ -2362,7 +2443,7 @@ function isObjectParam(node) {
   const annotation = node.typeAnnotation?.typeAnnotation;
   return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
 }
-var codeObjectParams = defineRule18({
+var codeObjectParams = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2411,8 +2492,8 @@ var codeObjectParams = defineRule18({
 });
 
 // src/rules/code/code-paired-call.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
-var codePairedCall = defineRule19({
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var codePairedCall = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2443,7 +2524,6 @@ var codePairedCall = defineRule19({
     }
   },
   createOnce(context) {
-    const aliases = new Map;
     let pairs = [];
     return {
       before() {
@@ -2451,26 +2531,10 @@ var codePairedCall = defineRule19({
         const all = when && require2 ? [{ when, require: require2 }, ...configured] : configured;
         pairs = all.map((pair) => ({ ...pair, firstWhen: null, sawRequired: false }));
       },
-      Program(program) {
-        aliases.clear();
-        for (const statement of program.body) {
-          if (statement.type !== "ImportDeclaration") {
-            continue;
-          }
-          for (const specifier of statement.specifiers) {
-            if (specifier.type !== "ImportSpecifier") {
-              continue;
-            }
-            const imported = astModuleName(specifier.imported);
-            if (imported !== specifier.local.name) {
-              aliases.set(specifier.local.name, imported);
-            }
-          }
-        }
-      },
       CallExpression(node) {
-        const called = astCallName(node);
-        const name = called ? aliases.get(called) ?? called : undefined;
+        const callee = node.callee;
+        const binding = callee.type === "Identifier" ? boundariesDeclaredVariable(context.sourceCode.getScope(node), callee.name)?.defs.at(0)?.node : undefined;
+        const name = binding?.type === "ImportSpecifier" ? astModuleName(binding.imported) : astCallName(node);
         for (const pair of pairs) {
           if (name === pair.when) {
             pair.firstWhen ??= node;
@@ -2496,7 +2560,7 @@ var codePairedCall = defineRule19({
 });
 
 // src/rules/code/code-promise-mutation.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2525,7 +2589,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule20({
+var codePromiseMutation = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2618,8 +2682,8 @@ var codePromiseMutation = defineRule20({
 var codeSwitch = astSelectorRule("SwitchStatement", "Avoid switch statements.");
 
 // src/rules/code/code-traced.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var codeTraced = defineRule21({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var codeTraced = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2668,17 +2732,17 @@ var codeTraced = defineRule21({
         message = options.message ?? `An exported function or service method gets a span: replace ${[...untraced].join(", ")} with its traced form.`;
       },
       ExportNamedDeclaration(node) {
-        if (!exported || node.declaration?.type !== "VariableDeclaration") {
+        if (!exported) {
           return;
         }
-        for (const declarator of node.declaration.declarations) {
-          if (isUntraced(declarator.init)) {
-            context.report({
-              node: declarator,
-              messageId: "surface",
-              data: { message }
-            });
-          }
+        const declarators = node.declaration?.type === "VariableDeclaration" ? node.declaration.declarations.filter((declarator) => isUntraced(declarator.init)) : [];
+        const specifiers = node.source ? [] : node.specifiers.filter((specifier) => resolves(specifier.local));
+        for (const surface of [...declarators, ...specifiers]) {
+          context.report({
+            node: surface,
+            messageId: "surface",
+            data: { message }
+          });
         }
       },
       CallExpression(node) {
@@ -2706,7 +2770,7 @@ var codeTraced = defineRule21({
 });
 
 // src/rules/code/code-trivial-functions.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 var codeTrivialFunctionsBanned = [
   "isRecord",
   "isPlainObject",
@@ -2836,7 +2900,7 @@ function guardStatement(node, state) {
     return guardFallback(declaration.init);
   });
 }
-var codeTrivialFunctions = defineRule22({
+var codeTrivialFunctions = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2967,8 +3031,8 @@ var codeTrivialFunctions = defineRule22({
 });
 
 // src/rules/code/code-yield-argument.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var codeYieldArgument = defineRule23({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var codeYieldArgument = defineRule24({
   meta: {
     type: "suggestion",
     messages: {
@@ -2990,7 +3054,7 @@ var codeYieldArgument = defineRule23({
 });
 
 // src/rules/comments/comments-code.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 var commentsLineGap = /^[\t \r\n\u2028\u2029]*$/;
 var commentsLineTerminator = /\r\n|[\n\r\u2028\u2029]/;
 var commentsUnicodeTerminator = /[\u2028\u2029]/;
@@ -3041,7 +3105,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule24({
+var commentsCode = defineRule25({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -3050,7 +3114,7 @@ var commentsCode = defineRule24({
         type: "object",
         additionalProperties: false,
         properties: {
-          why: { type: "boolean", default: true },
+          why: { anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }], default: true },
           allow: { type: "array", items: { type: "string" } },
           jsdoc: { type: "boolean", default: false },
           members: { type: "string", enum: ["off", "also", "only"] }
@@ -3064,6 +3128,7 @@ var commentsCode = defineRule24({
   },
   createOnce(context) {
     let allowWhy = true;
+    let whyPrefix = "Why: ";
     let allowJsdoc = false;
     let allowed = [];
     let members = "off";
@@ -3088,7 +3153,8 @@ var commentsCode = defineRule24({
     return {
       before() {
         const options = optionsFirst(context, {});
-        allowWhy = options.why ?? true;
+        allowWhy = options.why !== false;
+        whyPrefix = `${typeof options.why === "string" ? options.why.trim() : "Why:"} `;
         allowJsdoc = options.jsdoc ?? false;
         allowed = (options.allow ?? []).map((pattern) => new RegExp(pattern));
         members = options.members ?? "off";
@@ -3117,7 +3183,7 @@ var commentsCode = defineRule24({
             mightContainJsxComment = true;
           }
           const followsPrevious = previous !== undefined && comment.loc.start.line === previous.loc.end.line + 1 && commentsLineGap.test(text.slice(previous.range[1], comment.range[0]));
-          const isWhy = value.startsWith("Why: ") || comment.type === "Line" && whyContinuation && followsPrevious;
+          const isWhy = value.startsWith(whyPrefix) || comment.type === "Line" && whyContinuation && followsPrevious;
           if (/^(?:eslint|oxlint)-disable-next-line\b/.test(value)) {
             protectedLines.push(comment.loc.end.line + 1);
           }
@@ -3205,9 +3271,9 @@ var commentsCode = defineRule24({
 });
 
 // src/rules/comments/comments-directives.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 var directive = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s;
-var commentsDirectives = defineRule25({
+var commentsDirectives = defineRule26({
   meta: {
     type: "problem",
     schema: [],
@@ -3235,9 +3301,9 @@ var commentsDirectives = defineRule25({
 });
 
 // src/rules/copy/copy-dashes.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 var copyDashesMessage = "Use a comma, colon, period or parentheses instead.";
-var copyDashes = defineRule26({
+var copyDashes = defineRule27({
   meta: {
     type: "suggestion",
     schema: [
@@ -3293,7 +3359,7 @@ var copyDashes = defineRule26({
 });
 
 // src/rules/files/files-components-only.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 
 // src/utils/react.utils.ts
 function reactReturnsOutput(program, node) {
@@ -3365,7 +3431,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule27({
+var filesComponentsOnly = defineRule28({
   meta: {
     type: "problem",
     schema: [
@@ -3373,7 +3439,7 @@ var filesComponentsOnly = defineRule27({
         type: "object",
         additionalProperties: false,
         properties: {
-          filename: { type: "boolean" },
+          filename: { oneOf: [{ type: "boolean" }, { type: "string", enum: ["each"] }] },
           roles: { type: "array", items: { type: "string" } },
           types: { type: "boolean" },
           deny: optionsPatternSchema
@@ -3434,10 +3500,13 @@ var filesComponentsOnly = defineRule27({
           return;
         }
         const names = components.map((candidate) => candidate.name.toLowerCase());
-        if (expectedKeys.some((key) => names.includes(key) || names.every((name) => name.startsWith(key)))) {
+        if (matchFileName !== "each" && expectedKeys.some((key) => names.includes(key) || names.every((name) => name.startsWith(key)))) {
           return;
         }
         for (const { name, node } of components) {
+          if (matchFileName === "each" && expectedKeys.some((key) => name.toLowerCase().startsWith(key))) {
+            continue;
+          }
           context.report({
             node,
             messageId: "nameMismatch",
@@ -3450,7 +3519,7 @@ var filesComponentsOnly = defineRule27({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 function unwrap(expression) {
   if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "TSInstantiationExpression") {
     return unwrap(expression.expression);
@@ -3505,7 +3574,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule28({
+var filesConstantsOnly = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3604,7 +3673,7 @@ var filesConstantsOnly = defineRule28({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -3622,14 +3691,21 @@ function isData(expression) {
   }
   return value.type === "NewExpression" && value.callee.type === "Identifier" && ["Map", "Set"].includes(value.callee.name) && value.arguments[0]?.type === "ArrayExpression" && value.arguments[0].elements.length > 0;
 }
-var filesDomainConstants = defineRule29({
+var filesDomainConstants = defineRule30({
   meta: {
     type: "problem",
     schema: [
       {
         type: "object",
         additionalProperties: false,
-        properties: { data: { type: "boolean" }, services: { type: "boolean" } }
+        properties: {
+          data: { type: "boolean" },
+          services: { type: "boolean" },
+          pattern: { ...optionsPatternSchema, default: "^[A-Z][A-Z0-9_]+$" },
+          folders: { type: "array", items: { type: "string", minLength: 1 }, default: ["services"] },
+          roles: { type: "array", items: { type: "string", minLength: 1 }, default: ["action", "query"] },
+          file: { type: "string", minLength: 1, default: "{domain}.constants.ts" }
+        }
       }
     ],
     messages: {
@@ -3638,11 +3714,19 @@ var filesDomainConstants = defineRule29({
   },
   createOnce(context) {
     let includeData = false;
+    let names = [];
+    let folders = [];
+    let roles = [];
+    let target = "";
     let serviceObjects = new Set;
     return {
       Program(program) {
         const options = optionsFirst(context, {});
         includeData = Boolean(options.data);
+        names = optionsPatterns(options.pattern ?? "^[A-Z][A-Z0-9_]+$");
+        folders = options.folders ?? ["services"];
+        roles = options.roles ?? ["action", "query"];
+        target = options.file ?? "{domain}.constants.ts";
         serviceObjects = new Set(options.services ? declarationsPublicServiceMethods(program).map((method) => method.binding) : []);
       },
       VariableDeclarator(node) {
@@ -3652,15 +3736,19 @@ var filesDomainConstants = defineRule29({
           return;
         }
         const name = node.id.type === "Identifier" ? node.id.name : undefined;
-        if ((!name || !/^[A-Z][A-Z0-9_]+$/.test(name)) && (!includeData || !node.init || !isData(node.init))) {
+        if ((!name || !optionsPatternsTest(names, name)) && (!includeData || !node.init || !isData(node.init))) {
           return;
         }
         const file = context.filename.replaceAll("\\", "/");
-        const owner = file.includes("/services/") && dirname2(file).split("/").at(-1) !== "services" ? basename2(dirname2(file)) : basename2(file).split(".")[0].replace(/-(?:action|query)$/, "");
+        const folder = basename2(dirname2(file));
+        const stem = basename2(file).split(".")[0];
+        const role = roles.find((candidate) => stem.endsWith(`-${candidate}`));
+        const domain = role ? stem.slice(0, -role.length - 1) : stem;
+        const owner = folders.some((candidate) => file.includes(`/${candidate}/`) && folder !== candidate) ? folder : domain;
         context.report({
           node,
           messageId: "forbidden",
-          data: { name: name ?? "<destructured binding>", file: `${owner}.constants.ts` }
+          data: { name: name ?? "<destructured binding>", file: target.replaceAll("{domain}", owner) }
         });
       }
     };
@@ -3668,11 +3756,11 @@ var filesDomainConstants = defineRule29({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule31 } from "@oxlint/plugins";
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var filesExports = defineRule30({
+var filesExports = defineRule31({
   meta: {
     type: "problem",
     schema: [
@@ -3753,11 +3841,12 @@ var filesExports = defineRule30({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { builtinModules as builtinModules2 } from "node:module";
 import { dirname as dirname3, join as join2 } from "node:path";
-var filesExternals = defineRule31({
+var filesExternalsConfigs = "^(?:vite|next)\\.config\\.[cm]?[jt]s$";
+var filesExternals = defineRule32({
   meta: {
     type: "problem",
     schema: [
@@ -3765,7 +3854,8 @@ var filesExternals = defineRule31({
         type: "object",
         additionalProperties: false,
         properties: {
-          packages: { type: "array", items: { type: "string", minLength: 1 } }
+          packages: { type: "array", items: { type: "string", minLength: 1 } },
+          files: { ...optionsPatternSchema, default: filesExternalsConfigs }
         }
       }
     ],
@@ -3821,7 +3911,8 @@ var filesExternals = defineRule31({
     }
     return {
       before() {
-        if (!/^(?:vite|next)\.config\.[cm]?[jt]s$/.test(namingBasename(context.filename))) {
+        const files = optionsPatterns(optionsFirst(context, {}).files ?? filesExternalsConfigs);
+        if (!optionsPatternsTest(files, namingBasename(context.filename))) {
           return false;
         }
       },
@@ -3848,7 +3939,7 @@ var filesExternals = defineRule31({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
+import { defineRule as defineRule33 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -3859,7 +3950,7 @@ function compileKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return { patterns: optionsPatternsWithEmpty(pattern), allowed: new Set(allowedList), allowedList, required: requireKeys };
 }
-var filesFactoryKeys = defineRule32({
+var filesFactoryKeys = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -3977,8 +4068,8 @@ var filesFactoryKeys = defineRule32({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
-var filesHelpers = defineRule33({
+import { defineRule as defineRule34 } from "@oxlint/plugins";
+var filesHelpers = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -4026,8 +4117,8 @@ var filesHelpers = defineRule33({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule34({
+import { defineRule as defineRule35 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -4081,8 +4172,8 @@ var filesNoFunctions = defineRule34({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
-var filesRestricted = defineRule35({
+import { defineRule as defineRule36 } from "@oxlint/plugins";
+var filesRestricted = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4114,7 +4205,7 @@ var filesRestricted = defineRule35({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
   astVisit(item.node.body, [item.node], (node) => {
     if (banIntrinsicJsx && node.type === "JSXOpeningElement" && node.name.type === "JSXIdentifier" && /^[a-z]/.test(node.name.name)) {
@@ -4134,7 +4225,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule36({
+var filesRoute = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4204,7 +4295,7 @@ var filesRoute = defineRule36({
 });
 
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -4373,7 +4464,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule37({
+var filesTypesOnly = defineRule38({
   meta: {
     type: "problem",
     schema: [
@@ -4481,8 +4572,8 @@ var filesTypesOnly = defineRule37({
 });
 
 // src/rules/layout/layout-arrow-body.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-var layoutArrowBody = defineRule38({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule39({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4534,12 +4625,12 @@ var layoutArrowBody = defineRule38({
 });
 
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
+import { defineRule as defineRule40 } from "@oxlint/plugins";
 function layoutCallArgumentsHuggable(node) {
   return astIsInlineFunction(node) || node.type === "ObjectExpression" || node.type === "ArrayExpression" || astIsCall(node) && node.arguments.length === 1 && (node.callee.type !== "MemberExpression" || astIsOneLine(node.callee)) && node.arguments.every(layoutCallArgumentsHuggable);
 }
 var layoutCallArgumentsMax = { type: "integer", minimum: 1 };
-var layoutCallArguments = defineRule39({
+var layoutCallArguments = defineRule40({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4553,11 +4644,7 @@ var layoutCallArguments = defineRule39({
             minimum: 2,
             default: 3
           },
-          indent: {
-            type: "integer",
-            minimum: 1,
-            default: 2
-          },
+          indent: { ...sourceIndentSchema, default: 2 },
           split: {
             type: "boolean",
             default: true
@@ -4575,6 +4662,7 @@ var layoutCallArguments = defineRule39({
             properties: {
               max: layoutCallArgumentsMax,
               nesting: layoutCallArgumentsMax,
+              items: layoutCallArgumentsMax,
               keep: { type: "array", items: { type: "string" } }
             }
           }
@@ -4591,7 +4679,7 @@ var layoutCallArguments = defineRule39({
   createOnce(context) {
     let options = {};
     let minArguments = 3;
-    let indent = 2;
+    let indentUnit = sourceIndentUnit();
     const split = (node) => {
       const args = node.arguments;
       const last = args.at(-1);
@@ -4615,7 +4703,7 @@ var layoutCallArguments = defineRule39({
       const unsafe = source.getCommentsInside(node).length > 0 || text[open] !== "(" || text[close] !== ")" || !/^\s*$/.test(between[0]) || between.slice(1, -1).some((gap) => !/^\s*,\s*$/.test(gap)) || !/^\s*,?\s*$/.test(between.at(-1) ?? "");
       const baseIndent = sourceLineIndent(text, open);
       const newline = sourceNewline(text);
-      const argumentIndent = `${baseIndent}${" ".repeat(indent)}`;
+      const argumentIndent = `${baseIndent}${indentUnit}`;
       context.report({
         node,
         messageId: "multiline",
@@ -4660,7 +4748,7 @@ var layoutCallArguments = defineRule39({
       }
       const newline = sourceNewline(text);
       const base = sourceLineIndent(text, open.range[0]);
-      const inner = `${base}${" ".repeat(indent)}`;
+      const inner = `${base}${indentUnit}`;
       context.report({
         node,
         messageId: "hug",
@@ -4671,16 +4759,14 @@ var layoutCallArguments = defineRule39({
       const source = context.sourceCode;
       const text = source.text;
       const first = items.at(0);
-      if (!first || !open || !close || items.length > 2 || first.loc.start.line === open.loc.end.line || !items.every(astIsOneLine) || source.commentsExistBetween(open, close)) {
+      if (!first || !open || !close || items.length > Math.min(options.join?.items ?? 2, options.split === false ? Number.POSITIVE_INFINITY : minArguments - 1) || first.loc.start.line === open.loc.end.line || !items.every(astIsOneLine) || source.commentsExistBetween(open, close)) {
         return;
       }
-      const inside = items.map((item) => source.getText(item)).join(", ");
-      const before = text.slice(sourceLineStart(text, open.range[0]), open.range[1]);
-      const after = text.slice(close.range[0], sourceLineEnd(text, close.range[0]));
-      if (`${before}${inside}${after}`.length > (options.join?.max ?? 0)) {
+      const gaps = sourceItemGaps(open.range[1], items, close.range[0]);
+      const comma = text.slice(...gaps.at(-1) ?? [0, 0]).includes(",") ? "," : "";
+      if (sourceJoinedWidth(text, open.range[1], `${items.map((item) => source.getText(item)).join(", ")}${comma}`, close.range[0]) > (options.join?.max ?? 0)) {
         return;
       }
-      const gaps = sourceItemGaps(open.range[1], items, close.range[0]);
       context.report({
         node,
         messageId: "join",
@@ -4712,7 +4798,7 @@ var layoutCallArguments = defineRule39({
       before() {
         options = optionsFirst(context, {});
         minArguments = options.min ?? 3;
-        indent = options.indent ?? 2;
+        indentUnit = sourceIndentUnit(options.indent);
       },
       CallExpression: call,
       NewExpression: call,
@@ -4726,12 +4812,12 @@ var layoutCallArguments = defineRule39({
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
+import { defineRule as defineRule41 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule40({
+var layoutCallArray = defineRule41({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4847,7 +4933,7 @@ var layoutCallArray = defineRule40({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
+import { defineRule as defineRule42 } from "@oxlint/plugins";
 function layoutCallDepthOuter(node) {
   const parent = node.parent;
   if (!parent || parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type.endsWith("Statement")) {
@@ -4855,7 +4941,7 @@ function layoutCallDepthOuter(node) {
   }
   return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent);
 }
-var layoutCallDepth = defineRule41({
+var layoutCallDepth = defineRule42({
   meta: {
     type: "layout",
     schema: [
@@ -4894,8 +4980,8 @@ var layoutCallDepth = defineRule41({
 });
 
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var layoutChain = defineRule42({
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var layoutChain = defineRule43({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5014,8 +5100,8 @@ var layoutChain = defineRule42({
 });
 
 // src/rules/layout/layout-items.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var layoutItems = defineRule43({
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var layoutItems = defineRule44({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5070,8 +5156,8 @@ var layoutItems = defineRule43({
 });
 
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule44({
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule45({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5081,12 +5167,19 @@ var layoutJsxAttributes = defineRule44({
         additionalProperties: false,
         properties: {
           min: { type: "integer", minimum: 1 },
-          indent: sourceIndentSchema
+          indent: sourceIndentSchema,
+          join: {
+            type: "object",
+            additionalProperties: false,
+            required: ["max"],
+            properties: { max: { type: "integer", minimum: 1 } }
+          }
         }
       }
     ],
     messages: {
-      multiline: "Put every JSX attribute and the closing token on its own line."
+      multiline: "Put every JSX attribute and the closing token on its own line.",
+      join: "This tag fits on one line, so keep it on one line."
     }
   },
   createOnce(context) {
@@ -5094,35 +5187,52 @@ var layoutJsxAttributes = defineRule44({
     let indentUnit = sourceIndentUnit();
     let newline = `
 `;
+    let joinMax;
     return {
       before() {
         const options = optionsFirst(context, {});
         minAttributes = options.min ?? 3;
         indentUnit = sourceIndentUnit(options.indent);
         newline = sourceNewline(context.sourceCode.text);
+        joinMax = options.join?.max;
       },
       JSXOpeningElement(node) {
-        if (node.attributes.length < minAttributes || node.loc.start.line !== node.loc.end.line) {
-          return;
-        }
         const source = context.sourceCode;
         const text = source.text;
+        const attributes = node.attributes;
+        const split = attributes.length >= minAttributes;
+        if (split ? !astIsOneLine(node) : joinMax === undefined || astIsOneLine(node)) {
+          return;
+        }
+        if (!split) {
+          const start = (node.typeArguments ?? node.name).range[1];
+          if (attributes.length === 0 || !attributes.every(astIsOneLine) || text.slice(node.range[0], start).includes(`
+`) || source.getCommentsInside(node).length > 0) {
+            return;
+          }
+          const end = node.range[1] - (node.selfClosing ? 2 : 1);
+          const ranges = sourceItemGaps(start, attributes, end);
+          const closing = node.selfClosing ? " " : "";
+          if (sourceJoinedWidth(text, start, ` ${attributes.map((attribute) => source.getText(attribute)).join(" ")}${closing}`, end) > (joinMax ?? 0)) {
+            return;
+          }
+          context.report({
+            node,
+            messageId: "join",
+            fix: (fixer) => ranges.some((range) => !/^\s*$/.test(text.slice(...range))) ? null : ranges.map((range, index) => fixer.replaceTextRange(range, index === ranges.length - 1 ? closing : " "))
+          });
+          return;
+        }
         const baseIndent = sourceLineIndent(text, node.range[0]);
         const attributeIndent = baseIndent + indentUnit;
-        const attributes = node.attributes;
         context.report({
           node,
           messageId: "multiline",
           fix: (fixer) => {
-            const last = attributes.at(-1);
-            if (source.getCommentsInside(node).length > 0 || !last) {
+            if (source.getCommentsInside(node).length > 0) {
               return null;
             }
-            const ranges = [
-              [(node.typeArguments ?? node.name).range[1], attributes[0].range[0]],
-              ...attributes.slice(1).map((attribute, index) => [attributes[index].range[1], attribute.range[0]]),
-              [last.range[1], node.range[1] - (node.selfClosing ? 2 : 1)]
-            ];
+            const ranges = sourceItemGaps((node.typeArguments ?? node.name).range[1], attributes, node.range[1] - (node.selfClosing ? 2 : 1));
             if (ranges.some((range) => !/^\s*$/.test(text.slice(...range)))) {
               return null;
             }
@@ -5135,8 +5245,8 @@ var layoutJsxAttributes = defineRule44({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule45({
+import { defineRule as defineRule46 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule46({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5172,11 +5282,15 @@ var layoutKeyValue = defineRule45({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
+import { defineRule as defineRule47 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
-var layoutObject = defineRule46({
+function layoutObjectIsFlat(property) {
+  const value = property.type === "SpreadElement" ? property.argument : property.value;
+  return astIsOneLine(property) && (property.type === "SpreadElement" || !property.method && property.kind === "init") && value.type !== "ObjectExpression" && value.type !== "ArrayExpression" && !astIsInlineFunction(value);
+}
+var layoutObject = defineRule47({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5187,13 +5301,23 @@ var layoutObject = defineRule46({
         properties: {
           min: { type: "integer", minimum: 1, default: 3 },
           scope: { type: "string", enum: ["call-args", "all"], default: "call-args" },
-          indent: { ...sourceIndentSchema, default: 2 }
+          indent: { ...sourceIndentSchema, default: 2 },
+          join: {
+            type: "object",
+            additionalProperties: false,
+            required: ["max"],
+            properties: {
+              max: { type: "integer", minimum: 1 },
+              keep: { type: "array", items: { type: "string" } }
+            }
+          }
         }
       }
     ],
     messages: {
       callArgs: "Object with {{min}}+ properties in a call should have each property on its own line.",
-      always: "Object with {{min}}+ properties should have each property on its own line."
+      always: "Object with {{min}}+ properties should have each property on its own line.",
+      join: "This object fits on one line, so keep it on one line."
     }
   },
   createOnce(context) {
@@ -5202,6 +5326,7 @@ var layoutObject = defineRule46({
     let indentUnit = sourceIndentUnit();
     let newline = `
 `;
+    let join3;
     return {
       before() {
         const options = optionsFirst(context, {});
@@ -5209,21 +5334,43 @@ var layoutObject = defineRule46({
         scope = options.scope ?? "call-args";
         indentUnit = sourceIndentUnit(options.indent);
         newline = sourceNewline(context.sourceCode.text);
+        join3 = options.join;
       },
       ObjectExpression(node) {
-        if (node.properties.length < minProperties || node.loc.start.line !== node.loc.end.line) {
+        const source = context.sourceCode;
+        const text = source.text;
+        const properties = node.properties;
+        const split = properties.length >= minProperties;
+        if (split ? !astIsOneLine(node) : !join3 || astIsOneLine(node)) {
           return;
         }
         const parent = node.parent;
-        if (scope === "call-args" && !((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node))) {
+        const call = (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node) ? parent : undefined;
+        if (scope === "call-args" && !call) {
+          return;
+        }
+        if (!split) {
+          const callee = call ? astDottedName(call.callee) : undefined;
+          const kept = callee !== undefined && (join3?.keep ?? []).some((name) => callee === name || callee.endsWith(`.${name}`));
+          if (kept || properties.length === 0 || !properties.every(layoutObjectIsFlat) || source.getCommentsInside(node).length > 0) {
+            return;
+          }
+          const gaps = sourceItemGaps(node.range[0] + 1, properties, node.range[1] - 1);
+          const comma = text.slice(...gaps.at(-1) ?? [0, 0]).includes(",") ? "," : "";
+          const joined = ` ${properties.map((property) => source.getText(property)).join(", ")}${comma} `;
+          if (sourceJoinedWidth(text, node.range[0] + 1, joined, node.range[1] - 1) > (join3?.max ?? 0)) {
+            return;
+          }
+          context.report({
+            node,
+            messageId: "join",
+            fix: (fixer) => sourceRespace(fixer, text, gaps, () => " ")
+          });
           return;
         }
-        const source = context.sourceCode;
-        const text = source.text;
         const baseIndent = sourceLineIndent(text, node.range[0]);
         const propertyIndent = `${baseIndent}${indentUnit}`;
         const close = node.range[1] - 1;
-        const properties = node.properties;
         context.report({
           node,
           messageId: scope === "all" ? "always" : "callArgs",
@@ -5260,7 +5407,7 @@ var layoutObject = defineRule46({
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
+import { defineRule as defineRule48 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -5289,7 +5436,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule47({
+var layoutPadding = defineRule48({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5378,8 +5525,8 @@ var layoutPadding = defineRule47({
 });
 
 // src/rules/layout/layout-pipe.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
-var layoutPipe = defineRule48({
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+var layoutPipe = defineRule49({
   meta: {
     type: "layout",
     messages: {
@@ -5410,7 +5557,7 @@ var layoutPipe = defineRule48({
 });
 
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
+import { defineRule as defineRule50 } from "@oxlint/plugins";
 function layoutTernaryLines(node) {
   return node.loc.end.line - node.loc.start.line + 1;
 }
@@ -5418,7 +5565,7 @@ function layoutTernaryBreak(between, operator, newline) {
   const at = between.indexOf(operator);
   return `${between.slice(0, at).trimEnd()}${newline}${operator} ${between.slice(at + 1).trimStart()}`;
 }
-var layoutTernary = defineRule49({
+var layoutTernary = defineRule50({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5432,11 +5579,7 @@ var layoutTernary = defineRule49({
             minimum: 1,
             default: 160
           },
-          indent: {
-            type: "integer",
-            minimum: 1,
-            default: 2
-          },
+          indent: { ...sourceIndentSchema, default: 2 },
           fit: {
             type: "boolean",
             default: true
@@ -5459,7 +5602,7 @@ var layoutTernary = defineRule49({
   },
   createOnce(context) {
     let maxLength = 160;
-    let indent = 2;
+    let indentUnit = sourceIndentUnit();
     let fit = true;
     let branchMax;
     const branch = (node, max) => {
@@ -5480,7 +5623,7 @@ var layoutTernary = defineRule49({
       before() {
         const options = optionsFirst(context, {});
         maxLength = options.max ?? 160;
-        indent = options.indent ?? 2;
+        indentUnit = sourceIndentUnit(options.indent);
         fit = options.fit ?? true;
         branchMax = options.branch?.max;
       },
@@ -5520,7 +5663,7 @@ var layoutTernary = defineRule49({
         if (!onOneLine || interpolated || length <= maxLength) {
           return;
         }
-        const newline = `${sourceNewline(text)}${sourceLineIndent(text, node.range[0])}${" ".repeat(indent)}`;
+        const newline = `${sourceNewline(text)}${sourceLineIndent(text, node.range[0])}${indentUnit}`;
         const question = [node.test.range[1], node.consequent.range[0]];
         const colon = [node.consequent.range[1], node.alternate.range[0]];
         context.report({
@@ -5538,9 +5681,9 @@ var layoutTernary = defineRule49({
 });
 
 // src/rules/naming/naming-declarations.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
+import { defineRule as defineRule51 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule50({
+var namingDeclarations = defineRule51({
   meta: {
     type: "problem",
     schema: [
@@ -5572,11 +5715,9 @@ var namingDeclarations = defineRule50({
       const declarator = node.type === "VariableDeclarator";
       const kind = declarationsKindOf(node, declarator ? [node.parent] : []);
       const name = declarationsIdName(node);
-      let insideLoop = false;
-      for (let current = declarator ? node.parent : null;current && !insideLoop; current = current.parent) {
-        insideLoop = current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement";
-      }
-      if (!kind || !name || insideLoop || kinds && !kinds.has(kind) || optionsPatternsTest(allowed, name)) {
+      const loop = declarator ? node.parent.parent : null;
+      const loopHeader = loop?.type === "ForStatement" ? loop.init === node.parent : (loop?.type === "ForInStatement" || loop?.type === "ForOfStatement") && loop.left === node.parent;
+      if (!kind || !name || loopHeader || kinds && !kinds.has(kind) || optionsPatternsTest(allowed, name)) {
         return;
       }
       if (expected.length > 0) {
@@ -5619,7 +5760,7 @@ var namingDeclarations = defineRule50({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
+import { defineRule as defineRule52 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -5645,7 +5786,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule51({
+var namingExports = defineRule52({
   meta: {
     type: "problem",
     schema: {
@@ -5740,9 +5881,12 @@ var namingExports = defineRule51({
             }
             continue;
           }
-          const names = scope === "declarations" ? [...declarations ??= declarationsNamed(program)] : (bindings ??= exportsCollect(program)).flatMap((binding) => options.types && binding.typeOnly ? [] : [{ name: binding.localName ?? binding.exportedName, node: binding.node }]);
+          const names = scope === "declarations" ? [...declarations ??= declarationsNamed(program)] : (bindings ??= exportsCollect(program)).flatMap((binding) => {
+            const name = binding.default ? binding.localName ?? binding.exportedName : binding.exportedName;
+            return options.types && binding.typeOnly ? [] : [{ name, node: binding.node }];
+          });
           if (scope === "functions") {
-            const exported = new Set(names.map((item) => item.name));
+            const exported = new Set([...names.map((item) => item.name), ...(bindings ?? []).flatMap((binding) => binding.localName ?? [])]);
             names.push(...(declarations ??= declarationsNamed(program)).filter(({ name, node }) => !exported.has(name) && (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator" && declarationsIsFunctionValue(node.init))));
           }
           if (options.services) {
@@ -5779,10 +5923,10 @@ var namingExports = defineRule51({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule52({
+var namingFile = defineRule53({
   meta: {
     type: "problem",
     schema: {
@@ -5852,9 +5996,9 @@ var namingFile = defineRule52({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule54 } from "@oxlint/plugins";
 import { posix as posix2 } from "node:path";
-var namingFolder = defineRule53({
+var namingFolder = defineRule54({
   meta: {
     type: "problem",
     schema: [
@@ -5928,9 +6072,9 @@ var reactDynamicClasses = astSelectorRule(':matches(JSXAttribute[name.name="clas
 var reactEmptyEffect = astSelectorRule(':matches(CallExpression[callee.name=/^use(Layout)?Effect$/], CallExpression[callee.object.name="React"][callee.property.name=/^use(Layout)?Effect$/]) > :matches(ArrowFunctionExpression, FunctionExpression) > BlockStatement[body.length=0]', "Remove the empty effect.");
 
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
+import { defineRule as defineRule55 } from "@oxlint/plugins";
 var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule54({
+var reactMemo = defineRule55({
   meta: {
     type: "problem",
     schema: [],
@@ -5965,7 +6109,7 @@ var reactMemo = defineRule54({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
+import { defineRule as defineRule56 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -5992,7 +6136,7 @@ function reactIsPassThrough(type) {
   const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
   return name.type === "Identifier" && name.name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
 }
-var reactProps = defineRule55({
+var reactProps = defineRule56({
   meta: {
     type: "problem",
     schema: [
@@ -6000,7 +6144,8 @@ var reactProps = defineRule55({
         type: "object",
         additionalProperties: false,
         properties: {
-          prefix: { type: "boolean" }
+          prefix: { type: "boolean" },
+          suffix: { type: "string", minLength: 1, default: "Props" }
         }
       }
     ],
@@ -6014,7 +6159,7 @@ var reactProps = defineRule55({
   createOnce(context) {
     return {
       Program(program) {
-        const { prefix: filePrefix = false } = optionsFirst(context, {});
+        const { prefix: filePrefix = false, suffix = "Props" } = optionsFirst(context, {});
         const stem = namingFileStem(namingBasename(context.filename).replace(/\.(tsx?|jsx?)$/, ""));
         const prefix = namingNormalized(stem, "remove-separators");
         const exported = new Set(exportsCollect(program).flatMap((binding) => binding.typeOnly ? [] : [binding.localName]));
@@ -6039,7 +6184,7 @@ var reactProps = defineRule55({
             continue;
           }
           const type = target.typeArgument ?? reactParameterType(parameter);
-          const expected = `${candidate.name}Props`;
+          const expected = `${candidate.name}${suffix}`;
           const data = { name: candidate.name, expected };
           if (filePrefix && !exported.has(candidate.name) && !candidate.name.toLowerCase().startsWith(prefix)) {
             context.report({
@@ -6090,7 +6235,7 @@ var reactProps = defineRule55({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule57 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -6126,7 +6271,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule56({
+var schemasInline = defineRule57({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -6175,11 +6320,11 @@ var schemasInline = defineRule56({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule57 } from "@oxlint/plugins";
+import { defineRule as defineRule58 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
-var schemasLocal = defineRule57({
+var schemasLocal = defineRule58({
   meta: {
     type: "problem",
     schema: [
@@ -6209,8 +6354,6 @@ var schemasLocal = defineRule57({
     let packages = new Set;
     let calls = new Set;
     let pending = [];
-    let schemaUses = new Set;
-    let callUses = new Set;
     let importMessage = schemasLocalImportMessage;
     let constructionMessage = schemasLocalConstructionMessage;
     function isAllowedCall(node, member) {
@@ -6242,8 +6385,6 @@ var schemasLocal = defineRule57({
         packages = new Set(options.packages);
         calls = new Set(options.calls ?? schemasLocalCalls);
         pending = [];
-        schemaUses = new Set;
-        callUses = new Set;
         importMessage = options.importMessage ?? options.message ?? schemasLocalImportMessage;
         constructionMessage = options.constructionMessage ?? options.message ?? schemasLocalConstructionMessage;
         if ((options.allow ?? []).some((suffix) => filename.endsWith(suffix)) || (options.patterns ?? []).some((pattern) => new RegExp(pattern).test(filename))) {
@@ -6267,18 +6408,8 @@ var schemasLocal = defineRule57({
         }
         pending.push({ node, locals });
       },
-      Identifier(node) {
-        if (!constructors.has(node.name) || node.parent.type.startsWith("Import")) {
-          return;
-        }
-        if (isAllowedCall(node, node.parent)) {
-          callUses.add(node.name);
-          return;
-        }
-        schemaUses.add(node.name);
-      },
       "Program:exit"() {
-        const runtime = pending.filter(({ locals }) => locals.some((name) => schemaUses.has(name) || !callUses.has(name)));
+        const runtime = pending.filter(({ node, locals }) => context.sourceCode.getDeclaredVariables(node).filter((variable) => locals.includes(variable.name)).some((variable) => variable.references.length === 0 || variable.references.some((reference) => !isAllowedCall(reference.identifier, reference.identifier.parent))));
         for (const { node } of runtime) {
           reportRuntimeImport(node, node.source.value);
         }
@@ -6304,8 +6435,8 @@ var schemasLocal = defineRule57({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
-var schemasRederive = defineRule58({
+import { defineRule as defineRule59 } from "@oxlint/plugins";
+var schemasRederive = defineRule59({
   meta: {
     type: "problem",
     schema: [
@@ -6351,7 +6482,7 @@ var schemasRederive = defineRule58({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
+import { defineRule as defineRule60 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -6365,7 +6496,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule59({
+var schemasSingleUse = defineRule60({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -6441,7 +6572,7 @@ var schemasSingleUse = defineRule59({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { defineRule as defineRule61 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -6631,7 +6762,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule60({
+var testsAssertions = defineRule61({
   meta: {
     type: "problem",
     schema: [
@@ -6757,17 +6888,36 @@ var testsAssertions = defineRule60({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule61({
+import { defineRule as defineRule62 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule62({
   meta: {
     type: "problem",
-    schema: [{ type: "object", properties: { message: { type: "string" } }, additionalProperties: false }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          message: { type: "string" },
+          fixtures: { type: "array", items: { type: "string", minLength: 1 }, default: ["db"] },
+          callees: { type: "array", items: { type: "string", minLength: 1 }, default: ["test.concurrent"] }
+        }
+      }
+    ],
     messages: { forbidden: "{{message}}" }
   },
   createOnce(context) {
+    let message = "";
+    let fixtures = new Set;
+    let callees = new Set;
     return {
+      before() {
+        const options = optionsFirst(context, {});
+        message = options.message ?? "Obtain an isolated database fixture for concurrent tests.";
+        fixtures = new Set(options.fixtures ?? ["db"]);
+        callees = new Set(options.callees ?? ["test.concurrent"]);
+      },
       CallExpression(node) {
-        const callback = astDottedName(node.callee) === "test.concurrent" ? node.arguments.findLast(declarationsIsFunctionValue) : undefined;
+        const callback = callees.has(astDottedName(node.callee) ?? "") ? node.arguments.findLast(declarationsIsFunctionValue) : undefined;
         const parameter = callback?.params.at(0);
         const patterns = parameter?.type === "ObjectPattern" ? [parameter] : [];
         if (callback && parameter?.type === "Identifier") {
@@ -6780,8 +6930,8 @@ var testsConcurrentDb = defineRule61({
           }
         }
         for (const property of patterns.flatMap((pattern) => pattern.properties)) {
-          if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === "db") {
-            const { message = "Obtain an isolated database fixture for concurrent tests." } = optionsFirst(context, {});
+          const key = property.type === "Property" && !property.computed ? property.key : undefined;
+          if (fixtures.has((key?.type === "Identifier" ? key.name : key && astStaticString(key)) ?? "")) {
             context.report({
               node: property,
               messageId: "forbidden",
@@ -6795,10 +6945,10 @@ var testsConcurrentDb = defineRule61({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
+import { defineRule as defineRule63 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
-var testsModifiersBanned = new Set(["only", "skip", "todo"]);
+var testsModifiersBanned = ["only", "skip", "todo"];
 var testsModifiersBuilders = new Set(["if", "runIf", "skipIf"]);
 function modifierName(node) {
   if (node.type === "Identifier") {
@@ -6814,14 +6964,17 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule62({
+var testsModifiers = defineRule63({
   meta: {
     type: "problem",
     schema: [
       {
         type: "object",
         additionalProperties: false,
-        properties: { functions: { type: "array", items: { type: "string" } } }
+        properties: {
+          functions: { type: "array", items: { type: "string" } },
+          modifiers: { type: "array", items: { type: "string", minLength: 1 }, default: testsModifiersBanned }
+        }
       }
     ],
     messages: {
@@ -6830,12 +6983,12 @@ var testsModifiers = defineRule62({
   },
   createOnce(context) {
     let names = new Set;
+    let banned = new Set;
     return {
       before() {
-        names = new Set([
-          ...testsModifiersNames,
-          ...optionsFirst(context, {}).functions ?? []
-        ]);
+        const options = optionsFirst(context, {});
+        names = new Set([...testsModifiersNames, ...options.functions ?? []]);
+        banned = new Set(options.modifiers ?? testsModifiersBanned);
       },
       ImportDeclaration(node) {
         if (!testsModifiersPackages.has(node.source.value)) {
@@ -6853,7 +7006,7 @@ var testsModifiers = defineRule62({
       },
       MemberExpression(node) {
         const name = modifierName(node);
-        if (!name || !testsModifiersBanned.has(name.split(".").at(-1) ?? "")) {
+        if (!name || !banned.has(name.split(".").at(-1) ?? "")) {
           return;
         }
         if ([...names].some((test) => name.startsWith(`${test}.`))) {
@@ -6865,9 +7018,9 @@ var testsModifiers = defineRule62({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
-var testsTitlesModifiers = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
-var testsTitles = defineRule63({
+import { defineRule as defineRule64 } from "@oxlint/plugins";
+var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
+var testsTitles = defineRule64({
   meta: {
     type: "suggestion",
     schema: [
@@ -6876,6 +7029,7 @@ var testsTitles = defineRule63({
         additionalProperties: false,
         properties: {
           callees: { type: "array", items: { type: "string" } },
+          modifiers: { type: "array", items: { type: "string", minLength: 1 }, default: testsTitlesModifiers },
           deny: optionsPatternSchema,
           require: optionsPatternSchema,
           flags: { type: "string", pattern: "^[dgimsuvy]*$" }
@@ -6895,6 +7049,7 @@ var testsTitles = defineRule63({
   },
   createOnce(context) {
     let callees = [];
+    let modifiers = new Set;
     let forbid = [];
     let required = [];
     let requiredLabel = "";
@@ -6903,6 +7058,7 @@ var testsTitles = defineRule63({
         const options = optionsFirst(context);
         const flags = options.flags ?? "";
         callees = options.callees;
+        modifiers = new Set(options.modifiers ?? testsTitlesModifiers);
         forbid = options.deny === undefined ? [] : [options.deny].flat().map((source) => ({ regex: new RegExp(source, flags), pattern: source }));
         required = optionsPatternsWithEmpty(options.require, flags);
         requiredLabel = optionsPatternLabel(options.require);
@@ -6913,7 +7069,7 @@ var testsTitles = defineRule63({
       CallExpression(node) {
         const title = node.arguments.at(0);
         const callee = node.callee;
-        const configured = astMatchesCallee(astDottedName(callee), callees, testsTitlesModifiers) || callee.type === "CallExpression" && astMatchesCallee(astDottedName(callee.callee), callees, testsTitlesModifiers) || callee.type === "TaggedTemplateExpression" && astMatchesCallee(astDottedName(callee.tag), callees, testsTitlesModifiers);
+        const configured = astMatchesCallee(astDottedName(callee), callees, modifiers) || callee.type === "CallExpression" && astMatchesCallee(astDottedName(callee.callee), callees, modifiers) || callee.type === "TaggedTemplateExpression" && astMatchesCallee(astDottedName(callee.tag), callees, modifiers);
         if (!title || !configured) {
           return;
         }
@@ -6942,11 +7098,11 @@ var testsTitles = defineRule63({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule64({
+var typesDeclarations = defineRule65({
   meta: {
     type: "problem",
     schema: [
@@ -6989,7 +7145,7 @@ var typesDeclarations = defineRule64({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
+import { defineRule as defineRule66 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -7001,7 +7157,7 @@ function importedAliasTarget(declaration, imports) {
   const { name } = type.typeName;
   return imports.has(name) && !declaration.typeParameters?.params.some((parameter) => parameter.name.name === name) ? name : undefined;
 }
-var typesImportedAlias = defineRule65({
+var typesImportedAlias = defineRule66({
   meta: {
     type: "problem",
     schema: [],
@@ -7063,7 +7219,7 @@ var typesImportedAlias = defineRule65({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
+import { defineRule as defineRule67 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -7073,7 +7229,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule66({
+var typesInline = defineRule67({
   meta: {
     type: "problem",
     schema: [
@@ -7149,8 +7305,8 @@ var typesInline = defineRule66({
 var typesLocalAlias = astSelectorRule("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.");
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule67({
+import { defineRule as defineRule68 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule68({
   meta: {
     type: "suggestion",
     schema: [
@@ -7192,26 +7348,50 @@ var typesNamespaceImport = defineRule67({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
-var typesService = defineRule68({
+import { defineRule as defineRule69 } from "@oxlint/plugins";
+var typesService = defineRule69({
   meta: {
     type: "problem",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          suffix: { type: "string", minLength: 1, default: "Service" },
+          factory: { type: "string", minLength: 1, default: "make" }
+        }
+      }
+    ],
     messages: {
-      domain: "Move this type to its domain types file; only the matching factory-derived Service alias belongs here."
+      domain: "Move this type to its domain types file; only the matching factory-derived {{suffix}} alias belongs here."
     }
   },
   createOnce(context) {
+    let suffix = "Service";
+    let factory = "make";
     return {
+      before() {
+        const options = optionsFirst(context, {});
+        suffix = options.suffix ?? "Service";
+        factory = options.factory ?? "make";
+      },
       TSInterfaceDeclaration(node) {
-        context.report({ node, messageId: "domain" });
+        context.report({
+          node,
+          messageId: "domain",
+          data: { suffix }
+        });
       },
       TSTypeAliasDeclaration(node) {
         const type = node.typeAnnotation;
         const argument = type.type === "TSTypeReference" && type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
-        const isFactoryService = node.id.name.endsWith("Service") && type.type === "TSTypeReference" && type.typeName.type === "Identifier" && type.typeName.name === "ReturnType" && argument?.type === "TSTypeQuery" && argument.exprName.type === "Identifier" && argument.exprName.name === `make${node.id.name}`;
+        const isFactoryService = node.id.name.endsWith(suffix) && type.type === "TSTypeReference" && type.typeName.type === "Identifier" && type.typeName.name === "ReturnType" && argument?.type === "TSTypeQuery" && argument.exprName.type === "Identifier" && argument.exprName.name === `${factory}${node.id.name}`;
         if (!isFactoryService) {
-          context.report({ node, messageId: "domain" });
+          context.report({
+            node,
+            messageId: "domain",
+            data: { suffix }
+          });
         }
       }
     };
@@ -7219,12 +7399,12 @@ var typesService = defineRule68({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
+import { defineRule as defineRule70 } from "@oxlint/plugins";
 function isCatchName(node) {
   const key = "key" in node && !(("computed" in node) && node.computed) ? node.key : undefined;
   return key?.type === "Identifier" && key.name === "catch";
 }
-var typesUnknown = defineRule69({
+var typesUnknown = defineRule70({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {