oxlint-plugin-arch 0.13.0 → 0.13.2

package/dist/index.js

@@ -50,6 +50,12 @@ function optionsAssertMockingApis(patterns) {
     throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
   }
 }
+function optionsEscape(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function optionsWildcards(names) {
+  return [names ?? []].flat().map((name) => new RegExp(`^${name.split("*").map(optionsEscape).join(".*")}$`));
+}
 
 // src/utils/ast.utils.ts
 var astSkippedKeys = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
@@ -237,9 +243,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 +252,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
@@ -455,7 +461,8 @@ var namingStemSchemaProperties = {
   roles: { type: "array", items: { type: "string" } },
   separators: { type: "array", items: { type: "string" } },
   normalize: { type: "string", enum: ["remove-separators", "none"] },
-  singularize: { type: "string", enum: ["none", "trailing-s"] }
+  singularize: { type: "string", enum: ["none", "trailing-s"] },
+  prefix: { type: "array", items: { type: "string", enum: ["file", "folder", "parent"] }, minItems: 1 }
 };
 function namingBasename(filePath) {
   return posix.basename(filePath.replaceAll("\\", "/"));
@@ -482,17 +489,73 @@ function namingFileStem(basename, mode = "before-first-dot", trailingRoles = [],
   }
   return stem;
 }
+function namingSingular(value) {
+  const parts = value.split(/[-_]+/).filter(Boolean);
+  const last = parts.at(-1) ?? "";
+  return last.endsWith("s") && last.length > 1 ? [...parts.slice(0, -1), last.slice(0, -1)].join("-") : value;
+}
+function namingFolders(filename) {
+  return filename.replaceAll("\\", "/").split("/").slice(0, -1).toReversed();
+}
 function namingFilePrefixesFor(filename, options) {
   const basename = namingBasename(filename).replace(/\.(tsx?|jsx?)$/, "");
-  const stem = namingFileStem(basename, options.stem, options.roles, options.separators);
+  const [folder = "", parent = ""] = namingFolders(filename);
   const normalize = options.normalize ?? "remove-separators";
-  const prefixes = [namingNormalized(stem, normalize)];
-  const parts = stem.split(/[-_]+/).filter(Boolean);
-  const last = parts.at(-1) ?? "";
-  if (options.singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
-    prefixes.push(namingNormalized([...parts.slice(0, -1), last.slice(0, -1)].join("-"), normalize));
+  const sources = { file: namingFileStem(basename, options.stem, options.roles, options.separators), folder, parent };
+  const prefixes = (options.prefix ?? ["file"]).flatMap((source) => {
+    const stem = sources[source];
+    return options.singularize === "trailing-s" ? [stem, namingSingular(stem)] : [stem];
+  });
+  return [...new Set(prefixes.map((stem) => namingNormalized(stem, normalize)).filter(Boolean))];
+}
+function namingTemplatePattern(template, placeholder = "[a-z0-9-]+") {
+  const seen = new Set;
+  const source = template.split(/(\{[^{}]+\})/).map((part) => {
+    const name = /^\{[^{}]+\}$/.test(part) ? part.slice(1, -1) : undefined;
+    if (name === undefined) {
+      return part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    const again = seen.has(name);
+    seen.add(name);
+    return again ? `\\k<${name}>` : `(?<${name}>${placeholder})`;
+  }).join("");
+  try {
+    return new RegExp(`^${source}$`);
+  } catch {
+    return null;
   }
-  return [...new Set(prefixes.filter(Boolean))];
+}
+function namingCaptures(filename, options = {}) {
+  const path = filename.replaceAll("\\", "/");
+  const file = namingBasename(path).replace(/\.(tsx?|jsx?)$/, "");
+  const [folder = "", parent = ""] = namingFolders(path);
+  const stem = namingFileStem(file, options.stem === "folder" ? undefined : options.stem, options.roles, options.separators);
+  const read = options.stem === "folder" ? folder : stem;
+  const last = read.split(/[-_]+/).at(-1) ?? "";
+  const domain = options.singularize === "trailing-s" && last.length > 1 && last.endsWith("s") ? read.slice(0, -1) : read;
+  const builtIn = { file, stem, folder, parent, domain };
+  if (options.file === undefined) {
+    return builtIn;
+  }
+  const depth = options.file.split("/").length;
+  const match = namingTemplatePattern(options.file, options.placeholder)?.exec(path.split("/").slice(-depth).join("/"));
+  return match ? { ...builtIn, ...match.groups } : null;
+}
+function namingExpand(template, captures, camelCase, escape = (value) => value) {
+  return template.replaceAll(/\{([A-Za-z][A-Za-z0-9]*)\}/g, (placeholder, key) => {
+    const name = key.toLowerCase();
+    if (!Object.hasOwn(captures, name)) {
+      return placeholder;
+    }
+    const value = captures[name];
+    if (key.length > 1 && key === key.toUpperCase()) {
+      return escape(value.split(/[-_\s.]+/).filter(Boolean).join("_").toUpperCase());
+    }
+    if (/^[A-Z]/.test(key)) {
+      return escape(namingPascalCase(value));
+    }
+    return escape(camelCase ? namingCamelCase(value) : value);
+  });
 }
 function namingHasFilePrefix(name, prefixes, normalize) {
   const comparable = normalize === "none" ? name : name.replaceAll("_", "").toLowerCase();
@@ -842,6 +905,27 @@ import { defineRule as defineRule5 } from "@oxlint/plugins";
 // src/utils/boundaries.utils.ts
 import { builtinModules } from "node:module";
 import { dirname, resolve } from "node:path";
+var boundariesRuntimeConventions = {
+  server: ["server"],
+  rsc: ["rsc"],
+  actions: ["action"],
+  client: ["client"],
+  clientOnly: ["client-only"],
+  hooks: ["hooks"],
+  shared: ["utils", "constants"],
+  lib: "lib"
+};
+var boundariesSuffixList = { type: "array", items: { type: "string", minLength: 1 } };
+function boundariesConventionsFor(options) {
+  return { ...boundariesRuntimeConventions, ...options.conventions };
+}
+function boundariesHasSuffix(suffixes, path, optionalExtension = false) {
+  const extension = optionalExtension ? "(?:\\.[cm]?[jt]sx?)?" : "\\.[cm]?[jt]sx?";
+  return suffixes.length > 0 && new RegExp(`\\.(?:${suffixes.map(optionsEscape).join("|")})${extension}$`).test(path);
+}
+function boundariesIsClientOnly(conventions, target) {
+  return conventions.hooks.some((folder) => target.includes(`/${folder}/`)) || conventions.clientOnly.some((suffix) => new RegExp(`\\.${optionsEscape(suffix)}(?:\\.|$)`).test(target));
+}
 var boundariesServerGlobals = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
 var boundariesBrowserGlobals = [
   "window",
@@ -877,7 +961,21 @@ var boundariesRuntimeProperties = {
   dynamic: { type: "array", items: { type: "string" } },
   serverPackages: { type: "array", items: { type: "string" } },
   clientPackages: { type: "array", items: { type: "string" } },
-  hookPackages: { type: "array", items: { type: "string" } }
+  hookPackages: { type: "array", items: { type: "string" } },
+  conventions: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      server: boundariesSuffixList,
+      rsc: boundariesSuffixList,
+      actions: boundariesSuffixList,
+      client: boundariesSuffixList,
+      clientOnly: boundariesSuffixList,
+      hooks: boundariesSuffixList,
+      shared: boundariesSuffixList,
+      lib: { type: "string", minLength: 1 }
+    }
+  }
 };
 var boundariesServerPackages = ["@orpc/server", "react-dom/server"];
 var boundariesRuntimeMessages = {
@@ -908,16 +1006,21 @@ function boundariesReport(context, node, source, reason) {
     data: { source, reason }
   });
 }
-function boundariesImportExpression(context, node, allowComputed, check) {
-  const source = boundariesLiteralSource(node);
-  if (source !== undefined) {
-    check(source);
-  } else if (!allowComputed) {
-    context.report({ node, messageId: "computed" });
-  }
+function boundariesRuntimeImportVisitors(context, check, allowComputed) {
+  return {
+    ...boundariesExportVisitors(check),
+    ImportExpression(node) {
+      const source = boundariesLiteralSource(node);
+      if (source !== undefined) {
+        check(node, source, false, false);
+      } else if (!allowComputed()) {
+        context.report({ node, messageId: "computed" });
+      }
+    }
+  };
 }
-function boundariesIsSharedFile(options, file) {
-  return /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options.web.some((path) => file.startsWith(`${path}/lib/`));
+function boundariesIsSharedFile(options, conventions, file) {
+  return boundariesHasSuffix(conventions.shared, file) || options.web.some((path) => file.startsWith(`${path}/${conventions.lib}/`));
 }
 function boundariesDeclaredVariable(start, name) {
   for (let scope = start;scope; scope = scope.upper) {
@@ -946,7 +1049,7 @@ function boundariesMemberName(node) {
   }
   return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
 }
-function boundariesResolveTarget(options, file, source) {
+function boundariesResolveTarget(options, file, source, services = "services") {
   const owner = [...options.web, ...options.backend].sort((a, b) => b.length - a.length).find((root) => file.startsWith(`${root}/`));
   const web = owner && options.web.includes(owner) ? owner : undefined;
   const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
@@ -957,13 +1060,13 @@ function boundariesResolveTarget(options, file, source) {
     return resolve(dirname(file), source).replaceAll("\\", "/");
   }
   if (source.startsWith("@/") && web) {
-    return `${web}/${source.slice(2)}`;
+    return resolve(web, source.slice(2)).replaceAll("\\", "/");
   }
   if (source.startsWith("#/") && owner) {
-    return `${owner}/${source.slice(2)}`;
+    return resolve(owner, source.slice(2)).replaceAll("\\", "/");
   }
   if (source.startsWith("#services/") && owner) {
-    return `${owner}/services/${source.slice(10)}`;
+    return resolve(owner, services, source.slice("#services/".length)).replaceAll("\\", "/");
   }
   return source;
 }
@@ -1080,7 +1183,17 @@ var boundariesDeny = defineRule6({
         additionalProperties: false,
         properties: {
           imports: { type: "object", additionalProperties: { type: "string" } },
-          calls: { type: "object", additionalProperties: { type: "string" } }
+          calls: { type: "object", additionalProperties: { type: "string" } },
+          only: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: { imports: optionsPatternSchema, calls: optionsPatternSchema, in: optionsPatternSchema, message: { type: "string" } },
+              required: ["in"],
+              anyOf: [{ required: ["imports"] }, { required: ["calls"] }]
+            }
+          }
         }
       }
     ],
@@ -1105,8 +1218,17 @@ var boundariesDeny = defineRule6({
     return {
       before() {
         const options = optionsFirst(context, {});
-        imports = Object.entries(options.imports ?? {}).map(([pattern, message]) => [optionsGlob(pattern), message && ` ${message}`]);
-        calls = new Map(Object.entries(options.calls ?? {}).map(([name, message]) => [name, message && ` ${message}`]));
+        const filename = context.filename.replaceAll("\\", "/");
+        const elsewhere = (options.only ?? []).filter((entry) => ![entry.in].flat().some((place) => optionsGlob(`**/${place}{,/**}`).test(filename)));
+        const owned = (entry) => ` ${entry.message ?? `Only ${[entry.in].flat().join(", ")} may use it.`}`;
+        imports = [
+          ...Object.entries(options.imports ?? {}).map(([pattern, message]) => [optionsGlob(pattern), message && ` ${message}`]),
+          ...elsewhere.flatMap((entry) => [entry.imports ?? []].flat().map((pattern) => [optionsGlob(pattern), owned(entry)]))
+        ];
+        calls = new Map([
+          ...elsewhere.flatMap((entry) => [entry.calls ?? []].flat().map((name) => [name, owned(entry)])),
+          ...Object.entries(options.calls ?? {}).map(([name, message]) => [name, message && ` ${message}`])
+        ]);
         if (imports.length === 0 && calls.size === 0) {
           return false;
         }
@@ -1145,7 +1267,25 @@ var boundariesDeny = defineRule6({
 import { defineRule as defineRule7 } from "@oxlint/plugins";
 import { basename, resolve as resolve2 } from "node:path";
 var boundariesSurfaces = ["service", "client", "server", "rsc", "utils"];
-var boundariesActionOrQuery = /\/(?:[^/]+)-(?:action|query)\./;
+var boundariesConventions = {
+  services: "services",
+  registry: "service",
+  types: "types",
+  lib: "lib",
+  contracts: ["types", "constants"],
+  implementations: ["service", "utils"],
+  implementationFolders: ["core"],
+  operations: ["action", "query"],
+  operationFolders: ["actions", "queries"],
+  domainFiles: ["action", "query", "driver"],
+  clients: ["client"]
+};
+function boundariesAny(values) {
+  return values.length === 0 ? "(?!)" : `(?:${values.map(optionsEscape).join("|")})`;
+}
+function boundariesIsOperation(conventions, path) {
+  return new RegExp(`/[^/]+-${boundariesAny(conventions.operations)}\\.`).test(path);
+}
 function boundariesContains(directory, candidate) {
   return candidate === directory || candidate.startsWith(`${directory}/`);
 }
@@ -1155,44 +1295,56 @@ function boundariesIsSurface(options, stem) {
 function boundariesStripExtension(path) {
   return path.replace(/\.[cm]?[jt]sx?$/, "");
 }
+function boundariesConventionsOf(options) {
+  return { ...boundariesConventions, ...options.conventions };
+}
 function boundariesServiceFolder(options, root) {
   const nested = [...options.web, ...options.backend].filter((other) => other.length > root.length && boundariesContains(root, other));
-  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/services`;
+  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/${boundariesConventionsOf(options).services}`;
 }
-function boundariesDomain(path, appRoot, services) {
+function boundariesDomain(conventions, path, appRoot, services) {
   const relative = path.slice(appRoot.length + 1);
-  if (relative.startsWith("types/") && relative.endsWith(".types.ts")) {
-    return relative.slice("types/".length).split(".")[0];
+  if (relative.startsWith(`${conventions.types}/`) && relative.endsWith(`.${conventions.types}.ts`)) {
+    return relative.slice(conventions.types.length + 1).split(".")[0];
   }
   if (!boundariesContains(services, path) || path === services) {
     return;
   }
   const parts = path.slice(services.length + 1).split("/");
-  return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(/-(?:action|query|driver)$/, "");
+  return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(new RegExp(`-${boundariesAny(conventions.domainFiles)}$`), "");
 }
 function boundariesPrivateDomain({ options, file, target, reExport, roots, owner }) {
   const roles = options.roles;
+  const conventions = boundariesConventionsOf(options);
   if (!roles?.length) {
     return;
   }
   const targetOwner = roots.find((path) => boundariesContains(path, target));
-  const fileDomain = owner ? boundariesDomain(file, owner, boundariesServiceFolder(options, owner)) : undefined;
-  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
+  const fileDomain = owner ? boundariesDomain(conventions, file, owner, boundariesServiceFolder(options, owner)) : undefined;
+  const targetDomain = targetOwner ? boundariesDomain(conventions, target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
   const sameDomain = owner && owner === targetOwner && fileDomain && fileDomain === targetDomain;
   const targetStem = boundariesStripExtension(target);
-  const publicSurface = boundariesIsSurface(options, targetStem) && !boundariesActionOrQuery.test(targetStem);
-  const privateTarget = roles.some((role) => targetStem.endsWith(`.${role}`)) || targetDomain && !publicSurface && !/\.(?:types|constants)$/.test(targetStem);
+  const publicSurface = boundariesIsSurface(options, targetStem) && !boundariesIsOperation(conventions, targetStem);
+  const privateTarget = roles.some((role) => targetStem.endsWith(`.${role}`)) || targetDomain && !publicSurface && !new RegExp(`\\.${boundariesAny(conventions.contracts)}$`).test(targetStem);
   if (!privateTarget) {
     return;
   }
-  if (reExport && file.endsWith(".ts") && boundariesIsSurface(options, file.slice(0, -".ts".length)) && !boundariesActionOrQuery.test(file)) {
+  if (reExport && file.endsWith(".ts") && boundariesIsSurface(options, file.slice(0, -".ts".length)) && !boundariesIsOperation(conventions, file)) {
     return "public service and utility surfaces must not re-export private domain internals";
   }
   return sameDomain ? undefined : "private domain files stay in the same domain and application; use its service API or shared utilities";
 }
+function boundariesPortableFolder(options) {
+  if (!options.portable) {
+    return;
+  }
+  return typeof options.portable === "string" ? options.portable : boundariesConventionsOf(options).lib;
+}
 function boundariesPortableLib(check) {
   const { options, file, source, target, typeOnly, reExport, roots, web, backendImport } = check;
-  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file) || boundariesServiceFolder(options, web) === `${web}/lib`) {
+  const { types } = boundariesConventionsOf(options);
+  const lib = boundariesPortableFolder(options);
+  if (!lib || !web || !boundariesContains(`${web}/${lib}`, file) || boundariesServiceFolder(options, web) === `${web}/${lib}`) {
     return;
   }
   const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
@@ -1202,11 +1354,11 @@ function boundariesPortableLib(check) {
   if (backendImport || backendTarget || appService || appPackage) {
     return "portable frontend lib does not import application services or application APIs";
   }
-  const appType = roots.some((path) => boundariesContains(`${path}/types`, portableTarget));
+  const appType = roots.some((path) => boundariesContains(`${path}/${types}`, portableTarget));
   const stem = boundariesStripExtension(basename(file)).replace(/\.utils$/, "");
-  const ownType = typeOnly && !reExport && boundariesStripExtension(portableTarget) === `${web}/types/${stem}.types`;
+  const ownType = typeOnly && !reExport && boundariesStripExtension(portableTarget) === `${web}/${types}/${stem}.${types}`;
   if (appType && !ownType) {
-    return `portable frontend lib may only type-import its own contract '${web}/types/${stem}.types.ts'; app type re-exports are forbidden`;
+    return `portable frontend lib may only type-import its own contract '${web}/${types}/${stem}.${types}.ts'; app type re-exports are forbidden`;
   }
   return;
 }
@@ -1225,7 +1377,24 @@ var boundariesImports = defineRule7({
           roles: { type: "array", items: { type: "string" } },
           surfaces: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesSurfaces },
           services: { type: "array", items: { type: "string" } },
-          portable: { type: "boolean" },
+          portable: { anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }] },
+          conventions: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              services: { type: "string", minLength: 1 },
+              registry: { type: "string", minLength: 1 },
+              types: { type: "string", minLength: 1 },
+              lib: { type: "string", minLength: 1 },
+              contracts: { type: "array", items: { type: "string", minLength: 1 } },
+              implementations: { type: "array", items: { type: "string", minLength: 1 } },
+              implementationFolders: { type: "array", items: { type: "string", minLength: 1 } },
+              operations: { type: "array", items: { type: "string", minLength: 1 } },
+              operationFolders: { type: "array", items: { type: "string", minLength: 1 } },
+              domainFiles: { type: "array", items: { type: "string", minLength: 1 } },
+              clients: { type: "array", items: { type: "string", minLength: 1 } }
+            }
+          },
           backendPackages: { type: "array", items: { type: "string" } },
           entrypoints: { type: "array", items: { type: "string" } },
           appPackages: { type: "array", items: { type: "string" } },
@@ -1244,7 +1413,8 @@ var boundariesImports = defineRule7({
       const file = context.filename.replaceAll("\\", "/");
       const roots = [...options.web, ...options.backend].sort((a, b) => b.length - a.length);
       const owner = roots.find((path) => boundariesContains(path, file));
-      const target = boundariesResolveTarget(options, file, source);
+      const conventions = boundariesConventionsOf(options);
+      const target = boundariesResolveTarget(options, file, source, conventions.services);
       const web = owner && options.web.includes(owner) ? owner : undefined;
       const backendImport = options.backend.some((path) => boundariesContains(path, target)) || boundariesMatchesImport(options.backendPackages, source);
       const imported = { options, file, source, target, typeOnly, reExport, roots, owner, web, backendImport };
@@ -1253,13 +1423,16 @@ var boundariesImports = defineRule7({
       const serviceFolders = roots.map((path) => boundariesServiceFolder(options, path));
       const serviceTarget = serviceFolders.find((folder) => boundariesContains(folder, target));
       const serviceFile = serviceFolders.find((folder) => boundariesContains(folder, file));
-      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && (/\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target) || serviceTarget !== undefined && /\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/)/.test(target.slice(serviceTarget.length)));
+      const implementation = `(?:\\.${boundariesAny(conventions.implementations)}|-${boundariesAny(conventions.operations)}\\.|/${boundariesAny(conventions.operationFolders)}/)`;
+      const services = optionsEscape(conventions.services);
+      const domainContract = new RegExp(`\\.${boundariesAny(conventions.contracts)}\\.ts$`).test(file) && !typeOnly && (new RegExp(`/(?:${boundariesAny(conventions.implementationFolders)}/|${services}/.*${implementation})`).test(target) || serviceTarget !== undefined && new RegExp(`/.*${implementation}`).test(target.slice(serviceTarget.length)));
+      const registry = `/${optionsEscape(conventions.registry)}(?:\\.ts)?$`;
       const reason = [
         web && backendImport && !options.entrypoints.includes(source) ? "frontend code uses only public backend entry points" : undefined,
         inPackage && appTarget ? "shared packages do not import app internals" : undefined,
-        (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) || serviceFile !== undefined && /^\/service(?:\.ts)?$/.test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
+        (file.includes(`/${conventions.services}/`) && new RegExp(`/${services}${registry}`).test(target) || serviceFile !== undefined && new RegExp(`^${registry}`).test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
         domainContract ? "domain types/constants use type-only imports from implementations" : undefined,
-        file.endsWith(".client.ts") && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
+        conventions.clients.some((client) => file.endsWith(`.${client}.ts`)) && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
         boundariesPrivateDomain(imported),
         boundariesPortableLib(imported)
       ].findLast((candidate) => candidate !== undefined);
@@ -1300,7 +1473,8 @@ var boundariesImports = defineRule7({
       TSImportType(node) {
         const options = { ...boundariesImportsDefaults, ...optionsFirst(context) };
         const file = context.filename.replaceAll("\\", "/");
-        if (options.portable && options.web.some((path) => file.startsWith(`${path}/lib/`) && boundariesServiceFolder(options, path) !== `${path}/lib`)) {
+        const lib = boundariesPortableFolder(options);
+        if (lib && options.web.some((path) => file.startsWith(`${path}/${lib}/`) && boundariesServiceFolder(options, path) !== `${path}/${lib}`)) {
           check(node, node.source.value, true);
         }
       }
@@ -1344,6 +1518,7 @@ var boundariesNext = defineRule8({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let server = false;
     let client = false;
@@ -1355,12 +1530,12 @@ var boundariesNext = defineRule8({
         return;
       }
       const target = boundariesResolveTarget(options, file, source);
-      const clientOnly = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
+      const clientOnly = boundariesIsClientOnly(conventions, target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
       if (clientOnly && (server || shared)) {
         boundariesReport(context, node, source, "browser-only dependencies do not belong in server, RSC or shared modules");
         return;
       }
-      const serverOnly = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || /\.(?:server|rsc)(?:\.[cm]?[jt]sx?)?$/.test(target) || boundariesMatchesImport(options.server, source);
+      const serverOnly = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || boundariesHasSuffix([...conventions.server, ...conventions.rsc], target, true) || boundariesMatchesImport(options.server, source);
       if (!serverOnly || server) {
         return;
       }
@@ -1369,6 +1544,7 @@ var boundariesNext = defineRule8({
     return {
       Program(program) {
         options = { ...boundariesNextDefaults, ...optionsFirst(context) };
+        conventions = boundariesConventionsFor(options);
         reactNamespaces.clear();
         file = context.filename.replaceAll("\\", "/");
         const directives = new Map;
@@ -1379,9 +1555,9 @@ var boundariesNext = defineRule8({
         }
         const useServer = directives.get("use server");
         const useClient = directives.get("use client");
-        const serverName = /\.(?:server|rsc|action)\.[cm]?[jt]sx?$/.test(file);
-        const clientName = /\.client\.[cm]?[jt]sx?$/.test(file);
-        shared = boundariesIsSharedFile(options, file);
+        const serverName = boundariesHasSuffix([...conventions.server, ...conventions.rsc, ...conventions.actions], file);
+        const clientName = boundariesHasSuffix(conventions.client, file);
+        shared = boundariesIsSharedFile(options, conventions, file);
         server = !useClient && (serverName || Boolean(useServer));
         client = clientName || Boolean(useClient);
         if (useClient && serverName) {
@@ -1398,7 +1574,7 @@ var boundariesNext = defineRule8({
             data: { directive: "use server", side: "client" }
           });
         }
-        if (/\.action\.[cm]?[jt]sx?$/.test(file) && !useServer) {
+        if (boundariesHasSuffix(conventions.actions, file) && !useServer) {
           context.report({ node: program, messageId: "action" });
         }
       },
@@ -1428,10 +1604,7 @@ var boundariesNext = defineRule8({
           boundariesReport(context, node, `${node.object.name}.${name}`, boundariesClientHookReason);
         }
       },
-      ...boundariesExportVisitors(check),
-      ImportExpression(node) {
-        boundariesImportExpression(context, node, Boolean(options.dynamic?.includes(file)), (source) => check(node, source, false));
-      },
+      ...boundariesRuntimeImportVisitors(context, check, () => Boolean(options.dynamic?.includes(file))),
       "Program:exit"() {
         const scope = context.sourceCode.scopeManager.scopes.at(0);
         if (!scope) {
@@ -1548,11 +1721,9 @@ var boundariesTanstackDefaults = {
   hookPackages: ["react", "@tanstack/react-query", "@tanstack/react-router"],
   startPackages: ["@tanstack/react-start"],
   rscPackages: ["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"],
-  renderers: ["renderServerComponent", "renderToReadableStream"]
+  renderers: ["renderServerComponent", "renderToReadableStream"],
+  serverHooks: ["useId"]
 };
-function boundariesIsClientHook(name) {
-  return /^use[A-Z]/.test(name) && name !== "useId";
-}
 var boundariesTanstack = defineRule10({
   meta: {
     type: "problem",
@@ -1565,7 +1736,8 @@ var boundariesTanstack = defineRule10({
           rpc: { type: "array", items: { type: "string" } },
           startPackages: { type: "array", items: { type: "string" } },
           rscPackages: { type: "array", items: { type: "string" } },
-          renderers: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.renderers }
+          renderers: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.renderers },
+          serverHooks: { type: "array", items: { type: "string", minLength: 1 }, default: boundariesTanstackDefaults.serverHooks }
         }
       }
     ],
@@ -1573,6 +1745,7 @@ var boundariesTanstack = defineRule10({
   },
   createOnce(context) {
     let options;
+    let conventions = boundariesConventionsFor({});
     let file = "";
     let serverFile = false;
     let rscFile = false;
@@ -1581,6 +1754,7 @@ var boundariesTanstack = defineRule10({
     let referenced;
     let imports = new Map;
     const boundaries = [];
+    const clientHook = (name) => /^use[A-Z]/.test(name) && !options.serverHooks.includes(name);
     function imported(node) {
       const entry = imports.get(node.name);
       const variable = entry ? boundariesDeclaredVariable(context.sourceCode.getScope(node), node.name) : null;
@@ -1623,7 +1797,7 @@ var boundariesTanstack = defineRule10({
         return;
       }
       const target = boundariesResolveTarget(options, file, source);
-      const clientImport = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
+      const clientImport = boundariesIsClientOnly(conventions, target) || boundariesMatchesImport(options.clientPackages, source) || boundariesMatchesImport(options.client, source);
       if (clientImport && (serverFile || rscFile || shared) && !clientSide(node.start)) {
         const references = node.type === "ImportDeclaration" ? runtimeReferences(node) : [];
         if (shared || references.length === 0 || !references.every(clientSide)) {
@@ -1631,7 +1805,7 @@ var boundariesTanstack = defineRule10({
         }
         return;
       }
-      const serverImport = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || /\.server(?:\.[cm]?[jt]sx?)?$/.test(target) || boundariesMatchesImport(options.server, source);
+      const serverImport = boundariesIsServerPlatformImport(source, options.serverPackages) || boundariesIsBackendImport(options, target, source) || boundariesHasSuffix(conventions.server, target, true) || boundariesMatchesImport(options.server, source);
       if (!renderer && !serverImport) {
         return;
       }
@@ -1659,10 +1833,11 @@ var boundariesTanstack = defineRule10({
     return {
       Program(program) {
         options = { ...boundariesTanstackDefaults, ...optionsFirst(context) };
+        conventions = boundariesConventionsFor(options);
         file = context.filename.replaceAll("\\", "/");
-        serverFile = /\.server\.[cm]?[jt]sx?$/.test(file);
-        rscFile = /\.rsc\.[cm]?[jt]sx?$/.test(file);
-        shared = boundariesIsSharedFile(options, file);
+        serverFile = boundariesHasSuffix(conventions.server, file);
+        rscFile = boundariesHasSuffix(conventions.rsc, file);
+        shared = boundariesIsSharedFile(options, conventions, file);
         runtimeIdentifiers.clear();
         referenced = undefined;
         boundaries.length = 0;
@@ -1729,7 +1904,7 @@ var boundariesTanstack = defineRule10({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !boundariesIsClientHook(specifier.imported.name)) {
+          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier" || !clientHook(specifier.imported.name)) {
             continue;
           }
           const references = runtimeReferences(node, specifier.local.name);
@@ -1738,10 +1913,7 @@ var boundariesTanstack = defineRule10({
           }
         }
       },
-      ...boundariesExportVisitors(check),
-      ImportExpression(node) {
-        boundariesImportExpression(context, node, Boolean(options.dynamic?.includes(file)), (source) => check(node, source, false));
-      },
+      ...boundariesRuntimeImportVisitors(context, check, () => Boolean(options.dynamic?.includes(file))),
       MemberExpression(node) {
         const name = boundariesMemberName(node);
         if (!name || node.object.type !== "Identifier") {
@@ -1751,7 +1923,7 @@ var boundariesTanstack = defineRule10({
         if (kind === "rsc-renderers" && options.renderers.includes(name) && (shared || !serverPosition(node.start, true))) {
           boundariesReport(context, node, name, "server renderers require a server execution boundary");
         }
-        if ((serverFile || rscFile) && kind === "client-hooks" && boundariesIsClientHook(name) && !clientSide(node.start)) {
+        if ((serverFile || rscFile) && kind === "client-hooks" && clientHook(name) && !clientSide(node.start)) {
           boundariesReport(context, node, name, boundariesClientHookReason2);
         }
       },
@@ -2230,6 +2402,7 @@ var codeInline = defineRule16({
         properties: {
           max: { type: "integer", minimum: 1, default: 160 },
           nesting: { type: "integer", minimum: 1, default: 2 },
+          callbacks: { type: "boolean", default: false },
           allow: optionsPatternSchema,
           keep: optionsPatternSchema,
           services: { type: "array", items: { type: "string" } }
@@ -2258,7 +2431,8 @@ var codeInline = defineRule16({
         return;
       }
       if (uses.length === 1) {
-        if (init && codeInlineEffectBetween(context.sourceCode.ast, node.range[1], uses[0].identifier.range[0])) {
+        const use = uses[0].identifier;
+        if (init && (codeInlineEffectBetween(context.sourceCode.ast, node.range[1], use.range[0]) || codeInlineEnclosingCalls(use) + astCallDepth(init, options.callbacks ?? false) > (options.nesting ?? 2))) {
           return;
         }
         context.report({
@@ -2270,7 +2444,12 @@ var codeInline = defineRule16({
       }
       const arrow = init?.type === "ArrowFunctionExpression" && init.body.type !== "BlockStatement" && !astSome(init.body, astIsInlineFunction);
       const call = init?.type === "CallExpression" && !astSome(init.arguments, astIsInlineFunction) && astCallDepth(init) <= 2;
-      if (!optionsPatternsTest(kept, id.name) && (arrow || call)) {
+      const text = context.sourceCode.text;
+      const fits = init !== null && uses.every(({ identifier }) => {
+        const line = text.slice(sourceLineStart(text, identifier.range[0]), sourceLineEnd(text, identifier.range[0]));
+        return line.length - id.name.length + context.sourceCode.getText(init).length <= (options.max ?? 160) && codeInlineEnclosingCalls(identifier) + astCallDepth(init, options.callbacks ?? false) <= (options.nesting ?? 2);
+      });
+      if (!optionsPatternsTest(kept, id.name) && (arrow || call) && fits) {
         context.report({
           node: id,
           messageId: "trivial",
@@ -2298,7 +2477,7 @@ var codeInline = defineRule16({
         deferred ||= current.type === "FunctionDeclaration" || astIsInlineFunction(current);
       }
       const wrapped = codeInlineWrapped.has(init.type) && use.parent.type === "MemberExpression" && use.parent.object === use;
-      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init) > (options.nesting ?? 2) || line.length - id.name.length + context.sourceCode.getText(init).length > (options.max ?? 160) || codeInlineEffectBetween(context.sourceCode.ast, declarator.range[1], use.range[0])) {
+      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init, options.callbacks ?? false) > (options.nesting ?? 2) || line.length - id.name.length + context.sourceCode.getText(init).length > (options.max ?? 160) || codeInlineEffectBetween(context.sourceCode.ast, declarator.range[1], use.range[0])) {
         return;
       }
       context.report({
@@ -2332,9 +2511,85 @@ var codeInline = defineRule16({
   }
 });
 
-// src/rules/code/code-justified-call.ts
+// src/rules/code/code-inside.ts
 import { defineRule as defineRule17 } from "@oxlint/plugins";
-var codeJustifiedCall = defineRule17({
+function codeInsideOwners(node) {
+  const parent = node.parent;
+  if (!parent) {
+    return [];
+  }
+  const callback = node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+  const owner = callback && astIsCall(parent) && parent.arguments.some((item) => item === node) ? astDottedName(parent.callee) : undefined;
+  return [...owner === undefined ? [] : [owner], ...codeInsideOwners(parent)];
+}
+var codeInside = defineRule17({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          inside: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                callee: optionsPatternSchema,
+                calls: { type: "object", additionalProperties: { type: "string" } }
+              },
+              required: ["callee", "calls"]
+            }
+          }
+        },
+        required: ["inside"]
+      }
+    ],
+    messages: {
+      inside: "Do not call '{{name}}' inside {{owner}}.{{message}}"
+    }
+  },
+  createOnce(context) {
+    let entries = [];
+    return {
+      before() {
+        entries = optionsFirst(context, { inside: [] }).inside.map((entry) => ({
+          callees: optionsWildcards(entry.callee),
+          calls: Object.entries(entry.calls).map(([name, message]) => [optionsWildcards(name)[0], message && ` ${message}`])
+        }));
+        if (entries.length === 0) {
+          return false;
+        }
+      },
+      CallExpression(node) {
+        const name = astDottedName(node.callee);
+        if (name === undefined) {
+          return;
+        }
+        const banned = entries.flatMap(({ callees, calls }) => calls.flatMap(([pattern, message]) => pattern.test(name) ? [{ callees, message }] : []));
+        if (banned.length === 0) {
+          return;
+        }
+        const owners = codeInsideOwners(node);
+        for (const { callees, message } of banned) {
+          const owner = owners.find((item) => optionsPatternsTest(callees, item));
+          if (owner !== undefined) {
+            context.report({
+              node: node.callee,
+              messageId: "inside",
+              data: { name, owner, message }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/code/code-justified-call.ts
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var codeJustifiedCall = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2388,8 +2643,8 @@ var codeJustifiedCall = defineRule17({
 });
 
 // src/rules/code/code-literal-in.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-var codeLiteralIn = defineRule18({
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var codeLiteralIn = defineRule19({
   meta: {
     type: "suggestion",
     schema: [
@@ -2430,7 +2685,7 @@ var codeLiteralIn = defineRule18({
 });
 
 // src/rules/code/code-mutable-state.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 var functionScopes = new Set([
   "FunctionDeclaration",
   "FunctionExpression",
@@ -2447,7 +2702,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule19({
+var codeMutableState = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2505,7 +2760,7 @@ var codeMutableState = defineRule19({
 });
 
 // src/rules/code/code-object-params.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } from "@oxlint/plugins";
 function isObjectParam(node) {
   if (node.type === "ObjectPattern") {
     return true;
@@ -2519,7 +2774,7 @@ function isObjectParam(node) {
   const annotation = node.typeAnnotation?.typeAnnotation;
   return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
 }
-var codeObjectParams = defineRule20({
+var codeObjectParams = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2568,8 +2823,8 @@ var codeObjectParams = defineRule20({
 });
 
 // src/rules/code/code-paired-call.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var codePairedCall = defineRule21({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var codePairedCall = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2636,7 +2891,7 @@ var codePairedCall = defineRule21({
 });
 
 // src/rules/code/code-promise-mutation.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2665,7 +2920,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule22({
+var codePromiseMutation = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2758,8 +3013,8 @@ var codePromiseMutation = defineRule22({
 var codeSwitch = astSelectorRule("SwitchStatement", "Avoid switch statements.");
 
 // src/rules/code/code-traced.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var codeTraced = defineRule23({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var codeTraced = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -2846,7 +3101,7 @@ var codeTraced = defineRule23({
 });
 
 // src/rules/code/code-trivial-functions.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 var codeTrivialFunctionsBanned = [
   "isRecord",
   "isPlainObject",
@@ -3004,7 +3259,7 @@ function codeTrivialFunctionsDefaults(program) {
   }
   return starts;
 }
-var codeTrivialFunctions = defineRule24({
+var codeTrivialFunctions = defineRule25({
   meta: {
     type: "problem",
     schema: [
@@ -3146,8 +3401,8 @@ var codeTrivialFunctions = defineRule24({
 });
 
 // src/rules/code/code-yield-argument.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var codeYieldArgument = defineRule25({
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+var codeYieldArgument = defineRule26({
   meta: {
     type: "suggestion",
     messages: {
@@ -3169,7 +3424,7 @@ var codeYieldArgument = defineRule25({
 });
 
 // src/rules/comments/comments-code.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 var commentsLineGap = /^[\t \r\n\u2028\u2029]*$/;
 var commentsLineTerminator = /\r\n|[\n\r\u2028\u2029]/;
 var commentsUnicodeTerminator = /[\u2028\u2029]/;
@@ -3220,7 +3475,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule26({
+var commentsCode = defineRule27({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -3232,7 +3487,8 @@ var commentsCode = defineRule26({
           why: { anyOf: [{ type: "boolean" }, { type: "string", minLength: 1 }], default: true },
           allow: { type: "array", items: { type: "string" } },
           jsdoc: { type: "boolean", default: false },
-          members: { type: "string", enum: ["off", "also", "only"] }
+          members: { type: "string", enum: ["off", "also", "only"] },
+          steps: { type: "boolean", default: false }
         }
       }
     ],
@@ -3247,9 +3503,31 @@ var commentsCode = defineRule26({
     let allowJsdoc = false;
     let allowed = [];
     let members = "off";
+    let steps = false;
+    let functionDepth = 0;
     const memberComments = new Set;
+    const stepStarts = new Set;
+    function enterFunction() {
+      functionDepth++;
+    }
+    function exitFunction() {
+      functionDepth--;
+    }
+    function addSteps(nodes, inFunction) {
+      if (steps && inFunction) {
+        for (const node of nodes) {
+          stepStarts.add(node.range[0]);
+        }
+      }
+    }
+    function isStep(comment) {
+      const source = context.sourceCode;
+      const before = source.getTokenBefore(comment, { includeComments: true });
+      const after = source.getTokenAfter(comment, { includeComments: true });
+      return comment.type === "Line" && before?.loc.end.line !== comment.loc.start.line && !(before && (before.type === "Line" || before.type === "Block") && before.loc.end.line === comment.loc.start.line - 1) && after !== null && after.type !== "Line" && after.type !== "Block" && after.loc.start.line === comment.loc.end.line + 1 && stepStarts.has(after.range[0]);
+    }
     function keepComment(comment, value, isWhy) {
-      return allowWhy && isWhy || sourceIsDirective(value) || allowJsdoc && comment.type === "Block" && context.sourceCode.text.startsWith("/**", comment.range[0]) || allowed.some((pattern) => pattern.test(value.trim()));
+      return allowWhy && isWhy || sourceIsDirective(value) || allowJsdoc && comment.type === "Block" && context.sourceCode.text.startsWith("/**", comment.range[0]) || allowed.some((pattern) => pattern.test(value.trim())) || steps && isStep(comment);
     }
     function checkMember(node) {
       const parent = node.parent;
@@ -3273,7 +3551,10 @@ var commentsCode = defineRule26({
         allowJsdoc = options.jsdoc ?? false;
         allowed = (options.allow ?? []).map((pattern) => new RegExp(pattern));
         members = options.members ?? "off";
+        steps = options.steps ?? false;
+        functionDepth = 0;
         memberComments.clear();
+        stepStarts.clear();
       },
       TSPropertySignature: checkMember,
       TSMethodSignature: checkMember,
@@ -3282,6 +3563,17 @@ var commentsCode = defineRule26({
       TSConstructSignatureDeclaration: checkMember,
       Property: checkMember,
       SpreadElement: checkMember,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      BlockStatement: (node) => addSteps(node.body, functionDepth > 0),
+      SwitchCase: (node) => addSteps(node.consequent, functionDepth > 0),
+      IfStatement: (node) => addSteps([node.consequent, ...node.alternate ? [node.alternate] : []], functionDepth > 0),
+      "ForStatement, ForInStatement, ForOfStatement, WhileStatement, DoWhileStatement, LabeledStatement": (node) => addSteps([node.body], functionDepth > 0),
+      ObjectExpression: (node) => addSteps(node.properties, true),
       "Program:exit"(program) {
         const text = context.sourceCode.text;
         const found = [];
@@ -3386,9 +3678,9 @@ var commentsCode = defineRule26({
 });
 
 // src/rules/comments/comments-directives.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 var directive = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s;
-var commentsDirectives = defineRule27({
+var commentsDirectives = defineRule28({
   meta: {
     type: "problem",
     schema: [],
@@ -3416,9 +3708,9 @@ var commentsDirectives = defineRule27({
 });
 
 // src/rules/copy/copy-dashes.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 var copyDashesMessage = "Use a comma, colon, period or parentheses instead.";
-var copyDashes = defineRule28({
+var copyDashes = defineRule29({
   meta: {
     type: "suggestion",
     schema: [
@@ -3474,7 +3766,7 @@ var copyDashes = defineRule28({
 });
 
 // src/rules/effect/effect-layer-file.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 
 // src/utils/effect.utils.ts
 var effectBuilders = ["Effect.gen", "Effect.fn", "Effect.fnUntraced"];
@@ -3516,7 +3808,7 @@ var effectLayerFileDefaultConstructors = [
   "Layer.sync",
   "Layer.unwrap"
 ];
-var effectLayerFile = defineRule29({
+var effectLayerFile = defineRule30({
   meta: {
     type: "problem",
     schema: [
@@ -3527,6 +3819,7 @@ var effectLayerFile = defineRule29({
           layer: { type: "string" },
           make: { type: "string" },
           prefix: { type: "string" },
+          suffix: { type: "string" },
           builders: { type: "array", items: { type: "string" } },
           layers: optionsPatternSchema,
           services: optionsPatternSchema,
@@ -3539,8 +3832,8 @@ var effectLayerFile = defineRule29({
       notLayer: "`{{layer}}` is built with Layer: a Layer call, a Layer pipe, or a function returning one.",
       builderName: "The Effect that builds the service is named `{{make}}`, one per layer file.",
       moduleMethod: "Only `{{make}}` is an Effect at module level; move this into `{{make}}`, or into a utils file if two files use it.",
-      moduleHelper: "A layer file holds only `{{make}}`, {{prefix}}<Role> layers and `{{layer}}`; move this into `{{make}}`, or into a utils file if two files use it.",
-      localLayer: "A Layer other than `{{layer}}` is named {{prefix}}<Role> and is not exported.",
+      moduleHelper: "A layer file holds only `{{make}}`, {{prefix}}<Role>{{suffix}} layers and `{{layer}}`; move this into `{{make}}`, or into a utils file if two files use it.",
+      localLayer: "A Layer other than `{{layer}}` is named {{prefix}}<Role>{{suffix}} and is not exported.",
       makeReturn: "`{{make}}` returns the service through its tag (Tag.of({ … })), a Context, or a Layer.",
       inlineBuilder: "Build this layer from `{{make}}`, not an inline Effect: Layer.effect(Tag, {{make}}). One built layer per file."
     }
@@ -3549,6 +3842,7 @@ var effectLayerFile = defineRule29({
     let layer = "layer";
     let make = "make";
     let prefix = "layer";
+    let suffix = "";
     let builders = new Set(effectBuilders);
     let layers = [];
     let services = [];
@@ -3565,14 +3859,15 @@ var effectLayerFile = defineRule29({
         const options = optionsFirst(context, {});
         layer = options.layer ?? "layer";
         make = options.make ?? "make";
-        prefix = options.prefix ?? "layer";
+        suffix = options.suffix ?? "";
+        prefix = options.prefix ?? (suffix ? "" : "layer");
         builders = new Set(options.builders ?? effectBuilders);
         constructors = new Set(options.constructors ?? effectLayerFileDefaultConstructors);
-        layers = optionsPatterns(options.layers ?? effectLayerFileDefaultLayers);
+        layers = optionsPatterns(options.layers ?? [...effectLayerFileDefaultLayers, ...suffix ? [`(?:^|\\.)\\w+${optionsEscape(suffix)}$`] : []]);
         services = [...optionsPatterns(options.services ?? effectLayerFileDefaultServices), ...layers];
       },
       Program(program) {
-        const data = { layer, make, prefix };
+        const data = { layer, make, prefix, suffix };
         const declarators = program.body.flatMap((statement) => {
           const declaration = astDeclaration(statement);
           const exported = statement.type === "ExportNamedDeclaration";
@@ -3632,7 +3927,8 @@ var effectLayerFile = defineRule29({
               data
             });
           }
-          if (isLayer && name !== layer && (exported || !name.startsWith(prefix) || !/^[A-Z]\w*$/.test(name.slice(prefix.length)))) {
+          const role = name.endsWith(suffix) ? name.slice(prefix.length, name.length - suffix.length) : "";
+          if (isLayer && name !== layer && (exported || !name.startsWith(prefix) || !/^[A-Z]\w*$/.test(role))) {
             context.report({
               node,
               messageId: "localLayer",
@@ -3669,17 +3965,147 @@ var effectLayerFile = defineRule29({
             context.report({
               node: argument,
               messageId: "inlineBuilder",
-              data: { layer, make, prefix }
+              data: { layer, make, prefix, suffix }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-layer-keys.ts
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { readFileSync } from "node:fs";
+var effectLayerKeysPairs = new Map([["{", "}"], ["(", ")"], ["[", "]"], ["<", ">"]]);
+function effectLayerKeysDeclared(text, declaration) {
+  const code = text.replaceAll(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"/g, " ");
+  const start = code.indexOf(`${declaration}<`);
+  const open = start === -1 ? -1 : code.indexOf("{", start);
+  if (open === -1) {
+    return null;
+  }
+  const paths = [];
+  const frames = [{ open: "{", members: 0 }];
+  const key = /\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\??\s*(?=[:(<])/y;
+  let fresh = true;
+  for (let index = open + 1;index < code.length && frames.length > 0; index += 1) {
+    const char = code[index];
+    const members = frames.every((frame) => frame.open === "{");
+    key.lastIndex = index;
+    const match = fresh && members ? key.exec(code) : null;
+    if (match) {
+      const rest = code.slice(key.lastIndex).replace(/^:\s*/, "");
+      const path = [...frames.flatMap((frame) => frame.key ?? []), match[1]].join(".");
+      const parent = frames.at(-1);
+      if (parent) {
+        parent.members += 1;
+      }
+      if (rest.startsWith("{")) {
+        frames.push({
+          open: "{",
+          key: match[1],
+          members: 0
+        });
+        index = code.length - rest.length;
+      } else {
+        paths.push(path);
+        fresh = false;
+        index = key.lastIndex - 1;
+      }
+      continue;
+    }
+    if (effectLayerKeysPairs.has(char)) {
+      frames.push({ open: char, members: 0 });
+    } else if (char === effectLayerKeysPairs.get(frames.at(-1)?.open ?? "") && !(char === ">" && code[index - 1] === "=")) {
+      const closed = frames.pop();
+      if (closed?.key !== undefined && closed.members === 0) {
+        paths.push([...frames.flatMap((frame) => frame.key ?? []), closed.key].join("."));
+      }
+    }
+    fresh = members && (char === "{" || char === ";" || char === "," || char === "}" || fresh && /\s/.test(char));
+  }
+  return paths;
+}
+function effectLayerKeysBound(object, path) {
+  return object.properties.flatMap((property) => {
+    const key = declarationsPropertyName(property);
+    if (property.type !== "Property" || key === undefined) {
+      return [];
+    }
+    return property.value.type === "ObjectExpression" ? effectLayerKeysBound(property.value, [...path, key]) : [[[...path, key].join("."), property]];
+  });
+}
+var effectLayerKeys = defineRule31({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          service: { type: "string", minLength: 1 },
+          callees: { type: "array", items: { type: "string" }, minItems: 1 },
+          declaration: { type: "string", minLength: 1 }
+        },
+        required: ["service"]
+      }
+    ],
+    messages: {
+      extra: "'{{path}}' is not a method of the service declared in {{file}}.",
+      missing: "The service in {{file}} declares {{paths}}, which this layer does not bind."
+    }
+  },
+  createOnce(context) {
+    let declared = null;
+    let callees = [];
+    let file = "";
+    return {
+      before() {
+        const options = optionsFirst(context, { service: "" });
+        file = namingExpand(options.service, namingCaptures(context.filename) ?? {}, false);
+        callees = optionsWildcards(options.callees ?? ["*.of", "*.bind"]);
+        try {
+          declared = effectLayerKeysDeclared(readFileSync(file, "utf8"), options.declaration ?? "Context.Service");
+        } catch {
+          declared = null;
+        }
+        if (!declared) {
+          return false;
+        }
+      },
+      CallExpression(node) {
+        const first = node.arguments.at(0);
+        if (!declared || first?.type !== "ObjectExpression" || !optionsPatternsTest(callees, astDottedName(node.callee) ?? "")) {
+          return;
+        }
+        const bound = effectLayerKeysBound(first, []);
+        const names = new Set(bound.map(([path]) => path));
+        const short = file.split("/").slice(-2).join("/");
+        const missing = declared.filter((path) => !names.has(path) && !bound.some(([name]) => name.startsWith(`${path}.`)));
+        for (const [path, property] of bound) {
+          if (!declared.some((name) => name === path || path.startsWith(`${name}.`))) {
+            context.report({
+              node: property,
+              messageId: "extra",
+              data: { path, file: short }
             });
           }
         }
+        if (missing.length > 0) {
+          context.report({
+            node: first,
+            messageId: "missing",
+            data: { paths: missing.map((path) => `'${path}'`).join(", "), file: short }
+          });
+        }
       }
     };
   }
 });
 
 // src/rules/effect/effect-layers.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 var effectLayersDefaultMerge = ["Layer.mergeAll"];
 var effectLayersDefaultProvide = ["Effect.provide", "Layer.provide", "Layer.provideMerge"];
 var effectLayersDefaultMin = 2;
@@ -3691,7 +4117,7 @@ var effectLayersGroupSchema = {
     min: { type: "integer", minimum: 1 }
   }
 };
-var effectLayers = defineRule30({
+var effectLayers = defineRule32({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -3773,11 +4199,11 @@ var effectLayers = defineRule30({
 });
 
 // src/rules/effect/effect-merge-pipe.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule33 } from "@oxlint/plugins";
 var effectMergePipeDefaultMerge = ["Layer.mergeAll"];
 var effectMergePipeDefaultPipe = ["pipe", "Function.pipe"];
 var effectMergePipeDefaultMethods = ["pipe"];
-var effectMergePipe = defineRule31({
+var effectMergePipe = defineRule33({
   meta: {
     type: "layout",
     schema: [
@@ -3822,7 +4248,7 @@ var effectMergePipe = defineRule31({
 });
 
 // src/rules/effect/effect-schema-first.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 var effectSchemaFirstDefaultRuntime = [
   "Effect",
   "Layer",
@@ -3884,7 +4310,7 @@ function effectSchemaFirstReference(node) {
   }
   return node.type === "TSInterfaceHeritage" ? astDottedName(node.expression) : undefined;
 }
-var effectSchemaFirst = defineRule32({
+var effectSchemaFirst = defineRule34({
   meta: {
     type: "suggestion",
     schema: [
@@ -3894,6 +4320,7 @@ var effectSchemaFirst = defineRule32({
         properties: {
           member: { type: "string" },
           keep: optionsPatternSchema,
+          allow: optionsPatternSchema,
           runtime: { type: "array", items: { type: "string" } },
           rows: {
             type: "object",
@@ -3923,6 +4350,7 @@ var effectSchemaFirst = defineRule32({
   createOnce(context) {
     let member = "Type";
     let keep = [];
+    let allow = [];
     let runtime = new Set(effectSchemaFirstDefaultRuntime);
     let rows;
     let suffix = "Record";
@@ -3987,6 +4415,7 @@ var effectSchemaFirst = defineRule32({
         const options = optionsFirst(context, {});
         member = options.member ?? "Type";
         keep = optionsPatterns(options.keep);
+        allow = optionsPatterns(options.allow);
         runtime = new Set(options.runtime ?? effectSchemaFirstDefaultRuntime);
         rows = options.rows ? new Set(options.rows.types ?? ["Kysely.Selectable"]) : undefined;
         suffix = options.rows?.suffix ?? "Record";
@@ -4006,7 +4435,7 @@ var effectSchemaFirst = defineRule32({
         const typed = new Set(exported.flatMap((node) => node.type === "TSTypeAliasDeclaration" && derives(node) ? [node.id.name] : []));
         for (const node of exported.flatMap((declaration) => declaration.type === "VariableDeclaration" ? declaration.declarations : [])) {
           const isSchema = node.init?.type === "CallExpression" || node.init?.type === "MemberExpression";
-          if (isSchema && node.id.type === "Identifier" && !typed.has(node.id.name)) {
+          if (isSchema && node.id.type === "Identifier" && !typed.has(node.id.name) && !optionsPatternsTest(allow, node.id.name)) {
             context.report({
               node,
               messageId: "schemaType",
@@ -4056,8 +4485,104 @@ var effectSchemaFirst = defineRule32({
   }
 });
 
+// src/rules/effect/effect-service-params.ts
+import { defineRule as defineRule35 } from "@oxlint/plugins";
+function effectServiceParamsKey(member) {
+  if (member.type !== "TSPropertySignature" && member.type !== "TSMethodSignature" || member.computed) {
+    return;
+  }
+  return member.key.type === "Identifier" ? member.key.name : undefined;
+}
+function effectServiceParamsTypeName(name) {
+  if (name.type === "TSQualifiedName") {
+    return `${effectServiceParamsTypeName(name.left)}.${name.right.name}`;
+  }
+  return name.type === "Identifier" ? name.name : "this";
+}
+var effectServiceParams = defineRule35({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          name: optionsPatternSchema,
+          allow: optionsPatternSchema,
+          declaration: { type: "string", minLength: 1 }
+        }
+      }
+    ],
+    messages: {
+      name: "'{{path}}' takes '{{type}}'; a service method takes a params type that matches {{pattern}}.",
+      inline: "'{{path}}' takes an unnamed type; a service method takes a params type that matches {{pattern}}."
+    }
+  },
+  createOnce(context) {
+    let options = {};
+    let captures = {};
+    let allowed = [];
+    function checkParams(params, keys) {
+      const first = params.at(0);
+      const annotation = first && "typeAnnotation" in first ? first.typeAnnotation?.typeAnnotation : undefined;
+      if (!first || !annotation) {
+        return;
+      }
+      const values = { ...captures, path: keys.join("-"), key: keys.at(-1) ?? "" };
+      const sources = [options.name ?? "^{Folder}\\w*Params$"].flat().map((source) => namingExpand(source, values, true, optionsEscape));
+      const data = { path: keys.join("."), pattern: optionsPatternLabel(sources) };
+      if (annotation.type !== "TSTypeReference") {
+        context.report({
+          node: first,
+          messageId: "inline",
+          data
+        });
+        return;
+      }
+      const type = effectServiceParamsTypeName(annotation.typeName);
+      const last = type.split(".").at(-1) ?? type;
+      if (!optionsPatternsTest(allowed, type) && !optionsPatternsTest(optionsPatterns(sources), last)) {
+        context.report({
+          node: first,
+          messageId: "name",
+          data: { ...data, type }
+        });
+      }
+    }
+    function check(literal, path) {
+      for (const member of literal.members) {
+        const key = effectServiceParamsKey(member);
+        const type = member.type === "TSPropertySignature" ? member.typeAnnotation?.typeAnnotation : undefined;
+        if (key === undefined) {
+          continue;
+        }
+        if (member.type === "TSMethodSignature") {
+          checkParams(member.params, [...path, key]);
+        } else if (type?.type === "TSFunctionType") {
+          checkParams(type.params, [...path, key]);
+        } else if (type?.type === "TSTypeLiteral") {
+          check(type, [...path, key]);
+        }
+      }
+    }
+    return {
+      before() {
+        options = optionsFirst(context, {});
+        captures = namingCaptures(context.filename) ?? {};
+        allowed = optionsPatterns(options.allow);
+      },
+      TSTypeLiteral(node) {
+        const call = node.parent.type === "TSTypeParameterInstantiation" ? node.parent.parent : undefined;
+        if (call?.type === "CallExpression" && astDottedName(call.callee) === (options.declaration ?? "Context.Service")) {
+          check(node, []);
+        }
+      }
+    };
+  }
+});
+
 // src/rules/effect/effect-values-first.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 var effectValuesFirstDefaultPinned = [
   "^Layer\\.",
   "^Context\\.",
@@ -4066,7 +4591,7 @@ var effectValuesFirstDefaultPinned = [
   "(?:^|\\.)layer[^.]*$",
   "^Schema\\.(?:asserts|decode\\w*|encode\\w*|is|isSchema|isSchemaError|resolveAnnotations)$"
 ];
-var effectValuesFirst = defineRule33({
+var effectValuesFirst = defineRule36({
   meta: {
     type: "suggestion",
     schema: [
@@ -4148,12 +4673,96 @@ var effectValuesFirst = defineRule33({
   }
 });
 
-// src/rules/files/files-components-only.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-
-// src/utils/react.utils.ts
-function reactReturnsOutput(program, node) {
-  const expressions = astReturnExpressions(node);
+// src/rules/effect/effect-yield-name.ts
+import { defineRule as defineRule37 } from "@oxlint/plugins";
+var effectYieldName = defineRule37({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          names: { type: "object", additionalProperties: optionsPatternSchema },
+          allow: optionsPatternSchema
+        }
+      }
+    ],
+    messages: {
+      name: "Name this '{{expected}}', not '{{actual}}': it holds {{source}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      VariableDeclarator(node) {
+        const { id, init } = node;
+        if (id.type !== "Identifier" || init?.type !== "YieldExpression" || !init.delegate || init.argument?.type !== "MemberExpression") {
+          return;
+        }
+        const service = astMemberName(init.argument);
+        const source = astDottedName(init.argument);
+        if (!service || !source || !/^[A-Z]/.test(service)) {
+          return;
+        }
+        const options = optionsFirst(context, {});
+        const named = options.names?.[source] ?? options.names?.[`*.${service}`];
+        const expected = named === undefined ? [`${service.charAt(0).toLowerCase()}${service.slice(1)}`] : [named].flat();
+        if (!expected.includes(id.name) && !optionsPatternsTest(optionsPatterns(options.allow), id.name)) {
+          context.report({
+            node: id,
+            messageId: "name",
+            data: { expected: expected.join(" or "), actual: id.name, source }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-yields-first.ts
+import { defineRule as defineRule38 } from "@oxlint/plugins";
+function effectYieldsFirstService(statement) {
+  const init = statement.type === "VariableDeclaration" && statement.declarations.length === 1 ? statement.declarations[0].init : null;
+  const argument = init?.type === "YieldExpression" && init.delegate ? init.argument : null;
+  return argument?.type === "MemberExpression" && /^[A-Z]/.test(astMemberName(argument) ?? "") ? astDottedName(argument) : undefined;
+}
+var effectYieldsFirst = defineRule38({
+  meta: {
+    type: "suggestion",
+    messages: {
+      first: "Yield {{source}} with the other dependencies, at the top of the function."
+    }
+  },
+  createOnce(context) {
+    return {
+      FunctionExpression(node) {
+        if (!node.generator || !node.body) {
+          return;
+        }
+        let started = false;
+        for (const statement of node.body.body) {
+          const source = effectYieldsFirstService(statement);
+          if (source === undefined) {
+            started = true;
+          } else if (started) {
+            context.report({
+              node: statement,
+              messageId: "first",
+              data: { source }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/files/files-components-only.ts
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+
+// src/utils/react.utils.ts
+function reactReturnsOutput(program, node) {
+  const expressions = astReturnExpressions(node);
   if (expressions.some((expression) => astContainsJsx(expression) || expression.type === "Literal" && expression.value === null)) {
     return true;
   }
@@ -4221,7 +4830,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule34({
+var filesComponentsOnly = defineRule39({
   meta: {
     type: "problem",
     schema: [
@@ -4309,7 +4918,7 @@ var filesComponentsOnly = defineRule34({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
+import { defineRule as defineRule40 } 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);
@@ -4364,7 +4973,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule35({
+var filesConstantsOnly = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4463,7 +5072,7 @@ var filesConstantsOnly = defineRule35({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule41 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -4481,7 +5090,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 = defineRule36({
+var filesDomainConstants = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4546,12 +5155,8 @@ var filesDomainConstants = defineRule36({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
-import { posix as posix2 } from "node:path";
-function escapeRegExp(value) {
-  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var filesExports = defineRule37({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var filesExports = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4567,6 +5172,8 @@ var filesExports = defineRule37({
           separators: { type: "array", items: { type: "string" } },
           types: { type: "boolean" },
           factory: { type: "string" },
+          file: { type: "string" },
+          placeholder: { type: "string" },
           scope: { type: "string", enum: ["exports", "declarations"] }
         },
         anyOf: [{ required: ["names"] }, { required: ["patterns"] }, { required: ["factory"] }]
@@ -4605,16 +5212,12 @@ var filesExports = defineRule37({
         if (options.names === undefined && options.patterns === undefined) {
           return;
         }
-        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));
-          return new RegExp(`^(?:${source})$`);
-        });
+        const captures = namingCaptures(context.filename, options);
+        if (!captures) {
+          return;
+        }
+        const allowed = (options.names ?? []).map((template) => namingExpand(template, captures, true));
+        const patterns = (options.patterns ?? []).map((template) => new RegExp(`^(?:${namingExpand(template, captures, true, optionsEscape)})$`));
         const allowedLabel = [...allowed, ...patterns.map((pattern) => pattern.toString())].join(", ");
         for (const binding of exportsCollect(program)) {
           if (options.types && binding.typeOnly) {
@@ -4635,12 +5238,12 @@ var filesExports = defineRule37({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } 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 = defineRule38({
+var filesExternals = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4666,7 +5269,7 @@ var filesExternals = defineRule38({
       }
       let dependencies;
       try {
-        const manifest = JSON.parse(readFileSync(join2(folder, "package.json"), "utf8"));
+        const manifest = JSON.parse(readFileSync2(join2(folder, "package.json"), "utf8"));
         dependencies = [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.optionalDependencies ?? {})];
       } catch {
         return;
@@ -4733,7 +5336,7 @@ var filesExternals = defineRule38({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
+import { defineRule as defineRule44 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -4744,7 +5347,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 = defineRule39({
+var filesFactoryKeys = defineRule44({
   meta: {
     type: "problem",
     schema: [
@@ -4862,8 +5465,8 @@ var filesFactoryKeys = defineRule39({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var filesHelpers = defineRule40({
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+var filesHelpers = defineRule45({
   meta: {
     type: "problem",
     schema: [
@@ -4911,8 +5514,8 @@ var filesHelpers = defineRule40({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule41({
+import { defineRule as defineRule46 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule46({
   meta: {
     type: "problem",
     schema: [
@@ -4966,8 +5569,8 @@ var filesNoFunctions = defineRule41({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var filesRestricted = defineRule42({
+import { defineRule as defineRule47 } from "@oxlint/plugins";
+var filesRestricted = defineRule47({
   meta: {
     type: "problem",
     schema: [
@@ -4999,7 +5602,7 @@ var filesRestricted = defineRule42({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
+import { defineRule as defineRule48 } 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)) {
@@ -5019,7 +5622,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule43({
+var filesRoute = defineRule48({
   meta: {
     type: "problem",
     schema: [
@@ -5088,8 +5691,247 @@ var filesRoute = defineRule43({
   }
 });
 
+// src/rules/files/files-siblings.ts
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname4, join as join3 } from "node:path";
+var filesSiblings = defineRule49({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          require: optionsPatternSchema,
+          message: { type: "string" }
+        },
+        required: ["require"]
+      }
+    ],
+    messages: {
+      missing: "This file needs '{{file}}' beside it.{{message}}"
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options = optionsFirst(context, { require: [] });
+        const captures = namingCaptures(context.filename) ?? {};
+        for (const template of [options.require].flat()) {
+          const file = namingExpand(template, captures, false);
+          if (!existsSync3(join3(dirname4(context.filename), file))) {
+            context.report({
+              node: program,
+              messageId: "missing",
+              data: { file, message: options.message ? ` ${options.message}` : "" }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/files/files-top-level.ts
+import { defineRule as defineRule50 } from "@oxlint/plugins";
+var filesTopLevelKinds = [
+  "import",
+  "export",
+  "reexport",
+  "default",
+  "type",
+  "interface",
+  "enum",
+  "class",
+  "namespace",
+  "const",
+  "let",
+  "var",
+  "function",
+  "function-const",
+  "call",
+  "statement"
+];
+var filesTopLevelDeclared = new Map([
+  ["FunctionDeclaration", "function"],
+  ["TSDeclareFunction", "function"],
+  ["ClassDeclaration", "class"],
+  ["TSTypeAliasDeclaration", "type"],
+  ["TSInterfaceDeclaration", "interface"],
+  ["TSEnumDeclaration", "enum"],
+  ["TSModuleDeclaration", "namespace"]
+]);
+var filesTopLevelEntries = {
+  type: "array",
+  items: {
+    anyOf: [
+      { type: "string" },
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          kind: { anyOf: [{ type: "string", enum: [...filesTopLevelKinds] }, { type: "array", items: { type: "string", enum: [...filesTopLevelKinds] }, minItems: 1 }] },
+          names: optionsPatternSchema,
+          from: optionsPatternSchema,
+          exported: { type: "boolean" },
+          message: { type: "string" }
+        },
+        required: ["kind"]
+      }
+    ]
+  }
+};
+var filesTopLevelValues = new Map([
+  ["Literal", "<literal>"],
+  ["TemplateLiteral", "<literal>"],
+  ["ObjectExpression", "<object>"],
+  ["ArrayExpression", "<array>"],
+  ["FunctionExpression", "<function>"],
+  ["ArrowFunctionExpression", "<function>"]
+]);
+function filesTopLevelHead(node) {
+  if (!node) {
+    return "<none>";
+  }
+  if (node.type === "AwaitExpression") {
+    return filesTopLevelHead(node.argument);
+  }
+  if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "ChainExpression") {
+    return filesTopLevelHead(node.expression);
+  }
+  if (node.type === "CallExpression" || node.type === "NewExpression") {
+    return filesTopLevelHead(node.callee);
+  }
+  if (node.type === "TaggedTemplateExpression") {
+    return filesTopLevelHead(node.tag);
+  }
+  if (node.type === "MemberExpression") {
+    return astDottedName(node) ?? filesTopLevelHead(node.object);
+  }
+  return node.type === "Identifier" ? node.name : filesTopLevelValues.get(node.type) ?? "<other>";
+}
+function filesTopLevelItems(statement) {
+  const item = (kind, name, node2, from = "", exported2 = false) => ({ kind, name, from, exported: exported2, node: node2 });
+  if (statement.type === "ExpressionStatement" && statement.directive) {
+    return [];
+  }
+  if (statement.type === "ImportDeclaration") {
+    return [item("import", statement.source.value, statement)];
+  }
+  if (statement.type === "ExportAllDeclaration") {
+    return [item("reexport", statement.source.value, statement, "", true)];
+  }
+  if (statement.type === "ExportNamedDeclaration" && !statement.declaration) {
+    const kind = statement.source ? "reexport" : "export";
+    const names = statement.specifiers.map((specifier) => item(kind, astModuleName(specifier.exported), specifier, statement.source?.value ?? "", true));
+    return names.length > 0 ? names : [item(kind, "", statement, statement.source?.value ?? "", true)];
+  }
+  const exported = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration";
+  const node = exported ? statement.declaration : statement;
+  if (!node) {
+    return [];
+  }
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.flatMap((declarator) => {
+      const variable = node.kind === "using" || node.kind === "await using" ? "statement" : node.kind;
+      const kind = declarationsIsFunctionValue(declarator.init) ? "function-const" : variable;
+      return astBindings(declarator.id).map((binding) => item(kind, binding.name, declarator, filesTopLevelHead(declarator.init), exported));
+    });
+  }
+  const declared = filesTopLevelDeclared.get(node.type);
+  if (declared) {
+    const id = "id" in node ? node.id : null;
+    return [item(declared, id && "name" in id ? id.name : "", node, "", exported)];
+  }
+  if (statement.type === "ExportDefaultDeclaration") {
+    return [item("default", filesTopLevelHead(node), statement, filesTopLevelHead(node), true)];
+  }
+  if (statement.type === "ExpressionStatement") {
+    const expression = astUnwrap(statement.expression);
+    if (expression.type === "CallExpression" || expression.type === "TaggedTemplateExpression") {
+      return [item("call", filesTopLevelHead(expression), statement)];
+    }
+  }
+  return [item("statement", statement.type, statement)];
+}
+var filesTopLevel = defineRule50({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allow: filesTopLevelEntries,
+          deny: filesTopLevelEntries,
+          message: { type: "string" },
+          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" } },
+          file: { type: "string" },
+          placeholder: { type: "string" }
+        },
+        anyOf: [{ required: ["allow"] }, { required: ["deny"] }]
+      }
+    ],
+    messages: {
+      denied: "Top-level {{what}} is not allowed in this file.{{message}}",
+      unlisted: "Top-level {{what}} is not allowed in this file; allowed: {{allowed}}.{{message}}"
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options = optionsFirst(context, {});
+        const captures = namingCaptures(context.filename, options);
+        if (!captures) {
+          return;
+        }
+        const patterns = (pattern) => pattern === undefined ? null : optionsPatterns([pattern].flat().map((source) => namingExpand(source, captures, true, optionsEscape)));
+        const matcher = (entry) => {
+          if (typeof entry !== "string") {
+            return { kinds: [entry.kind].flat(), names: patterns(entry.names), from: patterns(entry.from), exported: entry.exported, message: entry.message ?? "" };
+          }
+          const kind = filesTopLevelKinds.find((name) => name === entry);
+          return kind ? { kinds: [kind], names: null, from: null, message: "" } : { kinds: ["call"], names: optionsWildcards(entry), from: null, message: "" };
+        };
+        const matches = (item) => (entry) => entry.kinds.includes(item.kind) && (entry.names === null || optionsPatternsTest(entry.names, item.name)) && (entry.from === null || optionsPatternsTest(entry.from, item.from)) && (entry.exported === undefined || entry.exported === item.exported);
+        const allow = options.allow?.map(matcher);
+        const deny = (options.deny ?? []).map(matcher);
+        const label = (entry) => [
+          entry.exported === undefined ? [] : [entry.exported ? "exported" : "unexported"],
+          [entry.kind].flat().join("/"),
+          entry.names === undefined ? [] : ["named", [entry.names].flat().join(" | ")],
+          entry.from === undefined ? [] : ["from", [entry.from].flat().join(" | ")]
+        ].flat().join(" ");
+        const allowed = (options.allow ?? []).map((entry) => typeof entry === "string" ? entry : label(entry)).join(", ");
+        const hint = options.message ? ` ${options.message}` : "";
+        for (const item of program.body.flatMap(filesTopLevelItems)) {
+          const what = item.name && item.kind !== "statement" ? `${item.kind} '${item.name}'` : item.kind;
+          const denied = deny.find(matches(item));
+          if (denied) {
+            context.report({
+              node: item.node,
+              messageId: "denied",
+              data: { what, message: denied.message ? ` ${denied.message}` : hint }
+            });
+          } else if (allow && !allow.some(matches(item))) {
+            context.report({
+              node: item.node,
+              messageId: "unlisted",
+              data: { what, allowed, message: hint }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
+import { defineRule as defineRule51 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -5258,7 +6100,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule44({
+var filesTypesOnly = defineRule51({
   meta: {
     type: "problem",
     schema: [
@@ -5366,8 +6208,8 @@ var filesTypesOnly = defineRule44({
 });
 
 // src/rules/layout/layout-arrow-body.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
-var layoutArrowBody = defineRule45({
+import { defineRule as defineRule52 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule52({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5419,12 +6261,12 @@ var layoutArrowBody = defineRule45({
 });
 
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } 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 = defineRule46({
+var layoutCallArguments = defineRule53({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5443,6 +6285,12 @@ var layoutCallArguments = defineRule46({
             type: "boolean",
             default: true
           },
+          pipe: {
+            type: "object",
+            additionalProperties: false,
+            required: ["min"],
+            properties: { min: { type: "integer", minimum: 2 }, methods: { type: "array", items: { type: "string" } } }
+          },
           hug: {
             type: "object",
             additionalProperties: false,
@@ -5465,6 +6313,7 @@ var layoutCallArguments = defineRule46({
     ],
     messages: {
       multiline: "A call with {{min}}+ arguments puts each argument on its own line.",
+      pipe: "A pipe with {{min}}+ steps puts each step on its own line.",
       hug: "Put every argument on its own line. Only a last callback, object or array may hug the call, after simple arguments.",
       prefer: "Hug the last argument: it is a callback, object or array after simple arguments.",
       join: "This fits on one line, so keep it on one line."
@@ -5474,11 +6323,13 @@ var layoutCallArguments = defineRule46({
     let options = {};
     let minArguments = 3;
     let indentUnit = sourceIndentUnit();
-    const split = (node) => {
+    let pipeMethods = new Set;
+    const isPipe = (node) => node.callee.type === "MemberExpression" && pipeMethods.has(astMemberName(node.callee) ?? "");
+    const split = (node, min, messageId) => {
       const args = node.arguments;
       const last = args.at(-1);
       const source = context.sourceCode;
-      if (args.length < minArguments || !last || args.some((arg) => (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") && arg.loc.start.line !== arg.loc.end.line)) {
+      if (args.length < min || !last || args.some((arg) => (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") && arg.loc.start.line !== arg.loc.end.line)) {
         return;
       }
       const text = source.text;
@@ -5500,8 +6351,8 @@ var layoutCallArguments = defineRule46({
       const argumentIndent = `${baseIndent}${indentUnit}`;
       context.report({
         node,
-        messageId: "multiline",
-        data: { min: String(minArguments) },
+        messageId,
+        data: { min: String(min) },
         fix: unsafe ? undefined : (fixer) => gaps.map((gap, index) => {
           if (index === 0) {
             return fixer.replaceTextRange(gap, `${newline}${argumentIndent}`);
@@ -5519,11 +6370,23 @@ var layoutCallArguments = defineRule46({
       const last = args.at(-1);
       const open = source.getTokenAfter(node.typeArguments ?? node.callee);
       const close = source.getLastToken(node);
-      if (!first || !last || !open || !close || args.every(astIsOneLine) || source.getCommentsInside(node).length > 0) {
+      if (!first || !last || !open || !close || source.getCommentsInside(node).length > 0) {
+        return;
+      }
+      if (args.every(astIsOneLine)) {
+        if (first.loc.start.line > open.loc.end.line && close.loc.start.line === last.loc.end.line) {
+          const newline2 = sourceNewline(text);
+          const base2 = sourceLineIndent(text, open.range[0]);
+          context.report({
+            node,
+            messageId: "hug",
+            fix: (fixer) => sourceRespace(fixer, text, sourceItemGaps(open.range[1], args, close.range[0]), (_, end) => `${newline2}${end ? base2 : `${base2}${indentUnit}`}`)
+          });
+        }
         return;
       }
       const leading = args.slice(0, -1);
-      const canHug = !astIsPipe(node) && leading.every((arg) => astIsOneLine(arg) && astCallDepth(arg) <= 1) && layoutCallArgumentsHuggable(last);
+      const canHug = !isPipe(node) && leading.every((arg) => astIsOneLine(arg) && astCallDepth(arg) <= 1) && layoutCallArgumentsHuggable(last);
       const gaps = sourceItemGaps(open.range[1], args, close.range[0]);
       if (first.loc.start.line > open.loc.end.line) {
         const head = [...leading.map((arg) => source.getText(arg)), text.slice(last.range[0], sourceLineEnd(text, last.range[0]))];
@@ -5549,7 +6412,7 @@ var layoutCallArguments = defineRule46({
         fix: (fixer) => sourceRespace(fixer, text, gaps, (_, end) => `${newline}${end ? base : inner}`)
       });
     };
-    const join3 = (node, items, open, close) => {
+    const join4 = (node, items, open, close) => {
       const source = context.sourceCode;
       const text = source.text;
       const first = items.at(0);
@@ -5569,14 +6432,16 @@ var layoutCallArguments = defineRule46({
     };
     const call = (node) => {
       const source = context.sourceCode;
-      if (options.split !== false) {
-        split(node);
+      if (options.pipe && isPipe(node)) {
+        split(node, options.pipe.min, "pipe");
+      } else if (options.split !== false) {
+        split(node, minArguments, "multiline");
       }
       if (options.hug) {
         hug(node, options.hug.max);
       }
-      if (options.join && !(options.join.keep ?? []).includes(source.getText(node.callee)) && !(astIsPipe(node) && node.arguments.length > 1) && astCallDepth(node) <= (options.join.nesting ?? Number.POSITIVE_INFINITY)) {
-        join3(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
+      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)) {
+        join4(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
       }
     };
     const parameters = (node) => {
@@ -5586,13 +6451,14 @@ var layoutCallArguments = defineRule46({
       if (!options.join || !first || !last) {
         return;
       }
-      join3(node, node.params, source.getTokenBefore(first, { filter: (token) => token.value === "(" }), source.getTokenAfter(last, { filter: (token) => token.value === ")" }));
+      join4(node, node.params, source.getTokenBefore(first, { filter: (token) => token.value === "(" }), source.getTokenAfter(last, { filter: (token) => token.value === ")" }));
     };
     return {
       before() {
         options = optionsFirst(context, {});
         minArguments = options.min ?? 3;
         indentUnit = sourceIndentUnit(options.indent);
+        pipeMethods = new Set(options.pipe?.methods ?? ["pipe"]);
       },
       CallExpression: call,
       NewExpression: call,
@@ -5606,12 +6472,12 @@ var layoutCallArguments = defineRule46({
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
+import { defineRule as defineRule54 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule47({
+var layoutCallArray = defineRule54({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5727,22 +6593,29 @@ var layoutCallArray = defineRule47({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
-function layoutCallDepthOuter(node) {
+import { defineRule as defineRule55 } 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 = defineRule48({
+var layoutCallDepth = defineRule55({
   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: {
@@ -5751,10 +6624,11 @@ var layoutCallDepth = defineRule48({
   },
   createOnce(context) {
     let max = 2;
+    let callbacks = false;
     const check = (node) => {
-      const depth = astCallDepth(node);
-      const outer = layoutCallDepthOuter(node);
-      if (!astIsOneLine(node) || depth <= max || outer !== undefined && astIsOneLine(outer) && astCallDepth(outer) > max) {
+      const depth = astCallDepth(node, callbacks);
+      const outer = layoutCallDepthOuter(node, callbacks);
+      if (!astIsOneLine(node) || depth <= max || outer !== undefined && astIsOneLine(outer) && astCallDepth(outer, callbacks) > max) {
         return;
       }
       context.report({
@@ -5765,7 +6639,9 @@ var layoutCallDepth = defineRule48({
     };
     return {
       before() {
-        max = optionsFirst(context, {}).max ?? 2;
+        const options = optionsFirst(context, {});
+        max = options.max ?? 2;
+        callbacks = options.callbacks ?? false;
       },
       CallExpression: check,
       NewExpression: check
@@ -5774,8 +6650,8 @@ var layoutCallDepth = defineRule48({
 });
 
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
-var layoutChain = defineRule49({
+import { defineRule as defineRule56 } from "@oxlint/plugins";
+var layoutChain = defineRule56({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5894,8 +6770,8 @@ var layoutChain = defineRule49({
 });
 
 // src/rules/layout/layout-items.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
-var layoutItems = defineRule50({
+import { defineRule as defineRule57 } from "@oxlint/plugins";
+var layoutItems = defineRule57({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5950,8 +6826,8 @@ var layoutItems = defineRule50({
 });
 
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule51({
+import { defineRule as defineRule58 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule58({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6039,8 +6915,8 @@ var layoutJsxAttributes = defineRule51({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule52({
+import { defineRule as defineRule59 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule59({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6076,7 +6952,7 @@ var layoutKeyValue = defineRule52({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule60 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
@@ -6084,7 +6960,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 = defineRule53({
+var layoutObject = defineRule60({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6096,6 +6972,10 @@ var layoutObject = defineRule53({
           min: { type: "integer", minimum: 1, default: 3 },
           scope: { type: "string", enum: ["call-args", "all"], default: "call-args" },
           indent: { ...sourceIndentSchema, default: 2 },
+          params: { type: "boolean", default: false },
+          nested: { type: "boolean", default: false },
+          siblings: { type: "boolean", default: false },
+          inner: { type: "integer", minimum: 1 },
           join: {
             type: "object",
             additionalProperties: false,
@@ -6111,6 +6991,11 @@ var layoutObject = defineRule53({
     messages: {
       callArgs: "Object with {{min}}+ properties in a call should have each property on its own line.",
       always: "Object with {{min}}+ properties should have each property on its own line.",
+      nested: "An object holding an object or function should have each property on its own line.",
+      nestedName: "An object holding an object or function should have each property on its own line. Name this call first: split here, it would break a chained call or a ternary.",
+      siblings: "A sibling call in this list splits its object; split this one too.",
+      inner: "An object with {{inner}}+ entries inside a split object should have each entry on its own line.",
+      params: "Destructured parameter with {{min}}+ properties should have each property on its own line.",
       join: "This object fits on one line, so keep it on one line."
     }
   },
@@ -6120,39 +7005,167 @@ var layoutObject = defineRule53({
     let indentUnit = sourceIndentUnit();
     let newline = `
 `;
-    let join3;
-    return {
-      before() {
-        const options = optionsFirst(context, {});
-        minProperties = options.min ?? 3;
-        scope = options.scope ?? "call-args";
-        indentUnit = sourceIndentUnit(options.indent);
-        newline = sourceNewline(context.sourceCode.text);
-        join3 = options.join;
-      },
-      ObjectExpression(node) {
-        const source = context.sourceCode;
-        const text = source.text;
-        const properties = node.properties;
-        const split = properties.length >= minProperties;
-        if (split ? !astIsOneLine(node) : !join3 || astIsOneLine(node)) {
-          return;
+    let join4;
+    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;
         }
-        const parent = node.parent;
-        const call = (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node) ? parent : undefined;
-        if (scope === "call-args" && !call) {
-          return;
+      }
+      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 (!split) {
-          const callee = call ? astDottedName(call.callee) : undefined;
-          const kept = callee !== undefined && (join3?.keep ?? []).some((name) => callee === name || callee.endsWith(`.${name}`));
-          if (kept || properties.length === 0 || !properties.every(layoutObjectIsFlat) || source.getCommentsInside(node).length > 0) {
-            return;
+        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;
           }
-          const gaps = sourceItemGaps(node.range[0] + 1, properties, node.range[1] - 1);
+          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 && (join4?.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, {});
+        minProperties = options.min ?? 3;
+        scope = options.scope ?? "call-args";
+        indentUnit = sourceIndentUnit(options.indent);
+        newline = sourceNewline(context.sourceCode.text);
+        join4 = 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 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) : !join4 || astIsOneLine(node)) {
+          return;
+        }
+        const call = (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node) ? parent : undefined;
+        if (scope === "call-args" && !call) {
+          return;
+        }
+        if (!split) {
+          if (joinBlocked(node, call)) {
+            return;
+          }
+          const gaps = sourceItemGaps(node.range[0] + 1, properties, node.range[1] - 1);
           const comma = text.slice(...gaps.at(-1) ?? [0, 0]).includes(",") ? "," : "";
           const joined = ` ${properties.map((property) => source.getText(property)).join(", ")}${comma} `;
-          if (sourceJoinedWidth(text, node.range[0] + 1, joined, node.range[1] - 1) > (join3?.max ?? 0)) {
+          if (sourceJoinedWidth(text, node.range[0] + 1, joined, node.range[1] - 1) > (join4?.max ?? 0)) {
             return;
           }
           context.report({
@@ -6162,46 +7175,16 @@ var layoutObject = defineRule53({
           });
           return;
         }
-        const baseIndent = sourceLineIndent(text, node.range[0]);
-        const propertyIndent = `${baseIndent}${indentUnit}`;
-        const close = node.range[1] - 1;
-        context.report({
-          node,
-          messageId: scope === "all" ? "always" : "callArgs",
-          data: { min: String(minProperties) },
-          fix: (fixer) => {
-            if (source.getCommentsInside(node).length > 0 || !layoutObjectIsWhitespace(text.slice(node.range[0] + 1, properties[0].range[0]))) {
-              return null;
-            }
-            const gaps = [[node.range[0] + 1, properties[0].range[0]]];
-            for (const [index, property] of properties.entries()) {
-              const next = properties.at(index + 1);
-              const after = property.range[1];
-              const limit = next ? next.range[0] : close;
-              const between = text.slice(after, limit);
-              const comma = between.indexOf(",");
-              if (comma === -1) {
-                if (next || !layoutObjectIsWhitespace(between)) {
-                  return null;
-                }
-                gaps.push([after, close]);
-                continue;
-              }
-              if (!layoutObjectIsWhitespace(between.slice(0, comma)) || !layoutObjectIsWhitespace(between.slice(comma + 1))) {
-                return null;
-              }
-              gaps.push([after + comma + 1, limit]);
-            }
-            return gaps.map((gap, index) => fixer.replaceTextRange(gap, index === gaps.length - 1 ? `${newline}${baseIndent}` : `${newline}${propertyIndent}`));
-          }
-        });
+        const messageId = scope === "all" ? "always" : "callArgs";
+        const nestedId = breaksAround(node) ? "nestedName" : "nested";
+        reportSplit(node, properties, node.range[0], node.range[1] - 1, holds ? nestedId : messageId);
       }
     };
   }
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
+import { defineRule as defineRule61 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -6230,7 +7213,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule54({
+var layoutPadding = defineRule61({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6319,23 +7302,33 @@ var layoutPadding = defineRule54({
 });
 
 // src/rules/layout/layout-pipe.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
-var layoutPipe = defineRule55({
+import { defineRule as defineRule62 } from "@oxlint/plugins";
+var layoutPipe = defineRule62({
   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) {
@@ -6351,7 +7344,7 @@ var layoutPipe = defineRule55({
 });
 
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule63 } from "@oxlint/plugins";
 function layoutTernaryLines(node) {
   return node.loc.end.line - node.loc.start.line + 1;
 }
@@ -6359,7 +7352,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 = defineRule56({
+var layoutTernary = defineRule63({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6474,14 +7467,75 @@ var layoutTernary = defineRule56({
   }
 });
 
+// src/rules/layout/layout-type-arguments.ts
+import { defineRule as defineRule64 } from "@oxlint/plugins";
+var layoutTypeArguments = defineRule64({
+  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 defineRule57 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule57({
+var namingDeclarations = defineRule65({
   meta: {
     type: "problem",
-    schema: [
-      {
+    schema: {
+      type: "array",
+      items: {
         type: "object",
         additionalProperties: false,
         properties: {
@@ -6492,56 +7546,61 @@ var namingDeclarations = defineRule57({
           allow: optionsPatternSchema
         }
       }
-    ],
+    },
     messages: {
       prefix: "'{{name}}' must start with file prefix '{{prefix}}'.",
       pattern: "'{{name}}' must match {{pattern}}."
     }
   },
   createOnce(context) {
-    let options = {};
-    let kinds = null;
-    let allowed = [];
-    let expected = [];
-    let prefixes = [];
-    let label = "";
+    let checks = [];
     function check(node) {
       const declarator = node.type === "VariableDeclarator";
       const kind = declarationsKindOf(node, declarator ? [node.parent] : []);
       const name = declarationsIdName(node);
       const loop = declarator ? node.parent.parent : null;
       const loopHeader = loop?.type === "ForStatement" ? loop.init === node.parent : (loop?.type === "ForInStatement" || loop?.type === "ForOfStatement") && loop.left === node.parent;
-      if (!kind || !name || loopHeader || kinds && !kinds.has(kind) || optionsPatternsTest(allowed, name)) {
+      if (!kind || !name || loopHeader) {
         return;
       }
-      if (expected.length > 0) {
-        if (optionsPatternsTest(expected, name)) {
-          return;
+      for (const { kinds, allowed, expected, prefixes, label, normalize } of checks) {
+        if (kinds && !kinds.has(kind) || optionsPatternsTest(allowed, name)) {
+          continue;
+        }
+        if (expected.length > 0) {
+          if (!optionsPatternsTest(expected, name)) {
+            context.report({
+              node,
+              messageId: "pattern",
+              data: { name, pattern: label }
+            });
+          }
+          continue;
+        }
+        if (!namingHasFilePrefix(name, prefixes, normalize)) {
+          context.report({
+            node,
+            messageId: "prefix",
+            data: { name, prefix: prefixes.join(" or ") }
+          });
         }
-        context.report({
-          node,
-          messageId: "pattern",
-          data: { name, pattern: label }
-        });
-        return;
-      }
-      if (namingHasFilePrefix(name, prefixes, options.normalize)) {
-        return;
       }
-      context.report({
-        node,
-        messageId: "prefix",
-        data: { name, prefix: prefixes.join(" or ") }
-      });
     }
     return {
       before() {
-        options = optionsFirst(context, { stem: "before-first-dot", normalize: "remove-separators" });
-        kinds = options.kinds?.length ? new Set(options.kinds) : null;
-        allowed = optionsPatterns(options.allow);
-        expected = optionsPatterns(options.pattern, options.flags);
-        label = optionsPatternLabel(options.pattern);
-        prefixes = namingFilePrefixesFor(context.filename, options);
+        const given = optionsAll(context);
+        const captures = namingCaptures(context.filename) ?? {};
+        checks = (given.length > 0 ? given : [{}]).map((options) => {
+          const sources = options.pattern === undefined ? [] : [options.pattern].flat().map((source) => namingExpand(source, captures, true, optionsEscape));
+          return {
+            kinds: options.kinds?.length ? new Set(options.kinds) : null,
+            allowed: optionsPatterns(options.allow),
+            expected: optionsPatterns(sources, options.flags),
+            prefixes: namingFilePrefixesFor(context.filename, options),
+            label: optionsPatternLabel(sources),
+            normalize: options.normalize
+          };
+        });
       },
       FunctionDeclaration: check,
       ClassDeclaration: check,
@@ -6554,33 +7613,14 @@ var namingDeclarations = defineRule57({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
+import { defineRule as defineRule66 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
   services: { type: "boolean" },
   allow: optionsPatternSchema
 };
-function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
-  let pattern = "";
-  let index = 0;
-  while (index < template.length) {
-    const char = template[index];
-    if (char === "{") {
-      const end = template.indexOf("}", index);
-      if (end === -1) {
-        return null;
-      }
-      pattern += `(?<${template.slice(index + 1, end)}>${placeholder})`;
-      index = end + 1;
-      continue;
-    }
-    pattern += /[.+^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
-    index += 1;
-  }
-  return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
-}
-var namingExports = defineRule58({
+var namingExports = defineRule66({
   meta: {
     type: "problem",
     schema: {
@@ -6610,7 +7650,7 @@ var namingExports = defineRule58({
               mode: { type: "string", enum: ["template"] },
               ...namingExportsScopeProperties,
               file: { type: "string" },
-              export: { type: "string" },
+              export: optionsPatternSchema,
               match: { type: "string", enum: ["all", "some"] },
               placeholder: { type: "string" },
               camelCase: { type: "boolean" }
@@ -6637,23 +7677,15 @@ var namingExports = defineRule58({
           const allowed = optionsPatterns(options.allow);
           if (options.mode === "template") {
             const file = namingBasename(context.filename);
-            const groups = matchTemplate(file, options.file, options.placeholder);
-            if (!groups) {
+            const captures2 = namingCaptures(context.filename, { file: options.file, placeholder: options.placeholder });
+            if (!captures2) {
               continue;
             }
-            const expected2 = options.export.replaceAll(/\{([^}]+)\}/g, (placeholder, key) => {
-              const group = groups[key.toLowerCase()];
-              if (!group) {
-                return placeholder;
-              }
-              if (/^[A-Z]/.test(key)) {
-                return namingPascalCase(group);
-              }
-              return options.camelCase ? namingCamelCase(group) : group;
-            });
+            const names2 = [options.export].flat().map((template) => namingExpand(template, captures2, options.camelCase ?? false));
+            const expected2 = names2.join(" or ");
             const functions = (scope === "exports" ? exportsFunctions(program, true) : declarationsFunctions(program)).filter(({ name }) => !optionsPatternsTest(allowed, name));
             if (options.match === "some") {
-              if (functions.some((item) => item.name === expected2)) {
+              if (functions.some((item) => names2.includes(item.name))) {
                 continue;
               }
               const first = functions.at(0);
@@ -6665,7 +7697,7 @@ var namingExports = defineRule58({
               continue;
             }
             for (const item of functions) {
-              if (item.name !== expected2) {
+              if (!names2.includes(item.name)) {
                 context.report({
                   node: item.node,
                   messageId: "mismatch",
@@ -6687,7 +7719,9 @@ var namingExports = defineRule58({
             names.push(...declarationsPublicServiceMethods(program));
           }
           const prefixes = options.mode === "pattern" ? [] : namingFilePrefixesFor(context.filename, options);
-          const expected = options.mode === "pattern" ? optionsPatternsWithEmpty(options.pattern, options.flags) : [];
+          const captures = namingCaptures(context.filename) ?? {};
+          const sources = options.mode === "pattern" ? [options.pattern].flat().map((source) => namingExpand(source, captures, true, optionsEscape)) : [];
+          const expected = optionsPatternsWithEmpty(sources, options.mode === "pattern" ? options.flags : undefined);
           for (const item of declarationsUnique(names)) {
             if (optionsPatternsTest(allowed, item.name)) {
               continue;
@@ -6697,7 +7731,7 @@ var namingExports = defineRule58({
                 context.report({
                   node: item.node,
                   messageId: "pattern",
-                  data: { name: item.name, pattern: optionsPatternLabel(options.pattern) }
+                  data: { name: item.name, pattern: optionsPatternLabel(sources) }
                 });
               }
               continue;
@@ -6716,71 +7750,586 @@ var namingExports = defineRule58({
   }
 });
 
-// src/rules/naming/naming-file.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
-import { readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule59({
+// src/rules/naming/naming-file.ts
+import { defineRule as defineRule67 } from "@oxlint/plugins";
+import { readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+var namingFile = defineRule67({
+  meta: {
+    type: "problem",
+    schema: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          pattern: optionsPatternSchema,
+          message: { type: "string" },
+          flags: { type: "string" },
+          unique: { type: "string", minLength: 1 },
+          template: optionsPatternSchema,
+          placeholder: { type: "string" }
+        },
+        required: ["message"],
+        anyOf: [{ required: ["pattern"] }, { required: ["template"] }]
+      }
+    },
+    messages: {
+      mismatch: "{{message}}",
+      duplicate: "'{{key}}' is also used by {{others}}; this part of the file name must be unique in its folder."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const basename3 = namingBasename(context.filename);
+        let siblings;
+        for (const { pattern, message, flags, unique, template, placeholder } of optionsAll(context)) {
+          const patterns = optionsPatternsWithEmpty(pattern, flags);
+          const path = context.filename.replaceAll("\\", "/").split("/");
+          const templates = [template ?? []].flat();
+          const fits = templates.some((item) => namingTemplatePattern(item, placeholder)?.test(path.slice(-item.split("/").length).join("/")));
+          if (pattern !== undefined && !optionsPatternsTest(patterns, basename3) || templates.length > 0 && !fits) {
+            context.report({
+              node: program,
+              messageId: "mismatch",
+              data: { message }
+            });
+          }
+          if (unique === undefined) {
+            continue;
+          }
+          const matcher = new RegExp(unique);
+          const keyOf = (name) => {
+            const match = matcher.exec(name);
+            return match ? match.at(1) ?? match[0] : undefined;
+          };
+          const key = keyOf(basename3);
+          if (key === undefined) {
+            continue;
+          }
+          if (!siblings) {
+            try {
+              siblings = readdirSync2(dirname5(context.filename), { withFileTypes: true }).flatMap((entry) => entry.isFile() ? [entry.name] : []);
+            } catch {
+              siblings = [];
+            }
+          }
+          const others = siblings.filter((name) => name !== basename3 && optionsPatternsTest(patterns, name) && keyOf(name) === key);
+          if (others.length > 0) {
+            context.report({
+              node: program,
+              messageId: "duplicate",
+              data: { key, others: others.join(", ") }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-folder.ts
+import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { posix as posix2 } from "node:path";
+var namingFolder = defineRule68({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
+          separators: { type: "array", items: { type: "string" } },
+          after: { type: "string" },
+          prefixes: { type: "array", items: { type: "string", minLength: 1 } }
+        }
+      }
+    ],
+    messages: {
+      prefix: "File '{{file}}' must start with '{{expected}}' to match its domain folder '{{folder}}'."
+    }
+  },
+  createOnce(context) {
+    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 parent = [all.at(-1) ?? ""];
+        let folders = after ? undefined : parent;
+        const marker = (after ?? "").split("/").filter(Boolean);
+        for (let index = all.length - marker.length;marker.length > 0 && index >= 0 && !folders; index -= 1) {
+          if (marker.every((part, offset) => all[index + offset] === part)) {
+            folders = all.slice(index + marker.length);
+          }
+        }
+        if (!folders) {
+          return;
+        }
+        const resolved = folders.length > 0 ? folders : parent;
+        const last = resolved.at(-1) ?? "";
+        const joiner = separators[0] ?? "-";
+        const singular = singularize === "trailing-s" && last.endsWith("s") && last.length > 1;
+        const prefixes = [
+          resolved.join(joiner),
+          ...singular ? [[...resolved.slice(0, -1), last.slice(0, -1)].join(joiner)] : []
+        ].filter(Boolean);
+        const file = namingBasename(context.filename);
+        const rawStem = file.replace(/\.(tsx?|jsx?)$/, "");
+        const strip = stripPrefixes.find((prefix) => rawStem.startsWith(prefix));
+        const stem = strip ? rawStem.slice(strip.length) : rawStem;
+        if (prefixes.some((prefix) => stem === prefix || separators.some((separator) => stem.startsWith(`${prefix}${separator}`)))) {
+          return;
+        }
+        context.report({
+          node: program,
+          messageId: "prefix",
+          data: {
+            file,
+            folder: resolved.join("/"),
+            expected: prefixes.map((prefix) => `${stripPrefixes[0] ?? ""}${prefix}`).join(" or ")
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-imports.ts
+import { defineRule as defineRule69 } from "@oxlint/plugins";
+var namingImports = defineRule69({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          imports: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                source: { type: "string" },
+                name: optionsPatternSchema,
+                namespace: { type: "boolean" },
+                placeholder: { type: "string" }
+              },
+              required: ["source", "name"]
+            }
+          }
+        },
+        required: ["imports"]
+      }
+    ],
+    messages: {
+      name: "Import '{{source}}' as '{{expected}}', not '{{actual}}'.",
+      namespace: "Import '{{source}}' as a namespace: import * as {{expected}}."
+    }
+  },
+  createOnce(context) {
+    let entries = [];
+    return {
+      before() {
+        entries = optionsFirst(context, { imports: [] }).imports.flatMap((entry) => {
+          const pattern = namingTemplatePattern(entry.source, entry.placeholder ?? "[^/]+");
+          return pattern ? [{ pattern, names: [entry.name].flat(), namespace: entry.namespace !== false }] : [];
+        });
+        if (entries.length === 0) {
+          return false;
+        }
+      },
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        for (const entry of entries) {
+          const match = entry.pattern.exec(source);
+          if (!match) {
+            continue;
+          }
+          const names = entry.names.map((template) => namingExpand(template, { ...match.groups }, true));
+          const expected = names.join(" or ");
+          for (const specifier of node.specifiers) {
+            if (specifier.type !== "ImportNamespaceSpecifier" && entry.namespace) {
+              context.report({
+                node: specifier,
+                messageId: "namespace",
+                data: { source, expected }
+              });
+            } else if (specifier.type !== "ImportSpecifier" && !names.includes(specifier.local.name)) {
+              context.report({
+                node: specifier,
+                messageId: "name",
+                data: { source, expected, actual: specifier.local.name }
+              });
+            }
+          }
+          return;
+        }
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-keys.ts
+import { defineRule as defineRule70 } from "@oxlint/plugins";
+function namingKeysNames(value) {
+  const dotted = astDottedName(value);
+  return dotted === undefined ? [] : [...new Set([dotted.split(".").at(-1) ?? dotted, dotted.split(".")[0]])];
+}
+function namingKeysSingular(key, options) {
+  return options.singularize === "trailing-s" && key.length > 1 && key.endsWith("s") ? [key, key.slice(0, -1)] : [key];
+}
+function namingKeysSources(options, captures, keys) {
+  const last = keys.at(-1) ?? "";
+  return [options.name ?? []].flat().flatMap((source) => namingKeysSingular(last, options).map((key) => {
+    const values = { ...captures, path: keys.join("-"), key };
+    return namingExpand(source, values, true, optionsEscape);
+  }));
+}
+function namingKeysFunction(value) {
+  if (astIsInlineFunction(value)) {
+    return value;
+  }
+  return value.type === "CallExpression" ? value.arguments.find(astIsInlineFunction) ?? namingKeysFunction(value.callee) : undefined;
+}
+function namingKeysYielded(node) {
+  let found;
+  astSome(node, (candidate) => {
+    const call = candidate.type === "YieldExpression" && candidate.delegate && candidate.argument ? astUnwrap(candidate.argument) : undefined;
+    found ??= call?.type === "CallExpression" ? call : undefined;
+    return found !== undefined;
+  });
+  return found;
+}
+function namingKeysAssigned(fn, returned) {
+  let found;
+  astSome(fn.body, (candidate) => {
+    const local = candidate.type === "VariableDeclarator" && candidate.id.type === "Identifier" && candidate.init ? candidate.id.name : undefined;
+    const used = local !== undefined && astSome(returned, (node) => node.type === "Identifier" && node.name === local);
+    found ??= used && candidate.type === "VariableDeclarator" && candidate.init ? namingKeysYielded(candidate.init) : undefined;
+    return found !== undefined;
+  });
+  return found;
+}
+function namingKeysCalled(fn) {
+  const returned = astReturnExpressions(fn).at(-1);
+  if (!returned) {
+    return;
+  }
+  const plain = astUnwrap(returned);
+  const direct = !fn.generator && plain.type === "CallExpression" ? plain : undefined;
+  const call = namingKeysYielded(returned) ?? namingKeysAssigned(fn, returned) ?? direct;
+  return call ? astDottedName(call.callee) : undefined;
+}
+var namingKeys = defineRule70({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          callees: { type: "array", items: { type: "string" }, minItems: 1 },
+          exports: optionsPatternSchema,
+          name: optionsPatternSchema,
+          keys: optionsPatternSchema,
+          inline: { type: "boolean" },
+          delegate: { type: "boolean" },
+          allow: optionsPatternSchema,
+          singularize: { type: "string", enum: ["none", "trailing-s"] }
+        },
+        anyOf: [{ required: ["callees"] }, { required: ["exports"] }]
+      }
+    ],
+    messages: {
+      name: "'{{name}}' under key '{{path}}' must match {{pattern}}.",
+      key: "Key '{{key}}' in '{{path}}' must match {{pattern}}.",
+      inline: "Bind a named function under '{{path}}', not an inline one.",
+      delegate: "'{{path}}' must return a call to '{{path}}' on its service, not '{{called}}'."
+    }
+  },
+  createOnce(context) {
+    let options = {};
+    let captures = {};
+    let callees = [];
+    let exported = [];
+    let allowed = [];
+    let keyPatterns = [];
+    function checkValue(value, keys) {
+      const path = keys.join(".");
+      const fn = namingKeysFunction(value);
+      const names = namingKeysNames(value);
+      const sources = namingKeysSources(options, captures, keys);
+      const called = options.delegate && fn ? namingKeysCalled(fn) : undefined;
+      if (fn && astIsInlineFunction(value) && options.inline === false) {
+        context.report({
+          node: value,
+          messageId: "inline",
+          data: { path }
+        });
+      }
+      if (called !== undefined && called.split(".").slice(1).join(".") !== path) {
+        context.report({
+          node: value,
+          messageId: "delegate",
+          data: { path, called }
+        });
+      }
+      if (sources.length > 0 && names.length > 0 && !names.some((name) => optionsPatternsTest(optionsPatterns(sources), name))) {
+        context.report({
+          node: value,
+          messageId: "name",
+          data: { name: names[0], path, pattern: optionsPatternLabel(sources) }
+        });
+      }
+    }
+    function check(object, path) {
+      for (const property of object.properties) {
+        const key = declarationsPropertyName(property);
+        const keys = key === undefined ? path : [...path, key];
+        if (property.type !== "Property" || key === undefined || optionsPatternsTest(allowed, keys.join("."))) {
+          continue;
+        }
+        if (keyPatterns.length > 0 && !optionsPatternsTest(keyPatterns, key)) {
+          context.report({
+            node: property.key,
+            messageId: "key",
+            data: { key, path: keys.join("."), pattern: optionsPatternLabel(options.keys) }
+          });
+        }
+        if (property.value.type === "ObjectExpression") {
+          check(property.value, keys);
+        } else {
+          checkValue(property.value, keys);
+        }
+      }
+    }
+    return {
+      before() {
+        options = optionsFirst(context, {});
+        captures = namingCaptures(context.filename) ?? {};
+        callees = optionsWildcards(options.callees);
+        exported = optionsPatterns(options.exports);
+        allowed = optionsPatterns(options.allow);
+        keyPatterns = optionsPatterns(options.keys);
+        if (callees.length === 0 && exported.length === 0) {
+          return false;
+        }
+      },
+      CallExpression(node) {
+        const first = node.arguments.at(0);
+        if (first?.type === "ObjectExpression" && optionsPatternsTest(callees, astDottedName(node.callee) ?? "")) {
+          check(first, []);
+        }
+      },
+      VariableDeclarator(node) {
+        const statement = node.parent.parent;
+        const top = statement?.type === "ExportNamedDeclaration" && statement.parent.type === "Program";
+        const value = node.init ? astUnwrap(node.init) : null;
+        if (top && node.id.type === "Identifier" && value?.type === "ObjectExpression" && optionsPatternsTest(exported, node.id.name)) {
+          check(value, []);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-labels.ts
+import { defineRule as defineRule71 } from "@oxlint/plugins";
+function namingLabelsRoot(node) {
+  return node.type === "CallExpression" ? namingLabelsRoot(node.callee) : astDottedName(node);
+}
+function namingLabelsBinding(node, within) {
+  const parent = node.parent;
+  if (!parent) {
+    return;
+  }
+  if (parent.type === "VariableDeclarator" && parent.init === node) {
+    return parent.id.type === "Identifier" ? parent.id.name : undefined;
+  }
+  if ((parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node) {
+    return parent.id?.name;
+  }
+  if (parent.type === "CallExpression" && parent.callee === node || parent.type === "MemberExpression" && parent.object === node) {
+    return namingLabelsBinding(parent, within);
+  }
+  const owner = parent.type === "CallExpression" && parent.callee.type === "MemberExpression" ? astDottedName(parent.callee) : undefined;
+  return owner !== undefined && optionsPatternsTest(within, owner) ? owner.split(".").at(-2) : undefined;
+}
+function namingLabelsTarget(first, property) {
+  if (property === undefined) {
+    return first;
+  }
+  const held = first.type === "ObjectExpression" ? first.properties.find((item) => declarationsPropertyName(item) === property) : undefined;
+  return held?.type === "Property" ? held.value : undefined;
+}
+function namingLabelsPlain(text, loose) {
+  return loose ? text.replaceAll(/[._\-/\s]/g, "").toLowerCase() : text;
+}
+function namingLabelsExpected({ entry, drop }, captures, binding) {
+  const name = drop.reduce((text, pattern) => text.replace(pattern, ""), binding);
+  return [entry.name ?? []].flat().map((template) => namingExpand(template, { ...captures, name }, false));
+}
+var namingLabels = defineRule71({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          labels: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                callee: optionsPatternSchema,
+                property: { type: "string" },
+                name: optionsPatternSchema,
+                pattern: optionsPatternSchema,
+                drop: optionsPatternSchema,
+                loose: { type: "boolean" },
+                within: optionsPatternSchema
+              },
+              required: ["callee"],
+              anyOf: [{ required: ["name"] }, { required: ["pattern"] }]
+            }
+          }
+        },
+        required: ["labels"]
+      }
+    ],
+    messages: {
+      name: "'{{label}}' must be '{{expected}}', after the name '{{name}}'.",
+      pattern: "'{{label}}' must match {{pattern}}."
+    }
+  },
+  createOnce(context) {
+    let entries = [];
+    let captures = {};
+    return {
+      before() {
+        const paths = namingCaptures(context.filename) ?? {};
+        captures = paths;
+        entries = optionsFirst(context, { labels: [] }).labels.map((entry) => ({
+          callees: optionsWildcards(entry.callee),
+          entry,
+          drop: optionsPatterns(entry.drop),
+          within: optionsWildcards(entry.within),
+          patterns: [entry.pattern ?? []].flat().map((source) => namingExpand(source, paths, true, optionsEscape))
+        }));
+        if (entries.length === 0) {
+          return false;
+        }
+      },
+      CallExpression(node) {
+        const root = namingLabelsRoot(node.callee);
+        const first = node.arguments.at(0);
+        if (root === undefined || !first) {
+          return;
+        }
+        for (const compiled of entries) {
+          const target = optionsPatternsTest(compiled.callees, root) ? namingLabelsTarget(first, compiled.entry.property) : undefined;
+          const label = target ? astStaticString(target) : undefined;
+          if (!target || label === undefined) {
+            continue;
+          }
+          if (compiled.patterns.length > 0 && !optionsPatternsTest(optionsPatterns(compiled.patterns), label)) {
+            context.report({
+              node: target,
+              messageId: "pattern",
+              data: { label, pattern: optionsPatternLabel(compiled.patterns) }
+            });
+          }
+          const binding = namingLabelsBinding(node, compiled.within);
+          const expected = binding === undefined ? [] : namingLabelsExpected(compiled, captures, binding);
+          const plain = expected.map((item) => namingLabelsPlain(item, compiled.entry.loose));
+          if (binding !== undefined && expected.length > 0 && !plain.includes(namingLabelsPlain(label, compiled.entry.loose))) {
+            context.report({
+              node: target,
+              messageId: "name",
+              data: { label, expected: expected.join(" or "), name: binding }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/naming/naming-pairs.ts
+import { defineRule as defineRule72 } from "@oxlint/plugins";
+function namingPairsArguments(node, found) {
+  if (node.type === "MemberExpression") {
+    return namingPairsArguments(node.object, found);
+  }
+  if (node.type !== "CallExpression") {
+    return found;
+  }
+  const method = node.callee.type === "MemberExpression" ? astMemberName(node.callee) : undefined;
+  const first = node.arguments.at(0);
+  if (method !== undefined && first && !found.has(method)) {
+    found.set(method, first);
+  }
+  return namingPairsArguments(node.callee, found);
+}
+var namingPairs = defineRule72({
   meta: {
     type: "problem",
-    schema: {
-      type: "array",
-      items: {
+    schema: [
+      {
         type: "object",
         additionalProperties: false,
         properties: {
-          pattern: optionsPatternSchema,
-          message: { type: "string" },
-          flags: { type: "string" },
-          unique: { type: "string", minLength: 1 }
+          pairs: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                methods: { type: "array", items: { type: "string" }, minItems: 2, maxItems: 2 },
+                strip: optionsPatternSchema,
+                allow: optionsPatternSchema
+              },
+              required: ["methods"]
+            }
+          }
         },
-        required: ["pattern", "message"]
+        required: ["pairs"]
       }
-    },
+    ],
     messages: {
-      mismatch: "{{message}}",
-      duplicate: "'{{key}}' is also used by {{others}}; this part of the file name must be unique in its folder."
+      pair: "'{{second}}' in .{{secondMethod}}() must share its name with '{{first}}' in .{{firstMethod}}()."
     }
   },
   createOnce(context) {
     return {
-      Program(program) {
-        const basename3 = namingBasename(context.filename);
-        let siblings;
-        for (const { pattern, message, flags, unique } of optionsAll(context)) {
-          const patterns = optionsPatternsWithEmpty(pattern, flags);
-          if (!optionsPatternsTest(patterns, basename3)) {
-            context.report({
-              node: program,
-              messageId: "mismatch",
-              data: { message }
-            });
-          }
-          if (unique === undefined) {
-            continue;
-          }
-          const matcher = new RegExp(unique);
-          const keyOf = (name) => {
-            const match = matcher.exec(name);
-            return match ? match.at(1) ?? match[0] : undefined;
-          };
-          const key = keyOf(basename3);
-          if (key === undefined) {
+      CallExpression(node) {
+        const parent = node.parent;
+        const chained = parent.type === "MemberExpression" && parent.object === node || parent.type === "CallExpression" && parent.callee === node;
+        const { pairs } = optionsFirst(context, { pairs: [] });
+        if (chained || pairs.length === 0) {
+          return;
+        }
+        const found = namingPairsArguments(node, new Map);
+        for (const { methods: [firstMethod, secondMethod], strip, allow } of pairs) {
+          const firstNode = found.get(firstMethod);
+          const secondNode = found.get(secondMethod);
+          const first = firstNode ? astDottedName(firstNode)?.split(".").at(-1) : undefined;
+          const second = secondNode ? astDottedName(secondNode)?.split(".").at(-1) : undefined;
+          const skipped = optionsPatterns(allow);
+          const stem = (name) => optionsPatterns(strip).reduce((text, pattern) => text.replace(pattern, ""), name);
+          if (!secondNode || first === undefined || second === undefined || optionsPatternsTest(skipped, first) || optionsPatternsTest(skipped, second)) {
             continue;
           }
-          if (!siblings) {
-            try {
-              siblings = readdirSync2(dirname4(context.filename), { withFileTypes: true }).flatMap((entry) => entry.isFile() ? [entry.name] : []);
-            } catch {
-              siblings = [];
-            }
-          }
-          const others = siblings.filter((name) => name !== basename3 && optionsPatternsTest(patterns, name) && keyOf(name) === key);
-          if (others.length > 0) {
+          if (stem(first) !== stem(second)) {
             context.report({
-              node: program,
-              messageId: "duplicate",
-              data: { key, others: others.join(", ") }
+              node: secondNode,
+              messageId: "pair",
+              data: { first, second, firstMethod, secondMethod }
             });
           }
         }
@@ -6789,113 +8338,175 @@ var namingFile = defineRule59({
   }
 });
 
-// src/rules/naming/naming-folder.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
-import { posix as posix3 } from "node:path";
-var namingFolder = defineRule60({
+// src/rules/naming/naming-types.ts
+import { defineRule as defineRule73 } from "@oxlint/plugins";
+var namingTypes = defineRule73({
+  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
+import { defineRule as defineRule74 } from "@oxlint/plugins";
+var reactDynamicClasses = defineRule74({
   meta: {
     type: "problem",
     schema: [
       {
         type: "object",
         additionalProperties: false,
-        properties: {
-          singularize: { type: "string", enum: ["none", "trailing-s"] },
-          separators: { type: "array", items: { type: "string" } },
-          after: { type: "string" },
-          prefixes: { type: "array", items: { type: "string", minLength: 1 } }
-        }
+        properties: { attributes: { type: "array", items: { type: "string" } }, message: { type: "string" } }
       }
     ],
-    messages: {
-      prefix: "File '{{file}}' must start with '{{expected}}' to match its domain folder '{{folder}}'."
-    }
+    messages: { forbidden: "{{message}}" }
   },
   createOnce(context) {
-    return {
-      Program(program) {
-        const { singularize = "trailing-s", separators = ["-"], after, prefixes: stripPrefixes = [] } = optionsFirst(context, {});
-        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);
-        for (let index = all.length - marker.length;marker.length > 0 && index >= 0 && !folders; index -= 1) {
-          if (marker.every((part, offset) => all[index + offset] === part)) {
-            folders = all.slice(index + marker.length);
-          }
-        }
-        if (!folders) {
+    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;
         }
-        const resolved = folders.length > 0 ? folders : parent;
-        const last = resolved.at(-1) ?? "";
-        const joiner = separators[0] ?? "-";
-        const singular = singularize === "trailing-s" && last.endsWith("s") && last.length > 1;
-        const prefixes = [
-          resolved.join(joiner),
-          ...singular ? [[...resolved.slice(0, -1), last.slice(0, -1)].join(joiner)] : []
-        ].filter(Boolean);
-        const file = namingBasename(context.filename);
-        const rawStem = file.replace(/\.(tsx?|jsx?)$/, "");
-        const strip = stripPrefixes.find((prefix) => rawStem.startsWith(prefix));
-        const stem = strip ? rawStem.slice(strip.length) : rawStem;
-        if (prefixes.some((prefix) => stem === prefix || separators.some((separator) => stem.startsWith(`${prefix}${separator}`)))) {
+      }
+    };
+    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
+import { defineRule as defineRule75 } from "@oxlint/plugins";
+var reactEmptyEffect = defineRule75({
+  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;
         }
-        context.report({
-          node: program,
-          messageId: "prefix",
-          data: {
-            file,
-            folder: resolved.join("/"),
-            expected: prefixes.map((prefix) => `${stripPrefixes[0] ?? ""}${prefix}`).join(" or ")
+        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/naming/naming-types.ts
-var namingTypes = astSelectorRule("TSInterfaceDeclaration:not([id.name=/^[A-Z][a-zA-Z0-9]*$/])", "Use PascalCase for interfaces.");
-
-// 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.");
-
-// 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.");
-
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
-var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule61({
+import { defineRule as defineRule76 } from "@oxlint/plugins";
+var reactMemo = defineRule76({
   meta: {
     type: "problem",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          names: { type: "array", items: { type: "string" } },
+          sources: { type: "array", items: { type: "string" } },
+          message: { type: "string" }
+        }
+      }
+    ],
     messages: {
-      memo: "Use the React Compiler rather than manual memoization."
+      memo: "{{message}}"
     }
   },
   createOnce(context) {
+    let names = [];
+    let sources = [];
+    let message = "";
     return {
+      before() {
+        const options = optionsFirst(context, {});
+        names = options.names ?? ["memo", "useMemo", "useCallback"];
+        sources = options.sources ?? ["react"];
+        message = options.message ?? "Use the React Compiler rather than manual memoization.";
+      },
       ImportDeclaration(node) {
-        if (node.source.value !== "react") {
+        if (!sources.includes(node.source.value)) {
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === "ImportSpecifier" && reactMemoNames.includes(astModuleName(specifier.imported))) {
-            context.report({ node: specifier, messageId: "memo" });
+          if (specifier.type === "ImportSpecifier" && names.includes(astModuleName(specifier.imported))) {
+            context.report({
+              node: specifier,
+              messageId: "memo",
+              data: { message }
+            });
           }
         }
       },
       MemberExpression(node) {
-        if (node.object.type !== "Identifier" || !reactMemoNames.includes(astMemberName(node) ?? "")) {
+        if (node.object.type !== "Identifier" || !names.includes(boundariesMemberName(node) ?? "")) {
           return;
         }
         const variable = boundariesDeclaredVariable(context.sourceCode.getScope(node), node.object.name);
-        const isReact = variable ? variable.defs.some((def) => def.type === "ImportBinding" && def.node.type !== "ImportSpecifier" && def.parent?.type === "ImportDeclaration" && def.parent.source.value === "react") : node.object.name === "React";
+        const isReact = variable ? variable.defs.some((def) => def.type === "ImportBinding" && (def.node.type !== "ImportSpecifier" || astModuleName(def.node.imported) === "default") && def.parent?.type === "ImportDeclaration" && sources.includes(def.parent.source.value)) : node.object.name === "React" && sources.includes("react");
         if (isReact) {
-          context.report({ node, messageId: "memo" });
+          context.report({
+            node,
+            messageId: "memo",
+            data: { message }
+          });
         }
       }
     };
@@ -6903,7 +8514,7 @@ var reactMemo = defineRule61({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
+import { defineRule as defineRule77 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -6930,7 +8541,7 @@ function reactIsPassThrough(type) {
   const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
   return name.type === "Identifier" && name.name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
 }
-var reactProps = defineRule62({
+var reactProps = defineRule77({
   meta: {
     type: "problem",
     schema: [
@@ -7029,8 +8640,8 @@ var reactProps = defineRule62({
 });
 
 // src/rules/react/react-query-props.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
-var reactQueryProps = defineRule63({
+import { defineRule as defineRule78 } from "@oxlint/plugins";
+var reactQueryProps = defineRule78({
   meta: {
     type: "problem",
     schema: [
@@ -7111,7 +8722,7 @@ var reactQueryProps = defineRule63({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
+import { defineRule as defineRule79 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -7147,7 +8758,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule64({
+var schemasInline = defineRule79({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -7196,11 +8807,11 @@ var schemasInline = defineRule64({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
+import { defineRule as defineRule80 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
-var schemasLocal = defineRule65({
+var schemasLocal = defineRule80({
   meta: {
     type: "problem",
     schema: [
@@ -7349,8 +8960,8 @@ var schemasLocal = defineRule65({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
-var schemasRederive = defineRule66({
+import { defineRule as defineRule81 } from "@oxlint/plugins";
+var schemasRederive = defineRule81({
   meta: {
     type: "problem",
     schema: [
@@ -7396,7 +9007,7 @@ var schemasRederive = defineRule66({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
+import { defineRule as defineRule82 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -7410,7 +9021,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule67({
+var schemasSingleUse = defineRule82({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -7486,7 +9097,7 @@ var schemasSingleUse = defineRule67({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { defineRule as defineRule83 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -7676,7 +9287,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule68({
+var testsAssertions = defineRule83({
   meta: {
     type: "problem",
     schema: [
@@ -7802,8 +9413,8 @@ var testsAssertions = defineRule68({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule69({
+import { defineRule as defineRule84 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule84({
   meta: {
     type: "problem",
     schema: [
@@ -7859,7 +9470,7 @@ var testsConcurrentDb = defineRule69({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
+import { defineRule as defineRule85 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
 var testsModifiersBanned = ["only", "skip", "todo"];
@@ -7878,7 +9489,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule70({
+var testsModifiers = defineRule85({
   meta: {
     type: "problem",
     schema: [
@@ -7932,9 +9543,9 @@ var testsModifiers = defineRule70({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule71 } from "@oxlint/plugins";
+import { defineRule as defineRule86 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule71({
+var testsTitles = defineRule86({
   meta: {
     type: "suggestion",
     schema: [
@@ -8012,11 +9623,11 @@ var testsTitles = defineRule71({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule72 } from "@oxlint/plugins";
+import { defineRule as defineRule87 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule72({
+var typesDeclarations = defineRule87({
   meta: {
     type: "problem",
     schema: [
@@ -8067,8 +9678,8 @@ var typesDeclarations = defineRule72({
 });
 
 // src/rules/types/types-duplicate.ts
-import { defineRule as defineRule73 } from "@oxlint/plugins";
-var typesDuplicate = defineRule73({
+import { defineRule as defineRule88 } from "@oxlint/plugins";
+var typesDuplicate = defineRule88({
   meta: {
     type: "suggestion",
     schema: [
@@ -8132,7 +9743,7 @@ var typesDuplicate = defineRule73({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule74 } from "@oxlint/plugins";
+import { defineRule as defineRule89 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -8144,7 +9755,7 @@ function importedAliasTarget(declaration, imports) {
   const { name } = type.typeName;
   return imports.has(name) && !declaration.typeParameters?.params.some((parameter) => parameter.name.name === name) ? name : undefined;
 }
-var typesImportedAlias = defineRule74({
+var typesImportedAlias = defineRule89({
   meta: {
     type: "problem",
     schema: [],
@@ -8206,7 +9817,7 @@ var typesImportedAlias = defineRule74({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule75 } from "@oxlint/plugins";
+import { defineRule as defineRule90 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -8216,7 +9827,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule75({
+var typesInline = defineRule90({
   meta: {
     type: "problem",
     schema: [
@@ -8328,11 +9939,38 @@ var typesInline = defineRule75({
 });
 
 // src/rules/types/types-local-alias.ts
-var typesLocalAlias = astSelectorRule("TSTypeAliasDeclaration", "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface.");
+import { defineRule as defineRule91 } from "@oxlint/plugins";
+var typesLocalAlias = defineRule91({
+  meta: {
+    type: "problem",
+    schema: [{ type: "object", additionalProperties: false, properties: { allow: optionsPatternSchema, message: { type: "string" } } }],
+    messages: { forbidden: "{{message}}" }
+  },
+  createOnce(context) {
+    let allow = [];
+    let message = "";
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        allow = optionsPatterns(options.allow);
+        message = options.message ?? "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface.";
+      },
+      TSTypeAliasDeclaration(node) {
+        if (!optionsPatternsTest(allow, node.id.name)) {
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message }
+          });
+        }
+      }
+    };
+  }
+});
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule76 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule76({
+import { defineRule as defineRule92 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule92({
   meta: {
     type: "suggestion",
     schema: [
@@ -8374,8 +10012,8 @@ var typesNamespaceImport = defineRule76({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule77 } from "@oxlint/plugins";
-var typesService = defineRule77({
+import { defineRule as defineRule93 } from "@oxlint/plugins";
+var typesService = defineRule93({
   meta: {
     type: "problem",
     schema: [
@@ -8425,12 +10063,12 @@ var typesService = defineRule77({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule78 } from "@oxlint/plugins";
+import { defineRule as defineRule94 } from "@oxlint/plugins";
 function isCatchName(node) {
   const key = "key" in node && !(("computed" in node) && node.computed) ? node.key : undefined;
   return key?.type === "Identifier" && key.name === "catch";
 }
-var typesUnknown = defineRule78({
+var typesUnknown = defineRule94({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -8473,6 +10111,7 @@ var src_default = eslintCompatPlugin({
     "code-double-negation": codeDoubleNegation,
     "code-function-nesting": codeFunctionNesting,
     "code-inline": codeInline,
+    "code-inside": codeInside,
     "code-justified-call": codeJustifiedCall,
     "code-literal-in": codeLiteralIn,
     "code-mutable-state": codeMutableState,
@@ -8487,10 +10126,14 @@ var src_default = eslintCompatPlugin({
     "comments-directives": commentsDirectives,
     "copy-dashes": copyDashes,
     "effect-layer-file": effectLayerFile,
+    "effect-layer-keys": effectLayerKeys,
     "effect-layers": effectLayers,
     "effect-merge-pipe": effectMergePipe,
     "effect-schema-first": effectSchemaFirst,
+    "effect-service-params": effectServiceParams,
     "effect-values-first": effectValuesFirst,
+    "effect-yield-name": effectYieldName,
+    "effect-yields-first": effectYieldsFirst,
     "files-components-only": filesComponentsOnly,
     "files-constants-only": filesConstantsOnly,
     "files-domain-constants": filesDomainConstants,
@@ -8501,6 +10144,8 @@ var src_default = eslintCompatPlugin({
     "files-no-functions": filesNoFunctions,
     "files-restricted": filesRestricted,
     "files-route": filesRoute,
+    "files-siblings": filesSiblings,
+    "files-top-level": filesTopLevel,
     "files-types-only": filesTypesOnly,
     "layout-arrow-body": layoutArrowBody,
     "layout-call-arguments": layoutCallArguments,
@@ -8514,10 +10159,15 @@ 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,
     "naming-folder": namingFolder,
+    "naming-imports": namingImports,
+    "naming-keys": namingKeys,
+    "naming-labels": namingLabels,
+    "naming-pairs": namingPairs,
     "naming-types": namingTypes,
     "react-dynamic-classes": reactDynamicClasses,
     "react-empty-effect": reactEmptyEffect,