oxlint-plugin-arch 0.13.0 → 0.13.1

package/dist/index.js

@@ -50,6 +50,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"]);
@@ -237,9 +240,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);
 }
@@ -249,17 +249,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/rules/backend/backend-orpc-output.ts
@@ -842,6 +845,27 @@ import { defineRule as defineRule5 } from "@oxlint/plugins";
 // src/utils/boundaries.utils.ts
 import { builtinModules } from "node:module";
 import { dirname, resolve } from "node:path";
+var boundariesRuntimeConventions = {
+  server: ["server"],
+  rsc: ["rsc"],
+  actions: ["action"],
+  client: ["client"],
+  clientOnly: ["client-only"],
+  hooks: ["hooks"],
+  shared: ["utils", "constants"],
+  lib: "lib"
+};
+var boundariesSuffixList = { type: "array", items: { type: "string", minLength: 1 } };
+function boundariesConventionsFor(options) {
+  return { ...boundariesRuntimeConventions, ...options.conventions };
+}
+function boundariesHasSuffix(suffixes, path, optionalExtension = false) {
+  const extension = optionalExtension ? "(?:\\.[cm]?[jt]sx?)?" : "\\.[cm]?[jt]sx?";
+  return suffixes.length > 0 && new RegExp(`\\.(?:${suffixes.map(optionsEscape).join("|")})${extension}$`).test(path);
+}
+function boundariesIsClientOnly(conventions, target) {
+  return conventions.hooks.some((folder) => target.includes(`/${folder}/`)) || conventions.clientOnly.some((suffix) => new RegExp(`\\.${optionsEscape(suffix)}(?:\\.|$)`).test(target));
+}
 var boundariesServerGlobals = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
 var boundariesBrowserGlobals = [
   "window",
@@ -877,7 +901,21 @@ var boundariesRuntimeProperties = {
   dynamic: { type: "array", items: { type: "string" } },
   serverPackages: { type: "array", items: { type: "string" } },
   clientPackages: { type: "array", items: { type: "string" } },
-  hookPackages: { type: "array", items: { type: "string" } }
+  hookPackages: { type: "array", items: { type: "string" } },
+  conventions: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      server: boundariesSuffixList,
+      rsc: boundariesSuffixList,
+      actions: boundariesSuffixList,
+      client: boundariesSuffixList,
+      clientOnly: boundariesSuffixList,
+      hooks: boundariesSuffixList,
+      shared: boundariesSuffixList,
+      lib: { type: "string", minLength: 1 }
+    }
+  }
 };
 var boundariesServerPackages = ["@orpc/server", "react-dom/server"];
 var boundariesRuntimeMessages = {
@@ -908,16 +946,21 @@ function boundariesReport(context, node, source, reason) {
     data: { source, reason }
   });
 }
