oxlint-plugin-arch 0.12.6 → 0.13.1

package/dist/index.js

@@ -37,7 +37,7 @@ function optionsPatternsTest(patterns, value) {
 function optionsGlob(pattern) {
   const negated = [];
   const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
-    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\?{}]/g, "\\$&").replaceAll("*", "[^/]*")).join("|"));
     return `\x02${negated.length - 1}\x03`;
   }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
   return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
@@ -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
@@ -283,16 +286,14 @@ var backendOrpcOutput = defineRule2({
         type: "object",
         additionalProperties: false,
         properties: {
-          composers: { type: "array", items: { type: "string" } },
           handler: { type: "string" },
           output: { type: "string" }
-        },
-        required: ["composers"]
+        }
       }
     ],
     messages: {
       missing: "oRPC procedures must declare .output() before .handler().",
-      invalid: "oRPC .output() must use a named schema or configured composer with a named schema."
+      invalid: "oRPC .output() must use a named schema or a plain function called with a named schema."
     }
   },
   createOnce(context) {
@@ -301,7 +302,7 @@ var backendOrpcOutput = defineRule2({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { composers, handler: handlerMethod = "handler", output: outputMethod = "output" } = optionsFirst(context);
+        const { handler: handlerMethod = "handler", output: outputMethod = "output" } = optionsFirst(context, {});
         if (astMemberName(node.callee) !== handlerMethod) {
           return;
         }
@@ -311,7 +312,7 @@ var backendOrpcOutput = defineRule2({
           return;
         }
         const schema = output.arguments.at(0);
-        const named = schema?.type === "Identifier" || schema?.type === "CallExpression" && schema.callee.type === "Identifier" && composers.includes(schema.callee.name) && schema.arguments[0]?.type === "Identifier";
+        const named = schema?.type === "Identifier" || schema?.type === "CallExpression" && schema.callee.type === "Identifier" && schema.arguments[0]?.type === "Identifier";
         if (!named) {
           context.report({ node: output, messageId: "invalid" });
         }
@@ -844,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",
@@ -879,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 = {
@@ -910,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) {
@@ -948,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}/`));
@@ -959,18 +1000,24 @@ 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;
 }
 
 // src/rules/backend/backend-sql-like.ts
+var backendSqlLikeDefaults = {
+  methods: ["like", "ilike"],
+  sanitizers: ["escapeLikeWildcards"],
+  bindings: true,
+  operators: ["where"]
+};
 var backendSqlLike = defineRule5({
   meta: {
     type: "problem",
@@ -983,17 +1030,16 @@ var backendSqlLike = defineRule5({
           sanitizers: { type: "array", items: { type: "string" } },
           bindings: { type: "boolean" },
           operators: { type: "array", items: { type: "string" } }
-        },
-        required: ["methods", "sanitizers"]
+        }
       }
     ],
     messages: { unescaped: ".{{method}}() values must use a configured sanitizer." }
   },
   createOnce(context) {
-    let options = { methods: [], sanitizers: [] };
+    let options = backendSqlLikeDefaults;
     const seen = new Set;
     function sanitizedBinding(identifier, name) {
-      const variable = options.bindings === false ? null : boundariesDeclaredVariable(context.sourceCode.getScope(identifier), name);
+      const variable = options.bindings ? boundariesDeclaredVariable(context.sourceCode.getScope(identifier), name) : null;
       const declarator = variable?.defs.length === 1 && variable.defs[0].type === "Variable" ? variable.defs[0].node : undefined;
       const statement = declarator?.parent?.parent;
       if (!variable || declarator?.type !== "VariableDeclarator" || seen.has(variable) || !(statement?.type === "Program" || statement?.type === "ExportNamedDeclaration" && statement.parent.type === "Program") || variable.references.some((reference) => reference.isWrite() && !reference.init)) {
@@ -1034,8 +1080,8 @@ var backendSqlLike = defineRule5({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        options = optionsFirst(context);
-        const { methods, operators: operatorMethods = [] } = options;
+        options = { ...backendSqlLikeDefaults, ...optionsFirst(context, {}) };
+        const { methods, operators: operatorMethods } = options;
         const method = astMemberName(node.callee);
         if (!method) {
           return;
@@ -1142,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}/`);
 }
@@ -1152,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;
@@ -1199,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;
 }
@@ -1222,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" } },
@@ -1241,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 };
@@ -1250,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);
@@ -1297,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);
         }
       }
@@ -1341,6 +1439,7 @@ var boundariesNext = defineRule8({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let server = false;
     let client = false;
@@ -1352,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;
       }
@@ -1366,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;
@@ -1376,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) {
@@ -1395,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" });
         }
       },
@@ -1425,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) {
@@ -1545,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",
@@ -1562,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 }
         }
       }
     ],
@@ -1570,6 +1666,7 @@ var boundariesTanstack = defineRule10({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let serverFile = false;
     let rscFile = false;
@@ -1578,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;
@@ -1620,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)) {
@@ -1628,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;
       }
@@ -1656,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;
@@ -1726,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);
@@ -1735,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") {
@@ -1748,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);
         }
       },
@@ -2016,12 +2112,82 @@ var codeConstructor = defineRule13({
   }
 });
 