-function boundariesImportExpression(context, node, allowComputed, check) {
-  const source = boundariesLiteralSource(node);
-  if (source !== undefined) {
-    check(source);
-  } else if (!allowComputed) {
-    context.report({ node, messageId: "computed" });
-  }
+function boundariesRuntimeImportVisitors(context, check, allowComputed) {
+  return {
+    ...boundariesExportVisitors(check),
+    ImportExpression(node) {
+      const source = boundariesLiteralSource(node);
+      if (source !== undefined) {
+        check(node, source, false, false);
+      } else if (!allowComputed()) {
+        context.report({ node, messageId: "computed" });
+      }
+    }
+  };
 }
-function boundariesIsSharedFile(options, file) {
-  return /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options.web.some((path) => file.startsWith(`${path}/lib/`));
+function boundariesIsSharedFile(options, conventions, file) {
+  return boundariesHasSuffix(conventions.shared, file) || options.web.some((path) => file.startsWith(`${path}/${conventions.lib}/`));
 }
 function boundariesDeclaredVariable(start, name) {
   for (let scope = start;scope; scope = scope.upper) {
@@ -946,7 +989,7 @@ function boundariesMemberName(node) {
   }
   return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
 }
-function boundariesResolveTarget(options, file, source) {
+function boundariesResolveTarget(options, file, source, services = "services") {
   const owner = [...options.web, ...options.backend].sort((a, b) => b.length - a.length).find((root) => file.startsWith(`${root}/`));
   const web = owner && options.web.includes(owner) ? owner : undefined;
   const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
@@ -957,13 +1000,13 @@ function boundariesResolveTarget(options, file, source) {
     return resolve(dirname(file), source).replaceAll("\\", "/");
   }
   if (source.startsWith("@/") && web) {
-    return `${web}/${source.slice(2)}`;
+    return resolve(web, source.slice(2)).replaceAll("\\", "/");
   }
   if (source.startsWith("#/") && owner) {
-    return `${owner}/${source.slice(2)}`;
+    return resolve(owner, source.slice(2)).replaceAll("\\", "/");
   }
   if (source.startsWith("#services/") && owner) {
-    return `${owner}/services/${source.slice(10)}`;
+    return resolve(owner, services, source.slice("#services/".length)).replaceAll("\\", "/");
   }
   return source;
 }
@@ -1145,7 +1188,25 @@ var boundariesDeny = defineRule6({
 import { defineRule as defineRule7 } from "@oxlint/plugins";
 import { basename, resolve as resolve2 } from "node:path";
 var boundariesSurfaces = ["service", "client", "server", "rsc", "utils"];
-var boundariesActionOrQuery = /\/(?:[^/]+)-(?:action|query)\./;
+var boundariesConventions = {
+  services: "services",
+  registry: "service",
+  types: "types",
+  lib: "lib",
+  contracts: ["types", "constants"],
+  implementations: ["service", "utils"],
+  implementationFolders: ["core"],
+  operations: ["action", "query"],
+  operationFolders: ["actions", "queries"],
+  domainFiles: ["action", "query", "driver"],
+  clients: ["client"]
+};
+function boundariesAny(values) {
+  return values.length === 0 ? "(?!)" : `(?:${values.map(optionsEscape).join("|")})`;
+}
+function boundariesIsOperation(conventions, path) {
+  return new RegExp(`/[^/]+-${boundariesAny(conventions.operations)}\\.`).test(path);
+}
 function boundariesContains(directory, candidate) {
   return candidate === directory || candidate.startsWith(`${directory}/`);
 }
@@ -1155,44 +1216,56 @@ function boundariesIsSurface(options, stem) {
 function boundariesStripExtension(path) {
   return path.replace(/\.[cm]?[jt]sx?$/, "");
 }
+function boundariesConventionsOf(options) {
+  return { ...boundariesConventions, ...options.conventions };
+}
 function boundariesServiceFolder(options, root) {
   const nested = [...options.web, ...options.backend].filter((other) => other.length > root.length && boundariesContains(root, other));
-  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/services`;
+  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/${boundariesConventionsOf(options).services}`;
 }
-function boundariesDomain(path, appRoot, services) {
+function boundariesDomain(conventions, path, appRoot, services) {
   const relative = path.slice(appRoot.length + 1);
-  if (relative.startsWith("types/") && relative.endsWith(".types.ts")) {
-    return relative.slice("types/".length).split(".")[0];
+  if (relative.startsWith(`${conventions.types}/`) && relative.endsWith(`.${conventions.types}.ts`)) {
+    return relative.slice(conventions.types.length + 1).split(".")[0];
   }
   if (!boundariesContains(services, path) || path === services) {
     return;
   }
   const parts = path.slice(services.length + 1).split("/");
-  return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(/-(?:action|query|driver)$/, "");
+  return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(new RegExp(`-${boundariesAny(conventions.domainFiles)}$`), "");
 }
 function boundariesPrivateDomain({ options, file, target, reExport, roots, owner }) {
   const roles = options.roles;
+  const conventions = boundariesConventionsOf(options);
   if (!roles?.length) {
     return;
   }
   const targetOwner = roots.find((path) => boundariesContains(path, target));
-  const fileDomain = owner ? boundariesDomain(file, owner, boundariesServiceFolder(options, owner)) : undefined;
-  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
+  const fileDomain = owner ? boundariesDomain(conventions, file, owner, boundariesServiceFolder(options, owner)) : undefined;
+  const targetDomain = targetOwner ? boundariesDomain(conventions, target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
   const sameDomain = owner && owner === targetOwner && fileDomain && fileDomain === targetDomain;
   const targetStem = boundariesStripExtension(target);
-  const publicSurface = boundariesIsSurface(options, targetStem) && !boundariesActionOrQuery.test(targetStem);
-  const privateTarget = roles.some((role) => targetStem.endsWith(`.${role}`)) || targetDomain && !publicSurface && !/\.(?:types|constants)$/.test(targetStem);
+  const publicSurface = boundariesIsSurface(options, targetStem) && !boundariesIsOperation(conventions, targetStem);
+  const privateTarget = roles.some((role) => targetStem.endsWith(`.${role}`)) || targetDomain && !publicSurface && !new RegExp(`\\.${boundariesAny(conventions.contracts)}$`).test(targetStem);
   if (!privateTarget) {
     return;
   }
-  if (reExport && file.endsWith(".ts") && boundariesIsSurface(options, file.slice(0, -".ts".length)) && !boundariesActionOrQuery.test(file)) {
+  if (reExport && file.endsWith(".ts") && boundariesIsSurface(options, file.slice(0, -".ts".length)) && !boundariesIsOperation(conventions, 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";
 }
+function boundariesPortableFolder(options) {
+  if (!options.portable) {
+    return;
+  }
+  return typeof options.portable === "string" ? options.portable : boundariesConventionsOf(options).lib;
+}
 function boundariesPortableLib(check) {
   const { options, file, source, target, typeOnly, reExport, roots, web, backendImport } = check;
-  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file) || boundariesServiceFolder(options, web) === `${web}/lib`) {
+  const { types } = boundariesConventionsOf(options);
+  const lib = boundariesPortableFolder(options);
+  if (!lib || !web || !boundariesContains(`${web}/${lib}`, file) || boundariesServiceFolder(options, web) === `${web}/${lib}`) {
     return;
   }
   const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
@@ -1202,11 +1275,11 @@ function boundariesPortableLib(check) {
   if (backendImport || backendTarget || appService || appPackage) {
     return "portable frontend lib does not import application services or application APIs";
   }
-  const appType = roots.some((path) => boundariesContains(`${path}/types`, portableTarget));
+  const appType = roots.some((path) => boundariesContains(`${path}/${types}`, portableTarget));
   const stem = boundariesStripExtension(basename(file)).replace(/\.utils$/, "");
-  const ownType = typeOnly && !reExport && boundariesStripExtension(portableTarget) === `${web}/types/${stem}.types`;
+  const ownType = typeOnly && !reExport && boundariesStripExtension(portableTarget) === `${web}/${types}/${stem}.${types}`;
   if (appType && !ownType) {
-    return `portable frontend lib may only type-import its own contract '${web}/types/${stem}.types.ts'; app type re-exports are forbidden`;
+    return `portable frontend lib may only type-import its own contract '${web}/${types}/${stem}.${types}.ts'; app type re-exports are forbidden`;
   }
   return;
 }
@@ -1225,7 +1298,24 @@ var boundariesImports = defineRule7({
           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" },
+          portable: { anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }] },
+          conventions: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              services: { type: "string", minLength: 1 },
+              registry: { type: "string", minLength: 1 },
+              types: { type: "string", minLength: 1 },
+              lib: { type: "string", minLength: 1 },
+              contracts: { type: "array", items: { type: "string", minLength: 1 } },
+              implementations: { type: "array", items: { type: "string", minLength: 1 } },
+              implementationFolders: { type: "array", items: { type: "string", minLength: 1 } },
+              operations: { type: "array", items: { type: "string", minLength: 1 } },
+              operationFolders: { type: "array", items: { type: "string", minLength: 1 } },
+              domainFiles: { type: "array", items: { type: "string", minLength: 1 } },
+              clients: { type: "array", items: { type: "string", minLength: 1 } }
+            }
+          },
           backendPackages: { type: "array", items: { type: "string" } },
           entrypoints: { type: "array", items: { type: "string" } },
           appPackages: { type: "array", items: { type: "string" } },
@@ -1244,7 +1334,8 @@ var boundariesImports = defineRule7({
       const file = context.filename.replaceAll("\\", "/");
       const roots = [...options.web, ...options.backend].sort((a, b) => b.length - a.length);
       const owner = roots.find((path) => boundariesContains(path, file));
-      const target = boundariesResolveTarget(options, file, source);
+      const conventions = boundariesConventionsOf(options);
+      const target = boundariesResolveTarget(options, file, source, conventions.services);
       const web = owner && options.web.includes(owner) ? owner : undefined;
       const backendImport = options.backend.some((path) => boundariesContains(path, target)) || boundariesMatchesImport(options.backendPackages, source);
       const imported = { options, file, source, target, typeOnly, reExport, roots, owner, web, backendImport };
@@ -1253,13 +1344,16 @@ var boundariesImports = defineRule7({
       const serviceFolders = roots.map((path) => boundariesServiceFolder(options, path));
       const serviceTarget = serviceFolders.find((folder) => boundariesContains(folder, target));
       const serviceFile = serviceFolders.find((folder) => boundariesContains(folder, file));
-      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && (/\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target) || serviceTarget !== undefined && /\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/)/.test(target.slice(serviceTarget.length)));
+      const implementation = `(?:\\.${boundariesAny(conventions.implementations)}|-${boundariesAny(conventions.operations)}\\.|/${boundariesAny(conventions.operationFolders)}/)`;
+      const services = optionsEscape(conventions.services);
+      const domainContract = new RegExp(`\\.${boundariesAny(conventions.contracts)}\\.ts$`).test(file) && !typeOnly && (new RegExp(`/(?:${boundariesAny(conventions.implementationFolders)}/|${services}/.*${implementation})`).test(target) || serviceTarget !== undefined && new RegExp(`/.*${implementation}`).test(target.slice(serviceTarget.length)));
+      const registry = `/${optionsEscape(conventions.registry)}(?:\\.ts)?$`;
       const reason = [
         web && backendImport && !options.entrypoints.includes(source) ? "frontend code uses only public backend entry points" : undefined,
         inPackage && appTarget ? "shared packages do not import app internals" : undefined,
-        (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) || serviceFile !== undefined && /^\/service(?:\.ts)?$/.test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
+        (file.includes(`/${conventions.services}/`) && new RegExp(`/${services}${registry}`).test(target) || serviceFile !== undefined && new RegExp(`^${registry}`).test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
         domainContract ? "domain types/constants use type-only imports from implementations" : undefined,
-        file.endsWith(".client.ts") && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
+        conventions.clients.some((client) => file.endsWith(`.${client}.ts`)) && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
         boundariesPrivateDomain(imported),
         boundariesPortableLib(imported)
       ].findLast((candidate) => candidate !== undefined);
@@ -1300,7 +1394,8 @@ var boundariesImports = defineRule7({
       TSImportType(node) {
         const options = { ...boundariesImportsDefaults, ...optionsFirst(context) };
         const file = context.filename.replaceAll("\\", "/");
-        if (options.portable && options.web.some((path) => file.startsWith(`${path}/lib/`) && boundariesServiceFolder(options, path) !== `${path}/lib`)) {
+        const lib = boundariesPortableFolder(options);
+        if (lib && options.web.some((path) => file.startsWith(`${path}/${lib}/`) && boundariesServiceFolder(options, path) !== `${path}/${lib}`)) {
           check(node, node.source.value, true);
         }
       }
@@ -1344,6 +1439,7 @@ var boundariesNext = defineRule8({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let server = false;
     let client = false;
@@ -1355,12 +1451,12 @@ var boundariesNext = defineRule8({
         return;
       }
       const target = boundariesResolveTarget(options, file, source);
-      const clientOnly = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
+      const clientOnly = boundariesIsClientOnly(conventions, target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
       if (clientOnly && (server || shared)) {
         boundariesReport(context, node, source, "browser-only dependencies do not belong in server, RSC or shared modules");
         return;
       }
-      const serverOnly = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || /\.(?:server|rsc)(?:\.[cm]?[jt]sx?)?$/.test(target) || boundariesMatchesImport(options.server, source);
+      const serverOnly = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || boundariesHasSuffix([...conventions.server, ...conventions.rsc], target, true) || boundariesMatchesImport(options.server, source);
       if (!serverOnly || server) {
         return;
       }
@@ -1369,6 +1465,7 @@ var boundariesNext = defineRule8({
     return {
       Program(program) {
         options = { ...boundariesNextDefaults, ...optionsFirst(context) };
+        conventions = boundariesConventionsFor(options);
         reactNamespaces.clear();
         file = context.filename.replaceAll("\\", "/");
         const directives = new Map;
@@ -1379,9 +1476,9 @@ var boundariesNext = defineRule8({
         }
         const useServer = directives.get("use server");
         const useClient = directives.get("use client");
-        const serverName = /\.(?:server|rsc|action)\.[cm]?[jt]sx?$/.test(file);
-        const clientName = /\.client\.[cm]?[jt]sx?$/.test(file);
-        shared = boundariesIsSharedFile(options, file);
+        const serverName = boundariesHasSuffix([...conventions.server, ...conventions.rsc, ...conventions.actions], file);
+        const clientName = boundariesHasSuffix(conventions.client, file);
+        shared = boundariesIsSharedFile(options, conventions, file);
         server = !useClient && (serverName || Boolean(useServer));
         client = clientName || Boolean(useClient);
         if (useClient && serverName) {
@@ -1398,7 +1495,7 @@ var boundariesNext = defineRule8({
             data: { directive: "use server", side: "client" }
           });
         }
-        if (/\.action\.[cm]?[jt]sx?$/.test(file) && !useServer) {
+        if (boundariesHasSuffix(conventions.actions, file) && !useServer) {
           context.report({ node: program, messageId: "action" });
         }
       },
@@ -1428,10 +1525,7 @@ var boundariesNext = defineRule8({
           boundariesReport(context, node, `${node.object.name}.${name}`, boundariesClientHookReason);
         }
       },
-      ...boundariesExportVisitors(check),
-      ImportExpression(node) {
-        boundariesImportExpression(context, node, Boolean(options.dynamic?.includes(file)), (source) => check(node, source, false));
-      },
+      ...boundariesRuntimeImportVisitors(context, check, () => Boolean(options.dynamic?.includes(file))),
       "Program:exit"() {
         const scope = context.sourceCode.scopeManager.scopes.at(0);
         if (!scope) {
@@ -1548,11 +1642,9 @@ var boundariesTanstackDefaults = {
   hookPackages: ["react", "@tanstack/react-query", "@tanstack/react-router"],
   startPackages: ["@tanstack/react-start"],
   rscPackages: ["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"],
-  renderers: ["renderServerComponent", "renderToReadableStream"]
+  renderers: ["renderServerComponent", "renderToReadableStream"],
+  serverHooks: ["useId"]
 };
-function boundariesIsClientHook(name) {
-  return /^use[A-Z]/.test(name) && name !== "useId";
-}
 var boundariesTanstack = defineRule10({
   meta: {
     type: "problem",
@@ -1565,7 +1657,8 @@ var boundariesTanstack = defineRule10({
           rpc: { type: "array", items: { type: "string" } },
           startPackages: { type: "array", items: { type: "string" } },
           rscPackages: { type: "array", items: { type: "string" } },
-          renderers: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.renderers }
+          renderers: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.renderers },
+          serverHooks: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.serverHooks }
         }
       }
     ],
@@ -1573,6 +1666,7 @@ var boundariesTanstack = defineRule10({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let serverFile = false;
     let rscFile = false;
@@ -1581,6 +1675,7 @@ var boundariesTanstack = defineRule10({
     let referenced;
     let imports = new Map;
     const boundaries = [];
+    const clientHook = (name) => /^use[A-Z]/.test(name) && !options.serverHooks.includes(name);
     function imported(node) {
       const entry = imports.get(node.name);
       const variable = entry ? boundariesDeclaredVariable(context.sourceCode.getScope(node), node.name) : null;
@@ -1623,7 +1718,7 @@ var boundariesTanstack = defineRule10({
         return;
       }
       const target = boundariesResolveTarget(options, file, source);
-      const clientImport = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
+      const clientImport = boundariesIsClientOnly(conventions, target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
       if (clientImport && (serverFile || rscFile || shared) && !clientSide(node.start)) {
         const references = node.type === "ImportDeclaration" ? runtimeReferences(node) : [];
         if (shared || references.length === 0 || !references.every(clientSide)) {
@@ -1631,7 +1726,7 @@ var boundariesTanstack = defineRule10({
         }
         return;
       }
-      const serverImport = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || /\.server(?:\.[cm]?[jt]sx?)?$/.test(target) || boundariesMatchesImport(options.server, source);
+      const serverImport = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || boundariesHasSuffix(conventions.server, target, true) || boundariesMatchesImport(options.server, source);
       if (!renderer && !serverImport) {
         return;
       }
@@ -1659,10 +1754,11 @@ var boundariesTanstack = defineRule10({
     return {
       Program(program) {
         options = { ...boundariesTanstackDefaults, ...optionsFirst(context) };
+        conventions = boundariesConventionsFor(options);
         file = context.filename.replaceAll("\\", "/");
-        serverFile = /\.server\.[cm]?[jt]sx?$/.test(file);
-        rscFile = /\.rsc\.[cm]?[jt]sx?$/.test(file);
-        shared = boundariesIsSharedFile(options, file);
+        serverFile = boundariesHasSuffix(conventions.server, file);
+        rscFile = boundariesHasSuffix(conventions.rsc, file);
+        shared = boundariesIsSharedFile(options, conventions, file);
         runtimeIdentifiers.clear();
         referenced = undefined;
         boundaries.length = 0;
@@ -1729,7 +1825,7 @@ var boundariesTanstack = defineRule10({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !boundariesIsClientHook(specifier.imported.name)) {
+          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !clientHook(specifier.imported.name)) {
             continue;
           }
           const references = runtimeReferences(node, specifier.local.name);
@@ -1738,10 +1834,7 @@ var boundariesTanstack = defineRule10({
           }
         }
       },
-      ...boundariesExportVisitors(check),
-      ImportExpression(node) {
-        boundariesImportExpression(context, node, Boolean(options.dynamic?.includes(file)), (source) => check(node, source, false));
-      },
+      ...boundariesRuntimeImportVisitors(context, check, () => Boolean(options.dynamic?.includes(file))),
       MemberExpression(node) {
         const name = boundariesMemberName(node);
         if (!name || node.object.type !== "Identifier") {
@@ -1751,7 +1844,7 @@ var boundariesTanstack = defineRule10({
         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" && boundariesIsClientHook(name) && !clientSide(node.start)) {
+        if ((serverFile || rscFile) && kind === "client-hooks" && clientHook(name) && !clientSide(node.start)) {
           boundariesReport(context, node, name, boundariesClientHookReason2);
         }
       },
@@ -2230,6 +2323,7 @@ var codeInline = defineRule16({
         properties: {
           max: { type: "integer", minimum: 1, default: 160 },
           nesting: { type: "integer", minimum: 1, default: 2 },
+          callbacks: { type: "boolean", default: false },
           allow: optionsPatternSchema,
           keep: optionsPatternSchema,
           services: { type: "array", items: { type: "string" } }
@@ -2258,7 +2352,8 @@ var codeInline = defineRule16({
         return;
       }
       if (uses.length === 1) {
-        if (init && codeInlineEffectBetween(context.sourceCode.ast, node.range[1], uses[0].identifier.range[0])) {
+        const use = uses[0].identifier;
+        if (init && (codeInlineEffectBetween(context.sourceCode.ast, node.range[1], use.range[0]) || codeInlineEnclosingCalls(use) + astCallDepth(init, options.callbacks ?? false) > (options.nesting ?? 2))) {
           return;
         }
         context.report({
@@ -2270,7 +2365,12 @@ var codeInline = defineRule16({
       }
       const arrow = init?.type === "ArrowFunctionExpression" && init.body.type !== "BlockStatement" && !astSome(init.body, astIsInlineFunction);
       const call = init?.type === "CallExpression" && !astSome(init.arguments, astIsInlineFunction) && astCallDepth(init) <= 2;
-      if (!optionsPatternsTest(kept, id.name) && (arrow || call)) {
+      const text = context.sourceCode.text;
+      const fits = init !== null && uses.every(({ identifier }) => {
+        const line = text.slice(sourceLineStart(text, identifier.range[0]), sourceLineEnd(text, identifier.range[0]));
+        return line.length - id.name.length + context.sourceCode.getText(init).length <= (options.max ?? 160) && codeInlineEnclosingCalls(identifier) + astCallDepth(init, options.callbacks ?? false) <= (options.nesting ?? 2);
+      });
+      if (!optionsPatternsTest(kept, id.name) && (arrow || call) && fits) {
         context.report({
           node: id,
           messageId: "trivial",
@@ -2298,7 +2398,7 @@ var codeInline = defineRule16({
         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) || codeInlineEffectBetween(context.sourceCode.ast, declarator.range[1], use.range[0])) {
+      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init, options.callbacks ?? false) > (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({
@@ -3232,7 +3332,8 @@ var commentsCode = defineRule26({
           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"] }
+          members: { type: "string", enum: ["off", "also", "only"] },
+          steps: { type: "boolean", default: false }
         }
       }
     ],
@@ -3247,9 +3348,31 @@ var commentsCode = defineRule26({
     let allowJsdoc = false;
     let allowed = [];
     let members = "off";
+    let steps = false;
+    let functionDepth = 0;
     const memberComments = new Set;
+    const stepStarts = new Set;
+    function enterFunction() {
+      functionDepth++;
+    }
+    function exitFunction() {
+      functionDepth--;
+    }
+    function addSteps(nodes, inFunction) {
+      if (steps && inFunction) {
+        for (const node of nodes) {
+          stepStarts.add(node.range[0]);
+        }
+      }
+    }
+    function isStep(comment) {
+      const source = context.sourceCode;
+      const before = source.getTokenBefore(comment, { includeComments: true });
+      const after = source.getTokenAfter(comment, { includeComments: true });
+      return comment.type === "Line" && before?.loc.end.line !== comment.loc.start.line && !(before && (before.type === "Line" || before.type === "Block") && before.loc.end.line === comment.loc.start.line - 1) && after !== null && after.type !== "Line" && after.type !== "Block" && after.loc.start.line === comment.loc.end.line + 1 && stepStarts.has(after.range[0]);
+    }
     function keepComment(comment, value, isWhy) {
-      return allowWhy && isWhy || sourceIsDirective(value) || allowJsdoc && comment.type === "Block" && context.sourceCode.text.startsWith("/**", comment.range[0]) || allowed.some((pattern) => pattern.test(value.trim()));
+      return allowWhy && isWhy || sourceIsDirective(value) || allowJsdoc && comment.type === "Block" && context.sourceCode.text.startsWith("/**", comment.range[0]) || allowed.some((pattern) => pattern.test(value.trim())) || steps && isStep(comment);
     }
     function checkMember(node) {
       const parent = node.parent;
@@ -3273,7 +3396,10 @@ var commentsCode = defineRule26({
         allowJsdoc = options.jsdoc ?? false;
         allowed = (options.allow ?? []).map((pattern) => new RegExp(pattern));
         members = options.members ?? "off";
+        steps = options.steps ?? false;
+        functionDepth = 0;
         memberComments.clear();
+        stepStarts.clear();
       },
       TSPropertySignature: checkMember,
       TSMethodSignature: checkMember,
@@ -3282,6 +3408,17 @@ var commentsCode = defineRule26({
       TSConstructSignatureDeclaration: checkMember,
       Property: checkMember,
       SpreadElement: checkMember,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      BlockStatement: (node) => addSteps(node.body, functionDepth > 0),
+      SwitchCase: (node) => addSteps(node.consequent, functionDepth > 0),
+      IfStatement: (node) => addSteps([node.consequent, ...node.alternate ? [node.alternate] : []], functionDepth > 0),
+      "ForStatement, ForInStatement, ForOfStatement, WhileStatement, DoWhileStatement, LabeledStatement": (node) => addSteps([node.body], functionDepth > 0),
+      ObjectExpression: (node) => addSteps(node.properties, true),
       "Program:exit"(program) {
         const text = context.sourceCode.text;
         const found = [];
@@ -3527,6 +3664,7 @@ var effectLayerFile = defineRule29({
           layer: { type: "string" },
           make: { type: "string" },
           prefix: { type: "string" },
+          suffix: { type: "string" },
           builders: { type: "array", items: { type: "string" } },
           layers: optionsPatternSchema,
           services: optionsPatternSchema,
@@ -3539,8 +3677,8 @@ var effectLayerFile = defineRule29({
       notLayer: "`{{layer}}` is built with Layer: a Layer call, a Layer pipe, or a function returning one.",
       builderName: "The Effect that builds the service is named `{{make}}`, one per layer file.",
       moduleMethod: "Only `{{make}}` is an Effect at module level; move this into `{{make}}`, or into a utils file if two files use it.",
-      moduleHelper: "A layer file holds only `{{make}}`, {{prefix}}<Role> layers and `{{layer}}`; move this into `{{make}}`, or into a utils file if two files use it.",
-      localLayer: "A Layer other than `{{layer}}` is named {{prefix}}<Role> and is not exported.",
+      moduleHelper: "A layer file holds only `{{make}}`, {{prefix}}<Role>{{suffix}} layers and `{{layer}}`; move this into `{{make}}`, or into a utils file if two files use it.",
+      localLayer: "A Layer other than `{{layer}}` is named {{prefix}}<Role>{{suffix}} and is not exported.",
       makeReturn: "`{{make}}` returns the service through its tag (Tag.of({ … })), a Context, or a Layer.",
       inlineBuilder: "Build this layer from `{{make}}`, not an inline Effect: Layer.effect(Tag, {{make}}). One built layer per file."
     }
@@ -3549,6 +3687,7 @@ var effectLayerFile = defineRule29({
     let layer = "layer";
     let make = "make";
     let prefix = "layer";
+    let suffix = "";
     let builders = new Set(effectBuilders);
     let layers = [];
     let services = [];
@@ -3565,14 +3704,15 @@ var effectLayerFile = defineRule29({
         const options = optionsFirst(context, {});
         layer = options.layer ?? "layer";
         make = options.make ?? "make";
-        prefix = options.prefix ?? "layer";
+        suffix = options.suffix ?? "";
+        prefix = options.prefix ?? (suffix ? "" : "layer");
         builders = new Set(options.builders ?? effectBuilders);
         constructors = new Set(options.constructors ?? effectLayerFileDefaultConstructors);
-        layers = optionsPatterns(options.layers ?? effectLayerFileDefaultLayers);
+        layers = optionsPatterns(options.layers ?? [...effectLayerFileDefaultLayers, ...suffix ? [`(?:^|\\.)\\w+${optionsEscape(suffix)}$`] : []]);
         services = [...optionsPatterns(options.services ?? effectLayerFileDefaultServices), ...layers];
       },
       Program(program) {
-        const data = { layer, make, prefix };
+        const data = { layer, make, prefix, suffix };
         const declarators = program.body.flatMap((statement) => {
           const declaration = astDeclaration(statement);
           const exported = statement.type === "ExportNamedDeclaration";
@@ -3632,7 +3772,8 @@ var effectLayerFile = defineRule29({
               data
             });
           }
-          if (isLayer && name !== layer && (exported || !name.startsWith(prefix) || !/^[A-Z]\w*$/.test(name.slice(prefix.length)))) {
+          const role = name.endsWith(suffix) ? name.slice(prefix.length, name.length - suffix.length) : "";
+          if (isLayer && name !== layer && (exported || !name.startsWith(prefix) || !/^[A-Z]\w*$/.test(role))) {
             context.report({
               node,
               messageId: "localLayer",
@@ -3669,7 +3810,7 @@ var effectLayerFile = defineRule29({
             context.report({
               node: argument,
               messageId: "inlineBuilder",
-              data: { layer, make, prefix }
+              data: { layer, make, prefix, suffix }
             });
           }
         }
@@ -4548,9 +4689,6 @@ var filesDomainConstants = defineRule36({
 // src/rules/files/files-exports.ts
 import { defineRule as defineRule37 } from "@oxlint/plugins";
 import { posix as posix2 } from "node:path";
-function escapeRegExp(value) {
-  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 var filesExports = defineRule37({
   meta: {
     type: "problem",
@@ -4612,7 +4750,7 @@ var filesExports = defineRule37({
         const camelDomain = namingCamelCase(domain);
         const allowed = (options.names ?? []).map((template) => template.replaceAll("{Domain}", pascalDomain).replaceAll("{domain}", camelDomain));
         const patterns = (options.patterns ?? []).map((template) => {
-          const source = template.replaceAll("{Domain}", escapeRegExp(pascalDomain)).replaceAll("{domain}", escapeRegExp(camelDomain));
+          const source = template.replaceAll("{Domain}", optionsEscape(pascalDomain)).replaceAll("{domain}", optionsEscape(camelDomain));
           return new RegExp(`^(?:${source})$`);
         });
         const allowedLabel = [...allowed, ...patterns.map((pattern) => pattern.toString())].join(", ");
@@ -5443,6 +5581,12 @@ var layoutCallArguments = defineRule46({
             type: "boolean",
             default: true
           },
+          pipe: {
+            type: "object",
+            additionalProperties: false,
+            required: ["min"],
+            properties: { min: { type: "integer", minimum: 2 }, methods: { type: "array", items: { type: "string" } } }
+          },
           hug: {
             type: "object",
             additionalProperties: false,
@@ -5465,6 +5609,7 @@ var layoutCallArguments = defineRule46({
     ],
     messages: {
       multiline: "A call with {{min}}+ arguments puts each argument on its own line.",
+      pipe: "A pipe with {{min}}+ steps puts each step on its own line.",
       hug: "Put every argument on its own line. Only a last callback, object or array may hug the call, after simple arguments.",
       prefer: "Hug the last argument: it is a callback, object or array after simple arguments.",
       join: "This fits on one line, so keep it on one line."
@@ -5474,11 +5619,13 @@ var layoutCallArguments = defineRule46({
     let options = {};
     let minArguments = 3;
     let indentUnit = sourceIndentUnit();
-    const split = (node) => {
+    let pipeMethods = new Set;
+    const isPipe = (node) => node.callee.type === "MemberExpression" && pipeMethods.has(astMemberName(node.callee) ?? "");
+    const split = (node, min, messageId) => {
       const args = node.arguments;
       const last = args.at(-1);
       const source = context.sourceCode;
-      if (args.length < minArguments || !last || args.some((arg) => (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") && arg.loc.start.line !== arg.loc.end.line)) {
+      if (args.length < min || !last || args.some((arg) => (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") && arg.loc.start.line !== arg.loc.end.line)) {
         return;
       }
       const text = source.text;
@@ -5500,8 +5647,8 @@ var layoutCallArguments = defineRule46({
       const argumentIndent = `${baseIndent}${indentUnit}`;
       context.report({
         node,
-        messageId: "multiline",
-        data: { min: String(minArguments) },
+        messageId,
+        data: { min: String(min) },
         fix: unsafe ? undefined : (fixer) => gaps.map((gap, index) => {
           if (index === 0) {
             return fixer.replaceTextRange(gap, `${newline}${argumentIndent}`);
@@ -5519,11 +5666,23 @@ var layoutCallArguments = defineRule46({
       const last = args.at(-1);
       const open = source.getTokenAfter(node.typeArguments ?? node.callee);
       const close = source.getLastToken(node);
-      if (!first || !last || !open || !close || args.every(astIsOneLine) || source.getCommentsInside(node).length > 0) {
+      if (!first || !last || !open || !close || source.getCommentsInside(node).length > 0) {
+        return;
+      }
+      if (args.every(astIsOneLine)) {
+        if (first.loc.start.line > open.loc.end.line && close.loc.start.line === last.loc.end.line) {
+          const newline2 = sourceNewline(text);
+          const base2 = sourceLineIndent(text, open.range[0]);
+          context.report({
+            node,
+            messageId: "hug",
+            fix: (fixer) => sourceRespace(fixer, text, sourceItemGaps(open.range[1], args, close.range[0]), (_, end) => `${newline2}${end ? base2 : `${base2}${indentUnit}`}`)
+          });
+        }
         return;
       }
       const leading = args.slice(0, -1);
-      const canHug = !astIsPipe(node) && leading.every((arg) => astIsOneLine(arg) && astCallDepth(arg) <= 1) && layoutCallArgumentsHuggable(last);
+      const canHug = !isPipe(node) && leading.every((arg) => astIsOneLine(arg) && astCallDepth(arg) <= 1) && layoutCallArgumentsHuggable(last);
       const gaps = sourceItemGaps(open.range[1], args, close.range[0]);
       if (first.loc.start.line > open.loc.end.line) {
         const head = [...leading.map((arg) => source.getText(arg)), text.slice(last.range[0], sourceLineEnd(text, last.range[0]))];
@@ -5569,13 +5728,15 @@ var layoutCallArguments = defineRule46({
     };
     const call = (node) => {
       const source = context.sourceCode;
-      if (options.split !== false) {
-        split(node);
+      if (options.pipe && isPipe(node)) {
+        split(node, options.pipe.min, "pipe");
+      } else if (options.split !== false) {
+        split(node, minArguments, "multiline");
       }
       if (options.hug) {
         hug(node, options.hug.max);
       }
-      if (options.join && !(options.join.keep ?? []).includes(source.getText(node.callee)) && !(astIsPipe(node) && node.arguments.length > 1) && astCallDepth(node) <= (options.join.nesting ?? Number.POSITIVE_INFINITY)) {
+      if (options.join && !(options.join.keep ?? []).includes(source.getText(node.callee)) && !(isPipe(node) && (node.arguments.length > 1 || options.pipe)) && astCallDepth(node) <= (options.join.nesting ?? Number.POSITIVE_INFINITY)) {
         join3(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
       }
     };
@@ -5593,6 +5754,7 @@ var layoutCallArguments = defineRule46({
         options = optionsFirst(context, {});
         minArguments = options.min ?? 3;
         indentUnit = sourceIndentUnit(options.indent);
+        pipeMethods = new Set(options.pipe?.methods ?? ["pipe"]);
       },
       CallExpression: call,
       NewExpression: call,
@@ -5728,12 +5890,19 @@ var layoutCallArray = defineRule47({
 
 // src/rules/layout/layout-call-depth.ts
 import { defineRule as defineRule48 } from "@oxlint/plugins";
-function layoutCallDepthOuter(node) {
+function layoutCallDepthOuter(node, callbacks) {
   const parent = node.parent;
-  if (!parent || parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type.endsWith("Statement")) {
+  if (!parent || !callbacks && (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression")) {
     return;
   }
-  return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent);
+  if (parent.type.endsWith("Statement")) {
+    let owner = parent;
+    while (owner?.type.endsWith("Statement")) {
+      owner = owner.parent;
+    }
+    return callbacks && owner && astIsInlineFunction(owner) ? layoutCallDepthOuter(owner, callbacks) : undefined;
+  }
+  return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent, callbacks);
 }
 var layoutCallDepth = defineRule48({
   meta: {
@@ -5742,7 +5911,7 @@ var layoutCallDepth = defineRule48({
       {
         type: "object",
         additionalProperties: false,
-        properties: { max: { type: "integer", minimum: 1, default: 2 } }
+        properties: { max: { type: "integer", minimum: 1, default: 2 }, callbacks: { type: "boolean", default: false } }
       }
     ],
     messages: {
@@ -5751,10 +5920,11 @@ var layoutCallDepth = defineRule48({
   },
   createOnce(context) {
     let max = 2;
+    let callbacks = false;
     const check = (node) => {
-      const depth = astCallDepth(node);
-      const outer = layoutCallDepthOuter(node);
-      if (!astIsOneLine(node) || depth <= max || outer !== undefined && astIsOneLine(outer) && astCallDepth(outer) > max) {
+      const depth = astCallDepth(node, callbacks);
+      const outer = layoutCallDepthOuter(node, callbacks);
+      if (!astIsOneLine(node) || depth <= max || outer !== undefined && astIsOneLine(outer) && astCallDepth(outer, callbacks) > max) {
         return;
       }
       context.report({
@@ -5765,7 +5935,9 @@ var layoutCallDepth = defineRule48({
     };
     return {
       before() {
-        max = optionsFirst(context, {}).max ?? 2;
+        const options = optionsFirst(context, {});
+        max = options.max ?? 2;
+        callbacks = options.callbacks ?? false;
       },
       CallExpression: check,
       NewExpression: check
@@ -6096,6 +6268,10 @@ var layoutObject = defineRule53({
           min: { type: "integer", minimum: 1, default: 3 },
           scope: { type: "string", enum: ["call-args", "all"], default: "call-args" },
           indent: { ...sourceIndentSchema, default: 2 },
+          params: { type: "boolean", default: false },
+          nested: { type: "boolean", default: false },
+          siblings: { type: "boolean", default: false },
+          inner: { type: "integer", minimum: 1 },
           join: {
             type: "object",
             additionalProperties: false,
@@ -6111,6 +6287,11 @@ var layoutObject = defineRule53({
     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.",
+      nested: "An object holding an object or function should have each property on its own line.",
+      nestedName: "An object holding an object or function should have each property on its own line. Name this call first: split here, it would break a chained call or a ternary.",
+      siblings: "A sibling call in this list splits its object; split this one too.",
+      inner: "An object with {{inner}}+ entries inside a split object should have each entry on its own line.",
+      params: "Destructured parameter with {{min}}+ properties should have each property on its own line.",
       join: "This object fits on one line, so keep it on one line."
     }
   },
@@ -6121,6 +6302,119 @@ var layoutObject = defineRule53({
     let newline = `
 `;
     let join3;
+    let params = false;
+    let nested = false;
+    let siblings = false;
+    let inner;
+    const splitCounts = new WeakMap;
+    function holdsNested(node) {
+      return nested && astIsOneLine(node) && node.properties.some((property) => property.type === "Property" && (property.value.type === "ObjectExpression" && property.value.properties.length > 0 || astIsInlineFunction(property.value))) && !insideOneLineObject(node.parent);
+    }
+    function insideOneLineObject(start) {
+      for (let ancestor = start;ancestor && !ancestor.type.endsWith("Statement"); ancestor = ancestor.parent) {
+        if (ancestor.type === "ObjectExpression" && astIsOneLine(ancestor)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function breaksAround(node) {
+      for (let child = node, parent = node.parent;parent; child = parent, parent = parent.parent) {
+        if (parent.type === "ConditionalExpression" || parent.type === "MemberExpression" && parent.object === child && astIsCall(child)) {
+          return true;
+        }
+        if (astIsInlineFunction(parent) || parent.type.endsWith("Statement") || parent.type.endsWith("Declaration")) {
+          return false;
+        }
+      }
+      return false;
+    }
+    function keptByInner(node) {
+      const parent = node.parent;
+      return inner !== undefined && node.properties.length >= inner && parent.type === "Property" && parent.value === node && !astIsOneLine(parent.parent);
+    }
+    function splitSiblings(node) {
+      const call = node.parent;
+      const list = call.parent;
+      if (!siblings || node.properties.length === 0 || !astIsCall(call) || list?.type !== "ArrayExpression") {
+        return 0;
+      }
+      let counts = splitCounts.get(list);
+      if (!counts) {
+        counts = new Map;
+        for (const element of list.elements) {
+          if (!element || !astIsCall(element)) {
+            continue;
+          }
+          for (const [index, argument] of element.arguments.entries()) {
+            if (argument.type === "ObjectExpression" && !astIsOneLine(argument)) {
+              const key = `${context.sourceCode.getText(element.callee)}#${index}`;
+              counts.set(key, (counts.get(key) ?? 0) + 1);
+            }
+          }
+        }
+        splitCounts.set(list, counts);
+      }
+      return counts.get(`${context.sourceCode.getText(call.callee)}#${call.arguments.indexOf(node)}`) ?? 0;
+    }
+    function joinBlocked(node, call) {
+      const callee = call && astIsCall(call) ? astDottedName(call.callee) : undefined;
+      const kept = callee !== undefined && (join3?.keep ?? []).some((name) => callee === name || callee.endsWith(`.${name}`));
+      return kept || keptByInner(node) || splitSiblings(node) > 1 || node.properties.length === 0 || !node.properties.every(layoutObjectIsFlat) || context.sourceCode.getCommentsInside(node).length > 0;
+    }
+    function reportSplit(node, properties, open, close, messageId) {
+      const source = context.sourceCode;
+      const text = source.text;
+      const baseIndent = sourceLineIndent(text, open);
+      const propertyIndent = `${baseIndent}${indentUnit}`;
+      context.report({
+        node,
+        messageId,
+        data: { min: String(minProperties), inner: String(inner ?? "") },
+        fix: (fixer) => {
+          if (messageId === "nestedName" || properties.length === 0 || source.getCommentsInside(node).length > 0 || !layoutObjectIsWhitespace(text.slice(open + 1, properties[0].range[0]))) {
+            return null;
+          }
+          const gaps = [[open + 1, properties[0].range[0]]];
+          for (const [index, property] of properties.entries()) {
+            const next = properties.at(index + 1);
+            const after = property.range[1];
+            const limit = next ? next.range[0] : close;
+            const between = text.slice(after, limit);
+            const comma = between.indexOf(",");
+            if (comma === -1) {
+              if (next || !layoutObjectIsWhitespace(between)) {
+                return null;
+              }
+              gaps.push([after, close]);
+              continue;
+            }
+            if (!layoutObjectIsWhitespace(between.slice(0, comma)) || !layoutObjectIsWhitespace(between.slice(comma + 1))) {
+              return null;
+            }
+            gaps.push([after + comma + 1, limit]);
+          }
+          return gaps.map((gap, index) => fixer.replaceTextRange(gap, index === gaps.length - 1 ? `${newline}${baseIndent}` : `${newline}${propertyIndent}`));
+        }
+      });
+    }
+    function checkParams(node) {
+      if (!params) {
+        return;
+      }
+      for (const param of node.params) {
+        const pattern = param.type === "AssignmentPattern" ? param.left : param;
+        if (pattern.type !== "ObjectPattern" || pattern.properties.length < minProperties) {
+          continue;
+        }
+        const text = context.sourceCode.text;
+        const close = text.lastIndexOf("}", (pattern.typeAnnotation?.range[0] ?? pattern.range[1]) - 1);
+        if (!text.slice(pattern.range[0], close).includes(`
+`)) {
+          reportSplit(pattern, pattern.properties, pattern.range[0], close, "params");
+        }
+      }
+    }
     return {
       before() {
         const options = optionsFirst(context, {});
@@ -6129,24 +6423,39 @@ var layoutObject = defineRule53({
         indentUnit = sourceIndentUnit(options.indent);
         newline = sourceNewline(context.sourceCode.text);
         join3 = options.join;
+        params = options.params ?? false;
+        nested = options.nested ?? false;
+        siblings = options.siblings ?? false;
+        inner = options.inner;
       },
+      FunctionDeclaration: checkParams,
+      FunctionExpression: checkParams,
+      ArrowFunctionExpression: checkParams,
       ObjectExpression(node) {
         const source = context.sourceCode;
         const text = source.text;
         const properties = node.properties;
-        const split = properties.length >= minProperties;
+        const parent = node.parent;
+        const full = properties.length >= minProperties;
+        const holds = !full && holdsNested(node);
+        if (!full && !holds && astIsOneLine(node) && splitSiblings(node) > 0) {
+          reportSplit(node, properties, node.range[0], node.range[1] - 1, "siblings");
+          return;
+        }
+        if (astIsOneLine(node) && keptByInner(node)) {
+          reportSplit(node, properties, node.range[0], node.range[1] - 1, "inner");
+          return;
+        }
+        const split = full || holds;
         if (split ? !astIsOneLine(node) : !join3 || astIsOneLine(node)) {
           return;
         }
-        const parent = node.parent;
         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) {
+          if (joinBlocked(node, call)) {
             return;
           }
           const gaps = sourceItemGaps(node.range[0] + 1, properties, node.range[1] - 1);
@@ -6162,39 +6471,9 @@ var layoutObject = defineRule53({
           });
           return;
         }
-        const baseIndent = sourceLineIndent(text, node.range[0]);
-        const propertyIndent = `${baseIndent}${indentUnit}`;
-        const close = node.range[1] - 1;
-        context.report({
-          node,
-          messageId: scope === "all" ? "always" : "callArgs",
-          data: { min: String(minProperties) },
-          fix: (fixer) => {
-            if (source.getCommentsInside(node).length > 0 || !layoutObjectIsWhitespace(text.slice(node.range[0] + 1, properties[0].range[0]))) {
-              return null;
-            }
-            const gaps = [[node.range[0] + 1, properties[0].range[0]]];
-            for (const [index, property] of properties.entries()) {
-              const next = properties.at(index + 1);
-              const after = property.range[1];
-              const limit = next ? next.range[0] : close;
-              const between = text.slice(after, limit);
-              const comma = between.indexOf(",");
-              if (comma === -1) {
-                if (next || !layoutObjectIsWhitespace(between)) {
-                  return null;
-                }
-                gaps.push([after, close]);
-                continue;
-              }
-              if (!layoutObjectIsWhitespace(between.slice(0, comma)) || !layoutObjectIsWhitespace(between.slice(comma + 1))) {
-                return null;
-              }
-              gaps.push([after + comma + 1, limit]);
-            }
-            return gaps.map((gap, index) => fixer.replaceTextRange(gap, index === gaps.length - 1 ? `${newline}${baseIndent}` : `${newline}${propertyIndent}`));
-          }
-        });
+        const messageId = scope === "all" ? "always" : "callArgs";
+        const nestedId = breaksAround(node) ? "nestedName" : "nested";
+        reportSplit(node, properties, node.range[0], node.range[1] - 1, holds ? nestedId : messageId);
       }
     };
   }
@@ -6323,19 +6602,29 @@ import { defineRule as defineRule55 } from "@oxlint/plugins";
 var layoutPipe = defineRule55({
   meta: {
     type: "layout",
+    schema: [{ type: "object", additionalProperties: false, properties: { methods: { type: "array", items: { type: "string" } } } }],
     messages: {
-      after: "No ).pipe( after a call that spans lines. Name the value and pipe the name, or pass the call to the step data-first.",
+      after: "No ).{{method}}( after a call that spans lines. Name the value and pipe the name, or pass the call to the step data-first.",
       step: "A pipe step may span lines only through a callback, object or array. Name this call first, then pass the name."
     }
   },
   createOnce(context) {
+    let methods = new Set;
     return {
+      before() {
+        methods = new Set(optionsFirst(context, {}).methods ?? ["pipe"]);
+      },
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type === "MemberExpression" && astMemberName(callee) === "pipe" && astIsCall(callee.object) && !astIsOneLine(callee.object) && callee.property.loc.start.line === callee.object.loc.end.line) {
-          context.report({ node: callee.property, messageId: "after" });
+        const piped = callee.type === "MemberExpression" && methods.has(astMemberName(callee) ?? "");
+        if (piped && astIsCall(callee.object) && !astIsOneLine(callee.object) && callee.property.loc.start.line === callee.object.loc.end.line) {
+          context.report({
+            node: callee.property,
+            messageId: "after",
+            data: { method: astMemberName(callee) ?? "pipe" }
+          });
         }
-        if (!astIsPipe(node)) {
+        if (!piped) {
           return;
         }
         for (const step of node.arguments) {
@@ -6474,10 +6763,70 @@ var layoutTernary = defineRule56({
   }
 });
 
-// src/rules/naming/naming-declarations.ts
+// src/rules/layout/layout-type-arguments.ts
 import { defineRule as defineRule57 } from "@oxlint/plugins";
+var layoutTypeArguments = defineRule57({
+  meta: {
+    type: "layout",
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          min: { type: "integer", minimum: 2, default: 3 },
+          indent: { ...sourceIndentSchema, default: 2 }
+        }
+      }
+    ],
+    messages: {
+      union: "A union of {{min}}+ types in type arguments puts each type on its own line."
+    }
+  },
+  createOnce(context) {
+    let minMembers = 3;
+    let indentUnit = sourceIndentUnit();
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        minMembers = options.min ?? 3;
+        indentUnit = sourceIndentUnit(options.indent);
+      },
+      TSTypeParameterInstantiation(node) {
+        const unions = node.params.flatMap((param) => param.type === "TSUnionType" && param.types.length >= minMembers ? [param] : []);
+        if (unions.length === 0 || !astIsOneLine(node)) {
+          return;
+        }
+        const source = context.sourceCode;
+        const text = source.text;
+        const items = node.params.flatMap((param) => param.type === "TSUnionType" && unions.includes(param) ? param.types : [param]);
+        const gaps = sourceItemGaps(node.range[0] + 1, items, node.range[1] - 1);
+        const firsts = new Set(unions.map((union) => union.types[0]));
+        const matches = gaps.map((gap) => /^\s*(,?)\s*(\|?)\s*$/.exec(text.slice(...gap)));
+        const newline = sourceNewline(text);
+        const base = sourceLineIndent(text, node.range[0]);
+        const inner = `${base}${indentUnit}`;
+        const unsafe = text[node.range[0]] !== "<" || text[node.range[1] - 1] !== ">" || source.getCommentsInside(node).length > 0 || matches.some((match) => !match);
+        context.report({
+          node,
+          messageId: "union",
+          data: { min: String(minMembers) },
+          fix: unsafe ? undefined : (fixer) => gaps.map((gap, index) => {
+            const comma = matches[index]?.[1] ?? "";
+            const next = items.at(index);
+            const bar = matches[index]?.[2] || next && firsts.has(next) ? "| " : "";
+            return fixer.replaceTextRange(gap, next ? `${comma}${newline}${inner}${bar}` : `${comma}${newline}${base}`);
+          })
+        });
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-declarations.ts
+import { defineRule as defineRule58 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule57({
+var namingDeclarations = defineRule58({
   meta: {
     type: "problem",
     schema: [
@@ -6554,7 +6903,7 @@ var namingDeclarations = defineRule57({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
+import { defineRule as defineRule59 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -6580,7 +6929,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule58({
+var namingExports = defineRule59({
   meta: {
     type: "problem",
     schema: {
@@ -6717,10 +7066,10 @@ var namingExports = defineRule58({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
+import { defineRule as defineRule60 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule59({
+var namingFile = defineRule60({
   meta: {
     type: "problem",
     schema: {
@@ -6790,9 +7139,9 @@ var namingFile = defineRule59({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { defineRule as defineRule61 } from "@oxlint/plugins";
 import { posix as posix3 } from "node:path";
-var namingFolder = defineRule60({
+var namingFolder = defineRule61({
   meta: {
     type: "problem",
     schema: [
@@ -6857,45 +7206,174 @@ var namingFolder = defineRule60({
 });
 
 // src/rules/naming/naming-types.ts
-var namingTypes = astSelectorRule("TSInterfaceDeclaration:not([id.name=/^[A-Z][a-zA-Z0-9]*$/])", "Use PascalCase for interfaces.");
+import { defineRule as defineRule62 } from "@oxlint/plugins";
+var namingTypes = defineRule62({
+  meta: {
+    type: "problem",
+    schema: [{ type: "object", additionalProperties: false, properties: { pattern: optionsPatternSchema, message: { type: "string" } } }],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let patterns = [];
+    let message = "";
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        patterns = optionsPatterns(options.pattern ?? "^[A-Z][a-zA-Z0-9]*$");
+        message = options.message ?? "Use PascalCase for interfaces.";
+      },
+      TSInterfaceDeclaration(node) {
+        if (!optionsPatternsTest(patterns, node.id.name)) {
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message }
+          });
+        }
+      }
+    };
+  }
+});
 
 // src/rules/react/react-dynamic-classes.ts
-var reactDynamicClasses = astSelectorRule(':matches(JSXAttribute[name.name="className"] TemplateLiteral[expressions.length>0], JSXAttribute[name.name="className"] BinaryExpression[operator="+"])', "Write complete class names instead of constructing them dynamically.");
+import { defineRule as defineRule63 } from "@oxlint/plugins";
+var reactDynamicClasses = defineRule63({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { attributes: { type: "array", items: { type: "string" } }, message: { type: "string" } }
+      }
+    ],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let attributes = new Set;
+    let message = "";
+    const check = (node) => {
+      for (let parent = node.parent;parent; parent = parent.parent) {
+        if (parent.type === "JSXAttribute" && parent.name.type === "JSXIdentifier" && attributes.has(parent.name.name)) {
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message }
+          });
+          return;
+        }
+      }
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        attributes = new Set(options.attributes ?? ["className"]);
+        message = options.message ?? "Write complete class names instead of constructing them dynamically.";
+      },
+      "JSXAttribute TemplateLiteral[expressions.length>0]": check,
+      'JSXAttribute BinaryExpression[operator="+"]': check
+    };
+  }
+});
 
 // src/rules/react/react-empty-effect.ts
-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.");
+import { defineRule as defineRule64 } from "@oxlint/plugins";
+var reactEmptyEffect = defineRule64({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { hooks: { type: "array", items: { type: "string" } }, message: { type: "string" } }
+      }
+    ],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let hooks = new Set;
+    let message = "";
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        hooks = new Set(options.hooks ?? ["useEffect", "useLayoutEffect", "React.useEffect", "React.useLayoutEffect"]);
+        message = options.message ?? "Remove the empty effect.";
+      },
+      CallExpression(node) {
+        if (!hooks.has(astDottedName(node.callee) ?? "")) {
+          return;
+        }
+        for (const argument of node.arguments) {
+          if (astIsInlineFunction(argument) && argument.body?.type === "BlockStatement" && argument.body.body.length === 0) {
+            context.report({
+              node: argument.body,
+              messageId: "forbidden",
+              data: { message }
+            });
+          }
+        }
+      }
+    };
+  }
+});
 
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
-var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule61({
+import { defineRule as defineRule65 } from "@oxlint/plugins";
+var reactMemo = defineRule65({
   meta: {
     type: "problem",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          names: { type: "array", items: { type: "string" } },
+          sources: { type: "array", items: { type: "string" } },
+          message: { type: "string" }
+        }
+      }
+    ],
     messages: {
-      memo: "Use the React Compiler rather than manual memoization."
+      memo: "{{message}}"
     }
   },
   createOnce(context) {
+    let names = [];
+    let sources = [];
+    let message = "";
     return {
+      before() {
+        const options = optionsFirst(context, {});
+        names = options.names ?? ["memo", "useMemo", "useCallback"];
+        sources = options.sources ?? ["react"];
+        message = options.message ?? "Use the React Compiler rather than manual memoization.";
+      },
       ImportDeclaration(node) {
-        if (node.source.value !== "react") {
+        if (!sources.includes(node.source.value)) {
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === "ImportSpecifier" && reactMemoNames.includes(astModuleName(specifier.imported))) {
-            context.report({ node: specifier, messageId: "memo" });
+          if (specifier.type === "ImportSpecifier" && names.includes(astModuleName(specifier.imported))) {
+            context.report({
+              node: specifier,
+              messageId: "memo",
+              data: { message }
+            });
           }
         }
       },
       MemberExpression(node) {
-        if (node.object.type !== "Identifier" || !reactMemoNames.includes(astMemberName(node) ?? "")) {
+        if (node.object.type !== "Identifier" || !names.includes(boundariesMemberName(node) ?? "")) {
           return;
         }
         const variable = boundariesDeclaredVariable(context.sourceCode.getScope(node), node.object.name);
-        const isReact = variable ? variable.defs.some((def) => def.type === "ImportBinding" && def.node.type !== "ImportSpecifier" && def.parent?.type === "ImportDeclaration" && def.parent.source.value === "react") : node.object.name === "React";
+        const isReact = variable ? variable.defs.some((def) => def.type === "ImportBinding" && (def.node.type !== "ImportSpecifier" || astModuleName(def.node.imported) === "default") && def.parent?.type === "ImportDeclaration" && sources.includes(def.parent.source.value)) : node.object.name === "React" && sources.includes("react");
         if (isReact) {
-          context.report({ node, messageId: "memo" });
+          context.report({
+            node,
+            messageId: "memo",
+            data: { message }
+          });
         }
       }
     };
@@ -6903,7 +7381,7 @@ var reactMemo = defineRule61({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
+import { defineRule as defineRule66 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -6930,7 +7408,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 = defineRule62({
+var reactProps = defineRule66({
   meta: {
     type: "problem",
     schema: [
@@ -7029,8 +7507,8 @@ var reactProps = defineRule62({
 });
 
 // src/rules/react/react-query-props.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
-var reactQueryProps = defineRule63({
+import { defineRule as defineRule67 } from "@oxlint/plugins";
+var reactQueryProps = defineRule67({
   meta: {
     type: "problem",
     schema: [
@@ -7111,7 +7589,7 @@ var reactQueryProps = defineRule63({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
+import { defineRule as defineRule68 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -7147,7 +7625,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule64({
+var schemasInline = defineRule68({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -7196,11 +7674,11 @@ var schemasInline = defineRule64({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
+import { defineRule as defineRule69 } 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 = defineRule65({
+var schemasLocal = defineRule69({
   meta: {
     type: "problem",
     schema: [
@@ -7349,8 +7827,8 @@ var schemasLocal = defineRule65({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
-var schemasRederive = defineRule66({
+import { defineRule as defineRule70 } from "@oxlint/plugins";
+var schemasRederive = defineRule70({
   meta: {
     type: "problem",
     schema: [
@@ -7396,7 +7874,7 @@ var schemasRederive = defineRule66({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
+import { defineRule as defineRule71 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -7410,7 +7888,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule67({
+var schemasSingleUse = defineRule71({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -7486,7 +7964,7 @@ var schemasSingleUse = defineRule67({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { defineRule as defineRule72 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -7676,7 +8154,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule68({
+var testsAssertions = defineRule72({
   meta: {
     type: "problem",
     schema: [
@@ -7802,8 +8280,8 @@ var testsAssertions = defineRule68({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule69({
+import { defineRule as defineRule73 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule73({
   meta: {
     type: "problem",
     schema: [
@@ -7859,7 +8337,7 @@ var testsConcurrentDb = defineRule69({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
+import { defineRule as defineRule74 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
 var testsModifiersBanned = ["only", "skip", "todo"];
@@ -7878,7 +8356,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule70({
+var testsModifiers = defineRule74({
   meta: {
     type: "problem",
     schema: [
@@ -7932,9 +8410,9 @@ var testsModifiers = defineRule70({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule71 } from "@oxlint/plugins";
+import { defineRule as defineRule75 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule71({
+var testsTitles = defineRule75({
   meta: {
     type: "suggestion",
     schema: [
@@ -8012,11 +8490,11 @@ var testsTitles = defineRule71({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule72 } from "@oxlint/plugins";
+import { defineRule as defineRule76 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule72({
+var typesDeclarations = defineRule76({
   meta: {
     type: "problem",
     schema: [
@@ -8067,8 +8545,8 @@ var typesDeclarations = defineRule72({
 });
 
 // src/rules/types/types-duplicate.ts
-import { defineRule as defineRule73 } from "@oxlint/plugins";
-var typesDuplicate = defineRule73({
+import { defineRule as defineRule77 } from "@oxlint/plugins";
+var typesDuplicate = defineRule77({
   meta: {
     type: "suggestion",
     schema: [
@@ -8132,7 +8610,7 @@ var typesDuplicate = defineRule73({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule74 } from "@oxlint/plugins";
+import { defineRule as defineRule78 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -8144,7 +8622,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 = defineRule74({
+var typesImportedAlias = defineRule78({
   meta: {
     type: "problem",
     schema: [],
@@ -8206,7 +8684,7 @@ var typesImportedAlias = defineRule74({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule75 } from "@oxlint/plugins";
+import { defineRule as defineRule79 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -8216,7 +8694,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule75({
+var typesInline = defineRule79({
   meta: {
     type: "problem",
     schema: [
@@ -8328,11 +8806,38 @@ var typesInline = defineRule75({
 });
 
 // src/rules/types/types-local-alias.ts
-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.");
+import { defineRule as defineRule80 } from "@oxlint/plugins";
+var typesLocalAlias = defineRule80({
+  meta: {
+    type: "problem",
+    schema: [{ type: "object", additionalProperties: false, properties: { allow: optionsPatternSchema, message: { type: "string" } } }],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let allow = [];
+    let message = "";
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        allow = optionsPatterns(options.allow);
+        message = options.message ?? "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface.";
+      },
+      TSTypeAliasDeclaration(node) {
+        if (!optionsPatternsTest(allow, node.id.name)) {
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message }
+          });
+        }
+      }
+    };
+  }
+});
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule76 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule76({
+import { defineRule as defineRule81 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule81({
   meta: {
     type: "suggestion",
     schema: [
@@ -8374,8 +8879,8 @@ var typesNamespaceImport = defineRule76({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule77 } from "@oxlint/plugins";
-var typesService = defineRule77({
+import { defineRule as defineRule82 } from "@oxlint/plugins";
+var typesService = defineRule82({
   meta: {
     type: "problem",
     schema: [
@@ -8425,12 +8930,12 @@ var typesService = defineRule77({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule78 } from "@oxlint/plugins";
+import { defineRule as defineRule83 } 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 = defineRule78({
+var typesUnknown = defineRule83({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -8514,6 +9019,7 @@ var src_default = eslintCompatPlugin({
     "layout-padding": layoutPadding,
     "layout-pipe": layoutPipe,
     "layout-ternary": layoutTernary,
+    "layout-type-arguments": layoutTypeArguments,
     "naming-declarations": namingDeclarations,
     "naming-exports": namingExports,
     "naming-file": namingFile,