+// src/rules/code/code-delegate.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var codeDelegate = defineRule14({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          methods: { type: "array", items: { type: "string" } },
+          reads: { type: "array", items: { type: "string" } },
+          max: { type: "integer", minimum: 0 }
+        }
+      }
+    ],
+    messages: {
+      statement: "A handler only delegates: read services, make one call, return. Move this to an action.",
+      calls: "A handler's yielded or awaited calls are limited to {{max}}; move the rest into the action it calls.",
+      ternary: "A handler does not branch; move the condition into the action it calls.",
+      nested: "A handler holds no function; move it into the action it calls."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const { methods = ["handler", "effect"], reads = ["Effect.serviceOption"], max = 1 } = optionsFirst(context, {});
+        if (!methods.includes(astCallName(node) ?? "")) {
+          return;
+        }
+        const awaited = (value) => value?.type === "YieldExpression" || value?.type === "AwaitExpression";
+        for (const handler of node.arguments.filter(astIsInlineFunction)) {
+          let calls = 0;
+          const scan = (value) => astSome(value, (child) => {
+            if (child.type === "ConditionalExpression") {
+              context.report({ node: child, messageId: "ternary" });
+            }
+            if (child.type === "FunctionDeclaration" || astIsInlineFunction(child)) {
+              context.report({ node: child, messageId: "nested" });
+            }
+            const target = awaited(child) && "argument" in child ? child.argument : null;
+            if (target?.type === "CallExpression" && !reads.includes(astDottedName(target.callee) ?? "")) {
+              calls += 1;
+              if (calls > max) {
+                context.report({
+                  node: child,
+                  messageId: "calls",
+                  data: { max: String(max) }
+                });
+              }
+            }
+            return false;
+          }, (child) => child.type !== "FunctionDeclaration" && !astIsInlineFunction(child));
+          const { body } = handler;
+          if (body && body.type !== "BlockStatement") {
+            scan(body);
+          }
+          for (const statement of body?.type === "BlockStatement" ? body.body : []) {
+            const allowed = statement.type === "ReturnStatement" || statement.type === "VariableDeclaration" && statement.declarations.every((declarator) => awaited(declarator.init)) || statement.type === "ExpressionStatement" && awaited(statement.expression) && "argument" in statement.expression && statement.expression.argument?.type === "CallExpression";
+            if (!allowed) {
+              context.report({ node: statement, messageId: "statement" });
+            }
+            scan(statement);
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/code/code-double-negation.ts
 var codeDoubleNegation = astSelectorRule('UnaryExpression[operator="!"] > UnaryExpression[operator="!"]', "Use Boolean(value) or an explicit comparison.");
 
 // src/rules/code/code-function-nesting.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var codeFunctionNesting = defineRule14({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var codeFunctionNesting = defineRule15({
   meta: {
     type: "suggestion",
     schema: [
@@ -2062,7 +2228,7 @@ var codeFunctionNesting = defineRule14({
 });
 
 // src/rules/code/code-inline.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } 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])/;
@@ -2147,7 +2313,7 @@ var codeInlineEffects = new Set([
 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({
+var codeInline = defineRule16({
   meta: {
     type: "suggestion",
     schema: [
@@ -2157,6 +2323,7 @@ var codeInline = defineRule15({
         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" } }
@@ -2185,7 +2352,8 @@ var codeInline = defineRule15({
         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({
@@ -2197,7 +2365,12 @@ var codeInline = defineRule15({
       }
       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",
@@ -2225,7 +2398,7 @@ var codeInline = defineRule15({
         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({
@@ -2260,8 +2433,8 @@ var codeInline = defineRule15({
 });
 
 // src/rules/code/code-justified-call.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var codeJustifiedCall = defineRule16({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var codeJustifiedCall = defineRule17({
   meta: {
     type: "problem",
     schema: [
@@ -2315,8 +2488,8 @@ var codeJustifiedCall = defineRule16({
 });
 
 // src/rules/code/code-literal-in.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var codeLiteralIn = defineRule17({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var codeLiteralIn = defineRule18({
   meta: {
     type: "suggestion",
     schema: [
@@ -2357,7 +2530,7 @@ var codeLiteralIn = defineRule17({
 });
 
 // src/rules/code/code-mutable-state.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 var functionScopes = new Set([
   "FunctionDeclaration",
   "FunctionExpression",
@@ -2374,7 +2547,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule18({
+var codeMutableState = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2432,7 +2605,7 @@ var codeMutableState = defineRule18({
 });
 
 // src/rules/code/code-object-params.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function isObjectParam(node) {
   if (node.type === "ObjectPattern") {
     return true;
@@ -2446,7 +2619,7 @@ function isObjectParam(node) {
   const annotation = node.typeAnnotation?.typeAnnotation;
   return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
 }
-var codeObjectParams = defineRule19({
+var codeObjectParams = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2495,8 +2668,8 @@ var codeObjectParams = defineRule19({
 });
 
 // src/rules/code/code-paired-call.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var codePairedCall = defineRule20({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var codePairedCall = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2563,7 +2736,7 @@ var codePairedCall = defineRule20({
 });
 
 // src/rules/code/code-promise-mutation.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2592,7 +2765,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule21({
+var codePromiseMutation = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2685,8 +2858,8 @@ var codePromiseMutation = defineRule21({
 var codeSwitch = astSelectorRule("SwitchStatement", "Avoid switch statements.");
 
 // src/rules/code/code-traced.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var codeTraced = defineRule22({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var codeTraced = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2773,7 +2946,7 @@ var codeTraced = defineRule22({
 });
 
 // src/rules/code/code-trivial-functions.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 var codeTrivialFunctionsBanned = [
   "isRecord",
   "isPlainObject",
@@ -2903,7 +3076,35 @@ function guardStatement(node, state) {
     return guardFallback(declaration.init);
   });
 }
-var codeTrivialFunctions = defineRule23({
+function codeTrivialFunctionsDefaults(program) {
+  const starts = [];
+  const names = new Set;
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportDefaultDeclaration" ? statement.declaration : undefined;
+    if (declaration?.type === "FunctionDeclaration" || declaration && astIsInlineFunction(declaration)) {
+      starts.push(declaration.start);
+    } else if (declaration?.type === "Identifier") {
+      names.add(declaration.name);
+    } else if (statement.type === "ExportNamedDeclaration" && !statement.source) {
+      const specifier = statement.specifiers.find((item) => astModuleName(item.exported) === "default");
+      if (specifier) {
+        names.add(astModuleName(specifier.local));
+      }
+    }
+  }
+  for (const statement of program.body) {
+    if (statement.type === "FunctionDeclaration" && statement.id && names.has(statement.id.name)) {
+      starts.push(statement.start);
+    }
+    for (const declarator of statement.type === "VariableDeclaration" ? statement.declarations : []) {
+      if (declarator.id.type === "Identifier" && names.has(declarator.id.name) && declarator.init && astIsInlineFunction(declarator.init)) {
+        starts.push(declarator.init.start);
+      }
+    }
+  }
+  return starts;
+}
+var codeTrivialFunctions = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -2917,7 +3118,8 @@ var codeTrivialFunctions = defineRule23({
           services: { type: "boolean" },
           mode: { type: "string", enum: ["legacy", "precise"] },
           deny: { type: "array", items: { type: "string" }, uniqueItems: true },
-          guards: { type: "boolean" }
+          guards: { type: "boolean" },
+          defaults: { type: "boolean" }
         }
       }
     ],
@@ -2937,8 +3139,10 @@ var codeTrivialFunctions = defineRule23({
     let checkServiceMethods = false;
     const reported = new Set;
     const checked = new Set;
+    const defaults = new Set;
+    let checkDefaults = true;
     function checkHelper(node) {
-      if (bannedNames.size === 0 && !checkGenericGuards || checked.has(node.start)) {
+      if (bannedNames.size === 0 && !checkGenericGuards || checked.has(node.start) || defaults.has(node.start)) {
         return;
       }
       checked.add(node.start);
@@ -3003,12 +3207,20 @@ var codeTrivialFunctions = defineRule23({
         allowAsync = options.async ?? false;
         reported.clear();
         checked.clear();
+        defaults.clear();
+        checkDefaults = options.defaults ?? true;
       },
       FunctionDeclaration: checkHelper,
       FunctionExpression: checkHelper,
       ArrowFunctionExpression: checkHelper,
       Program(program) {
+        for (const start of checkDefaults ? [] : codeTrivialFunctionsDefaults(program)) {
+          defaults.add(start);
+        }
         for (const { name, node } of exportsCheckedFunctions(program, true, checkServiceMethods, allowed)) {
+          if (defaults.has(node.start)) {
+            continue;
+          }
           checkHelper(node);
           if (reported.has(node.start) || node.returnType?.typeAnnotation.type === "TSTypePredicate") {
             continue;
@@ -3034,8 +3246,8 @@ var codeTrivialFunctions = defineRule23({
 });
 
 // src/rules/code/code-yield-argument.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var codeYieldArgument = defineRule24({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var codeYieldArgument = defineRule25({
   meta: {
     type: "suggestion",
     messages: {
@@ -3057,7 +3269,7 @@ var codeYieldArgument = defineRule24({
 });
 
 // src/rules/comments/comments-code.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 var commentsLineGap = /^[\t \r\n\u2028\u2029]*$/;
 var commentsLineTerminator = /\r\n|[\n\r\u2028\u2029]/;
 var commentsUnicodeTerminator = /[\u2028\u2029]/;
@@ -3108,7 +3320,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule25({
+var commentsCode = defineRule26({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -3120,7 +3332,8 @@ var commentsCode = defineRule25({
           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 }
         }
       }
     ],
@@ -3135,9 +3348,31 @@ var commentsCode = defineRule25({
     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;
@@ -3161,7 +3396,10 @@ var commentsCode = defineRule25({
         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,
@@ -3170,6 +3408,17 @@ var commentsCode = defineRule25({
       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 = [];
@@ -3274,9 +3523,9 @@ var commentsCode = defineRule25({
 });
 
 // src/rules/comments/comments-directives.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 var directive = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s;
-var commentsDirectives = defineRule26({
+var commentsDirectives = defineRule27({
   meta: {
     type: "problem",
     schema: [],
@@ -3304,9 +3553,9 @@ var commentsDirectives = defineRule26({
 });
 
 // src/rules/copy/copy-dashes.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 var copyDashesMessage = "Use a comma, colon, period or parentheses instead.";
-var copyDashes = defineRule27({
+var copyDashes = defineRule28({
   meta: {
     type: "suggestion",
     schema: [
@@ -3362,7 +3611,7 @@ var copyDashes = defineRule27({
 });
 
 // src/rules/effect/effect-layer-file.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 
 // src/utils/effect.utils.ts
 var effectBuilders = ["Effect.gen", "Effect.fn", "Effect.fnUntraced"];
@@ -3404,7 +3653,7 @@ var effectLayerFileDefaultConstructors = [
   "Layer.sync",
   "Layer.unwrap"
 ];
-var effectLayerFile = defineRule28({
+var effectLayerFile = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3415,6 +3664,7 @@ var effectLayerFile = defineRule28({
           layer: { type: "string" },
           make: { type: "string" },
           prefix: { type: "string" },
+          suffix: { type: "string" },
           builders: { type: "array", items: { type: "string" } },
           layers: optionsPatternSchema,
           services: optionsPatternSchema,
@@ -3427,8 +3677,8 @@ var effectLayerFile = defineRule28({
       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."
     }
@@ -3437,6 +3687,7 @@ var effectLayerFile = defineRule28({
     let layer = "layer";
     let make = "make";
     let prefix = "layer";
+    let suffix = "";
     let builders = new Set(effectBuilders);
     let layers = [];
     let services = [];
@@ -3453,14 +3704,15 @@ var effectLayerFile = defineRule28({
         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";
@@ -3520,7 +3772,8 @@ var effectLayerFile = defineRule28({
               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",
@@ -3557,7 +3810,7 @@ var effectLayerFile = defineRule28({
             context.report({
               node: argument,
               messageId: "inlineBuilder",
-              data: { layer, make, prefix }
+              data: { layer, make, prefix, suffix }
             });
           }
         }
@@ -3567,7 +3820,7 @@ var effectLayerFile = defineRule28({
 });
 
 // src/rules/effect/effect-layers.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 var effectLayersDefaultMerge = ["Layer.mergeAll"];
 var effectLayersDefaultProvide = ["Effect.provide", "Layer.provide", "Layer.provideMerge"];
 var effectLayersDefaultMin = 2;
@@ -3579,7 +3832,7 @@ var effectLayersGroupSchema = {
     min: { type: "integer", minimum: 1 }
   }
 };
-var effectLayers = defineRule29({
+var effectLayers = defineRule30({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -3661,11 +3914,11 @@ var effectLayers = defineRule29({
 });
 
 // src/rules/effect/effect-merge-pipe.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule31 } from "@oxlint/plugins";
 var effectMergePipeDefaultMerge = ["Layer.mergeAll"];
 var effectMergePipeDefaultPipe = ["pipe", "Function.pipe"];
 var effectMergePipeDefaultMethods = ["pipe"];
-var effectMergePipe = defineRule30({
+var effectMergePipe = defineRule31({
   meta: {
     type: "layout",
     schema: [
@@ -3710,7 +3963,7 @@ var effectMergePipe = defineRule30({
 });
 
 // src/rules/effect/effect-schema-first.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 var effectSchemaFirstDefaultRuntime = [
   "Effect",
   "Layer",
@@ -3772,7 +4025,7 @@ function effectSchemaFirstReference(node) {
   }
   return node.type === "TSInterfaceHeritage" ? astDottedName(node.expression) : undefined;
 }
-var effectSchemaFirst = defineRule31({
+var effectSchemaFirst = defineRule32({
   meta: {
     type: "suggestion",
     schema: [
@@ -3945,7 +4198,7 @@ var effectSchemaFirst = defineRule31({
 });
 
 // src/rules/effect/effect-values-first.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
+import { defineRule as defineRule33 } from "@oxlint/plugins";
 var effectValuesFirstDefaultPinned = [
   "^Layer\\.",
   "^Context\\.",
@@ -3954,7 +4207,7 @@ var effectValuesFirstDefaultPinned = [
   "(?:^|\\.)layer[^.]*$",
   "^Schema\\.(?:asserts|decode\\w*|encode\\w*|is|isSchema|isSchemaError|resolveAnnotations)$"
 ];
-var effectValuesFirst = defineRule32({
+var effectValuesFirst = defineRule33({
   meta: {
     type: "suggestion",
     schema: [
@@ -4037,7 +4290,7 @@ var effectValuesFirst = defineRule32({
 });
 
 // src/rules/files/files-components-only.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 
 // src/utils/react.utils.ts
 function reactReturnsOutput(program, node) {
@@ -4109,7 +4362,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule33({
+var filesComponentsOnly = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -4197,7 +4450,7 @@ var filesComponentsOnly = defineRule33({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } 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);
@@ -4252,7 +4505,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule34({
+var filesConstantsOnly = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -4351,7 +4604,7 @@ var filesConstantsOnly = defineRule34({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -4369,7 +4622,7 @@ 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 = defineRule35({
+var filesDomainConstants = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4434,11 +4687,9 @@ var filesDomainConstants = defineRule35({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
-function escapeRegExp(value) {
-  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var filesExports = defineRule36({
+import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { posix as posix2 } from "node:path";
+var filesExports = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4448,7 +4699,8 @@ var filesExports = defineRule36({
         properties: {
           names: { type: "array", items: { type: "string" } },
           patterns: { type: "array", items: { type: "string" } },
-          stem: { type: "string", enum: [...namingStemModes] },
+          stem: { type: "string", enum: [...namingStemModes, "folder"] },
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
           roles: { type: "array", items: { type: "string" } },
           separators: { type: "array", items: { type: "string" } },
           types: { type: "boolean" },
@@ -4491,12 +4743,14 @@ var filesExports = defineRule36({
         if (options.names === undefined && options.patterns === undefined) {
           return;
         }
-        const domain = namingFileStem(basename3, options.stem, options.roles, options.separators);
+        const read = options.stem === "folder" ? namingBasename(posix2.dirname(context.filename.replaceAll("\\", "/"))) : namingFileStem(basename3, options.stem, options.roles, options.separators);
+        const last = read.split(/[-_]+/).at(-1) ?? "";
+        const domain = options.singularize === "trailing-s" && last.length > 1 && last.endsWith("s") ? read.slice(0, -1) : read;
         const pascalDomain = namingPascalCase(domain);
         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(", ");
@@ -4519,12 +4773,12 @@ var filesExports = defineRule36({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } 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 filesExternalsConfigs = "^(?:vite|next)\\.config\\.[cm]?[jt]s$";
-var filesExternals = defineRule37({
+var filesExternals = defineRule38({
   meta: {
     type: "problem",
     schema: [
@@ -4617,7 +4871,7 @@ var filesExternals = defineRule37({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule39 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -4628,7 +4882,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 = defineRule38({
+var filesFactoryKeys = defineRule39({
   meta: {
     type: "problem",
     schema: [
@@ -4746,8 +5000,8 @@ var filesFactoryKeys = defineRule38({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var filesHelpers = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var filesHelpers = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4795,8 +5049,8 @@ var filesHelpers = defineRule39({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4850,8 +5104,8 @@ var filesNoFunctions = defineRule40({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var filesRestricted = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var filesRestricted = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4883,7 +5137,7 @@ var filesRestricted = defineRule41({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule43 } 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)) {
@@ -4903,7 +5157,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule42({
+var filesRoute = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4973,7 +5227,7 @@ var filesRoute = defineRule42({
 });
 
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
+import { defineRule as defineRule44 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -5142,7 +5396,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule43({
+var filesTypesOnly = defineRule44({
   meta: {
     type: "problem",
     schema: [
@@ -5250,8 +5504,8 @@ var filesTypesOnly = defineRule43({
 });
 
 // src/rules/layout/layout-arrow-body.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
-var layoutArrowBody = defineRule44({
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule45({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5303,12 +5557,12 @@ var layoutArrowBody = defineRule44({
 });
 
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } 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 = defineRule45({
+var layoutCallArguments = defineRule46({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5327,6 +5581,12 @@ var layoutCallArguments = defineRule45({
             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,
@@ -5349,6 +5609,7 @@ var layoutCallArguments = defineRule45({
     ],
     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."
@@ -5358,11 +5619,13 @@ var layoutCallArguments = defineRule45({
     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;
@@ -5384,8 +5647,8 @@ var layoutCallArguments = defineRule45({
       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}`);
@@ -5403,11 +5666,23 @@ var layoutCallArguments = defineRule45({
       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]))];
@@ -5453,13 +5728,15 @@ var layoutCallArguments = defineRule45({
     };
     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));
       }
     };
@@ -5477,6 +5754,7 @@ var layoutCallArguments = defineRule45({
         options = optionsFirst(context, {});
         minArguments = options.min ?? 3;
         indentUnit = sourceIndentUnit(options.indent);
+        pipeMethods = new Set(options.pipe?.methods ?? ["pipe"]);
       },
       CallExpression: call,
       NewExpression: call,
@@ -5490,12 +5768,12 @@ var layoutCallArguments = defineRule45({
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
+import { defineRule as defineRule47 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule46({
+var layoutCallArray = defineRule47({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5611,22 +5889,29 @@ var layoutCallArray = defineRule46({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
-function layoutCallDepthOuter(node) {
+import { defineRule as defineRule48 } from "@oxlint/plugins";
+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 = defineRule47({
+var layoutCallDepth = defineRule48({
   meta: {
     type: "layout",
     schema: [
       {
         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: {
@@ -5635,10 +5920,11 @@ var layoutCallDepth = defineRule47({
   },
   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({
@@ -5649,7 +5935,9 @@ var layoutCallDepth = defineRule47({
     };
     return {
       before() {
-        max = optionsFirst(context, {}).max ?? 2;
+        const options = optionsFirst(context, {});
+        max = options.max ?? 2;
+        callbacks = options.callbacks ?? false;
       },
       CallExpression: check,
       NewExpression: check
@@ -5658,8 +5946,8 @@ var layoutCallDepth = defineRule47({
 });
 
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
-var layoutChain = defineRule48({
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+var layoutChain = defineRule49({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5778,8 +6066,8 @@ var layoutChain = defineRule48({
 });
 
 // src/rules/layout/layout-items.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
-var layoutItems = defineRule49({
+import { defineRule as defineRule50 } from "@oxlint/plugins";
+var layoutItems = defineRule50({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5834,8 +6122,8 @@ var layoutItems = defineRule49({
 });
 
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule50({
+import { defineRule as defineRule51 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule51({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5923,8 +6211,8 @@ var layoutJsxAttributes = defineRule50({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule51({
+import { defineRule as defineRule52 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule52({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5960,7 +6248,7 @@ var layoutKeyValue = defineRule51({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
@@ -5968,7 +6256,7 @@ 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 = defineRule52({
+var layoutObject = defineRule53({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5980,6 +6268,10 @@ var layoutObject = defineRule52({
           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,
@@ -5995,6 +6287,11 @@ var layoutObject = defineRule52({
     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."
     }
   },
@@ -6005,6 +6302,119 @@ var layoutObject = defineRule52({
     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, {});
@@ -6013,24 +6423,39 @@ var layoutObject = defineRule52({
         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);
@@ -6046,46 +6471,16 @@ var layoutObject = defineRule52({
           });
           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);
       }
     };
   }
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule54 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -6114,7 +6509,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule53({
+var layoutPadding = defineRule54({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6203,23 +6598,33 @@ var layoutPadding = defineRule53({
 });
 
 // src/rules/layout/layout-pipe.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
-var layoutPipe = defineRule54({
+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) {
@@ -6235,7 +6640,7 @@ var layoutPipe = defineRule54({
 });
 
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
+import { defineRule as defineRule56 } from "@oxlint/plugins";
 function layoutTernaryLines(node) {
   return node.loc.end.line - node.loc.start.line + 1;
 }
@@ -6243,7 +6648,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 = defineRule55({
+var layoutTernary = defineRule56({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6358,10 +6763,70 @@ var layoutTernary = defineRule55({
   }
 });
 
+// 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 defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule58 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule56({
+var namingDeclarations = defineRule58({
   meta: {
     type: "problem",
     schema: [
@@ -6438,7 +6903,7 @@ var namingDeclarations = defineRule56({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule57 } from "@oxlint/plugins";
+import { defineRule as defineRule59 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -6464,7 +6929,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule57({
+var namingExports = defineRule59({
   meta: {
     type: "problem",
     schema: {
@@ -6601,10 +7066,10 @@ var namingExports = defineRule57({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule58 } 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 = defineRule58({
+var namingFile = defineRule60({
   meta: {
     type: "problem",
     schema: {
@@ -6674,9 +7139,9 @@ var namingFile = defineRule58({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
-import { posix as posix2 } from "node:path";
-var namingFolder = defineRule59({
+import { defineRule as defineRule61 } from "@oxlint/plugins";
+import { posix as posix3 } from "node:path";
+var namingFolder = defineRule61({
   meta: {
     type: "problem",
     schema: [
@@ -6699,7 +7164,7 @@ var namingFolder = defineRule59({
     return {
       Program(program) {
         const { singularize = "trailing-s", separators = ["-"], after, prefixes: stripPrefixes = [] } = optionsFirst(context, {});
-        const all = posix2.dirname(context.filename.replaceAll("\\", "/")).split("/").filter((part) => part && part !== ".");
+        const all = posix3.dirname(context.filename.replaceAll("\\", "/")).split("/").filter((part) => part && part !== ".");
         const parent = [all.at(-1) ?? ""];
         let folders = after ? undefined : parent;
         const marker = (after ?? "").split("/").filter(Boolean);
@@ -6741,45 +7206,174 @@ var namingFolder = defineRule59({
 });
 
 // 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 defineRule60 } from "@oxlint/plugins";
-var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule60({
+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 }
+          });
         }
       }
     };
@@ -6787,7 +7381,7 @@ var reactMemo = defineRule60({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule61 } 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 };
@@ -6814,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 = defineRule61({
+var reactProps = defineRule66({
   meta: {
     type: "problem",
     schema: [
@@ -6912,8 +7506,90 @@ var reactProps = defineRule61({
   }
 });
 
+// src/rules/react/react-query-props.ts
+import { defineRule as defineRule67 } from "@oxlint/plugins";
+var reactQueryProps = defineRule67({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          hooks: { type: "array", items: { type: "string" } },
+          functions: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      options: "Build the {{hook}} options here from props; ready-made options hide where the data comes from.",
+      source: "{{key}} must be a prop or call one; pass the data function in from the app."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const { hooks = ["useQuery", "useMutation", "useInfiniteQuery", "useSuspenseQuery"], functions = ["queryFn", "mutationFn"] } = optionsFirst(context, {});
+        const hook = astCallName(node);
+        let owner = node.parent;
+        while (owner && owner.type !== "FunctionDeclaration" && !astIsInlineFunction(owner)) {
+          owner = owner.parent;
+        }
+        if (!hook || !hooks.includes(hook) || !owner || owner.type !== "FunctionDeclaration" && !astIsInlineFunction(owner)) {
+          return;
+        }
+        const component = owner;
+        const first = component.params.at(0);
+        const parameter = first?.type === "AssignmentPattern" ? first.left : first;
+        const definition = (identifier) => boundariesDeclaredVariable(context.sourceCode.getScope(identifier), identifier.name)?.defs.at(0);
+        const isProps = (value) => {
+          const found = value?.type === "Identifier" ? definition(value) : undefined;
+          return found?.type === "Parameter" && found.node === component && parameter?.type === "Identifier";
+        };
+        const isProp = (value) => {
+          if (value.type === "MemberExpression") {
+            return isProps(value.object);
+          }
+          const found = value.type === "Identifier" ? definition(value) : undefined;
+          if (found?.type === "Parameter") {
+            return found.node === component && parameter?.type === "ObjectPattern";
+          }
+          return found?.type === "Variable" && found.node.type === "VariableDeclarator" && found.node.id.type === "ObjectPattern" && isProps(found.node.init);
+        };
+        const options = node.arguments.at(0);
+        if (options?.type !== "ObjectExpression" || options.properties.some((property) => property.type === "SpreadElement")) {
+          context.report({
+            node: options ?? node,
+            messageId: "options",
+            data: { hook }
+          });
+          return;
+        }
+        for (const property of options.properties) {
+          if (property.type !== "Property") {
+            continue;
+          }
+          const key = property.key.type === "Identifier" && !property.computed ? property.key.name : astStaticString(property.key);
+          if (key === undefined || !functions.includes(key)) {
+            continue;
+          }
+          const { value } = property;
+          const calls = astIsInlineFunction(value) && astSome(value.body, (child) => child.type === "CallExpression" && isProp(child.callee));
+          if (!isProp(value) && !calls) {
+            context.report({
+              node: value,
+              messageId: "source",
+              data: { key }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
+import { defineRule as defineRule68 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -6949,7 +7625,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule62({
+var schemasInline = defineRule68({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -6998,11 +7674,11 @@ var schemasInline = defineRule62({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule63 } 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 = defineRule63({
+var schemasLocal = defineRule69({
   meta: {
     type: "problem",
     schema: [
@@ -7151,8 +7827,8 @@ var schemasLocal = defineRule63({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
-var schemasRederive = defineRule64({
+import { defineRule as defineRule70 } from "@oxlint/plugins";
+var schemasRederive = defineRule70({
   meta: {
     type: "problem",
     schema: [
@@ -7198,7 +7874,7 @@ var schemasRederive = defineRule64({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule65 } 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;
@@ -7212,7 +7888,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule65({
+var schemasSingleUse = defineRule71({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -7288,7 +7964,7 @@ var schemasSingleUse = defineRule65({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
+import { defineRule as defineRule72 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -7478,7 +8154,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule66({
+var testsAssertions = defineRule72({
   meta: {
     type: "problem",
     schema: [
@@ -7604,8 +8280,8 @@ var testsAssertions = defineRule66({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule67({
+import { defineRule as defineRule73 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule73({
   meta: {
     type: "problem",
     schema: [
@@ -7661,7 +8337,7 @@ var testsConcurrentDb = defineRule67({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule68 } 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"];
@@ -7680,7 +8356,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule68({
+var testsModifiers = defineRule74({
   meta: {
     type: "problem",
     schema: [
@@ -7734,9 +8410,9 @@ var testsModifiers = defineRule68({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
+import { defineRule as defineRule75 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule69({
+var testsTitles = defineRule75({
   meta: {
     type: "suggestion",
     schema: [
@@ -7814,11 +8490,11 @@ var testsTitles = defineRule69({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
+import { defineRule as defineRule76 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule70({
+var typesDeclarations = defineRule76({
   meta: {
     type: "problem",
     schema: [
@@ -7826,7 +8502,8 @@ var typesDeclarations = defineRule70({
         type: "object",
         additionalProperties: false,
         properties: {
-          allow: optionsPatternSchema
+          allow: optionsPatternSchema,
+          modules: { type: "boolean" }
         }
       }
     ],
@@ -7837,8 +8514,14 @@ var typesDeclarations = defineRule70({
   createOnce(context) {
     let allowedNames = [];
     let allowedValues = [];
+    let allowModules = false;
     function check(node) {
-      if (optionsPatternsTest(allowedNames, node.id.name) || node.type === "TSTypeAliasDeclaration" && allowedValues.length > 0 && optionsPatternsTest(allowedValues, `= ${context.sourceCode.getText(node.typeAnnotation)}`)) {
+      let ancestor = node.parent;
+      while (allowModules && ancestor && ancestor.type !== "TSModuleDeclaration") {
+        ancestor = ancestor.parent;
+      }
+      const ambient = ancestor?.type === "TSModuleDeclaration" && (ancestor.kind === "global" || ancestor.id.type === "Literal");
+      if (allowModules && ambient || optionsPatternsTest(allowedNames, node.id.name) || node.type === "TSTypeAliasDeclaration" && allowedValues.length > 0 && optionsPatternsTest(allowedValues, `= ${context.sourceCode.getText(node.typeAnnotation)}`)) {
         return;
       }
       context.report({
@@ -7849,7 +8532,8 @@ var typesDeclarations = defineRule70({
     }
     return {
       before() {
-        const { allow: allowPattern } = optionsFirst(context, {});
+        const { allow: allowPattern, modules = false } = optionsFirst(context, {});
+        allowModules = modules;
         const sources = allowPattern === undefined ? [] : [allowPattern].flat();
         allowedNames = optionsPatterns(sources.filter((source) => !isValuePattern(source)));
         allowedValues = optionsPatterns(sources.filter(isValuePattern));
@@ -7861,8 +8545,8 @@ var typesDeclarations = defineRule70({
 });
 
 // src/rules/types/types-duplicate.ts
-import { defineRule as defineRule71 } from "@oxlint/plugins";
-var typesDuplicate = defineRule71({
+import { defineRule as defineRule77 } from "@oxlint/plugins";
+var typesDuplicate = defineRule77({
   meta: {
     type: "suggestion",
     schema: [
@@ -7926,7 +8610,7 @@ var typesDuplicate = defineRule71({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule72 } from "@oxlint/plugins";
+import { defineRule as defineRule78 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -7938,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 = defineRule72({
+var typesImportedAlias = defineRule78({
   meta: {
     type: "problem",
     schema: [],
@@ -8000,7 +8684,7 @@ var typesImportedAlias = defineRule72({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule73 } from "@oxlint/plugins";
+import { defineRule as defineRule79 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -8010,7 +8694,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule73({
+var typesInline = defineRule79({
   meta: {
     type: "problem",
     schema: [
@@ -8021,6 +8705,9 @@ var typesInline = defineRule73({
           parameters: { type: "boolean" },
           returns: { type: "boolean" },
           functions: { type: "boolean" },
+          variables: { type: "boolean" },
+          assertions: { type: "boolean" },
+          arguments: { type: "boolean" },
           min: { type: "integer", minimum: 1 }
         }
       }
@@ -8033,6 +8720,9 @@ var typesInline = defineRule73({
     let checkParameters = true;
     let checkReturns = true;
     let checkFunctionTypes = true;
+    let checkVariables = false;
+    let checkAssertions = false;
+    let checkArguments = false;
     let minMembers = 1;
     function isInline(node) {
       if (node.type === "TSTypeLiteral") {
@@ -8068,11 +8758,44 @@ var typesInline = defineRule73({
         checkParameters = options.parameters ?? true;
         checkReturns = options.returns ?? true;
         checkFunctionTypes = options.functions ?? true;
+        checkVariables = options.variables ?? false;
+        checkAssertions = options.assertions ?? false;
+        checkArguments = options.arguments ?? false;
         minMembers = options.min ?? 1;
-        if (!checkParameters && !checkReturns) {
+        if (!checkParameters && !checkReturns && !checkVariables && !checkAssertions && !checkArguments) {
           return false;
         }
       },
+      VariableDeclarator(node) {
+        if (checkVariables) {
+          check(parameterAnnotation(node.id), "variable");
+        }
+      },
+      PropertyDefinition(node) {
+        if (checkVariables) {
+          check(node.typeAnnotation, "variable");
+        }
+      },
+      TSAsExpression(node) {
+        if (checkAssertions) {
+          check(node.typeAnnotation, "assertion");
+        }
+      },
+      TSSatisfiesExpression(node) {
+        if (checkAssertions) {
+          check(node.typeAnnotation, "assertion");
+        }
+      },
+      CallExpression(node) {
+        if (checkArguments) {
+          check(node.typeArguments, "type argument");
+        }
+      },
+      NewExpression(node) {
+        if (checkArguments) {
+          check(node.typeArguments, "type argument");
+        }
+      },
       FunctionDeclaration: checkFunction,
       FunctionExpression: checkFunction,
       ArrowFunctionExpression: checkFunction,
@@ -8083,11 +8806,38 @@ var typesInline = defineRule73({
 });
 
 // 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 defineRule74 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule74({
+import { defineRule as defineRule81 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule81({
   meta: {
     type: "suggestion",
     schema: [
@@ -8129,8 +8879,8 @@ var typesNamespaceImport = defineRule74({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule75 } from "@oxlint/plugins";
-var typesService = defineRule75({
+import { defineRule as defineRule82 } from "@oxlint/plugins";
+var typesService = defineRule82({
   meta: {
     type: "problem",
     schema: [
@@ -8180,12 +8930,12 @@ var typesService = defineRule75({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule76 } 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 = defineRule76({
+var typesUnknown = defineRule83({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -8224,6 +8974,7 @@ var src_default = eslintCompatPlugin({
     "boundaries-token-owner": boundariesTokenOwner,
     "code-branch-once": codeBranchOnce,
     "code-constructor": codeConstructor,
+    "code-delegate": codeDelegate,
     "code-double-negation": codeDoubleNegation,
     "code-function-nesting": codeFunctionNesting,
     "code-inline": codeInline,
@@ -8268,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,
@@ -8277,6 +9029,7 @@ var src_default = eslintCompatPlugin({
     "react-empty-effect": reactEmptyEffect,
     "react-memo": reactMemo,
     "react-props": reactProps,
+    "react-query-props": reactQueryProps,
     "schemas-inline": schemasInline,
     "schemas-local": schemasLocal,
     "schemas-rederive": schemasRederive,