oxlint-plugin-arch 0.13.1 → 0.13.2

package/dist/index.js

@@ -53,6 +53,9 @@ function optionsAssertMockingApis(patterns) {
 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"]);
@@ -458,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("\\", "/"));
@@ -485,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();
@@ -1123,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"] }]
+            }
+          }
         }
       }
     ],
@@ -1148,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;
         }
@@ -2432,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: [
@@ -2488,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: [
@@ -2530,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",
@@ -2547,7 +2702,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule19({
+var codeMutableState = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2605,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;
@@ -2619,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: [
@@ -2668,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: [
@@ -2736,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;
@@ -2765,7 +2920,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule22({
+var codePromiseMutation = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2858,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: [
@@ -2946,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",
@@ -3104,7 +3259,7 @@ function codeTrivialFunctionsDefaults(program) {
   }
   return starts;
 }
-var codeTrivialFunctions = defineRule24({
+var codeTrivialFunctions = defineRule25({
   meta: {
     type: "problem",
     schema: [
@@ -3246,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: {
@@ -3269,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]/;
@@ -3320,7 +3475,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule26({
+var commentsCode = defineRule27({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -3523,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: [],
@@ -3553,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: [
@@ -3611,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"];
@@ -3653,7 +3808,7 @@ var effectLayerFileDefaultConstructors = [
   "Layer.sync",
   "Layer.unwrap"
 ];
-var effectLayerFile = defineRule29({
+var effectLayerFile = defineRule30({
   meta: {
     type: "problem",
     schema: [
@@ -3819,8 +3974,138 @@ var effectLayerFile = defineRule29({
   }
 });
 
+// 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;
@@ -3832,7 +4117,7 @@ var effectLayersGroupSchema = {
     min: { type: "integer", minimum: 1 }
   }
 };
-var effectLayers = defineRule30({
+var effectLayers = defineRule32({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -3914,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: [
@@ -3963,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",
@@ -4025,7 +4310,7 @@ function effectSchemaFirstReference(node) {
   }
   return node.type === "TSInterfaceHeritage" ? astDottedName(node.expression) : undefined;
 }
-var effectSchemaFirst = defineRule32({
+var effectSchemaFirst = defineRule34({
   meta: {
     type: "suggestion",
     schema: [
@@ -4035,6 +4320,7 @@ var effectSchemaFirst = defineRule32({
         properties: {
           member: { type: "string" },
           keep: optionsPatternSchema,
+          allow: optionsPatternSchema,
           runtime: { type: "array", items: { type: "string" } },
           rows: {
             type: "object",
@@ -4064,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";
@@ -4128,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";
@@ -4147,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",
@@ -4197,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\\.",
@@ -4207,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: [
@@ -4289,32 +4673,116 @@ 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);
-  if (expressions.some((expression) => astContainsJsx(expression) || expression.type === "Literal" && expression.value === null)) {
-    return true;
-  }
-  const returned = new Set(expressions.flatMap((expression) => expression.type === "Identifier" ? [expression.name] : []));
-  const propsWithChildren = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" ? statement.specifiers.flatMap((specifier) => specifier.type === "ImportSpecifier" && astModuleName(specifier.imported) === "PropsWithChildren" ? [specifier.local.name] : []) : []));
-  return node.params.some((param) => {
-    const returnsProp = param.type === "ObjectPattern" && param.properties.some((property) => property.type === "Property" && property.value.type === "Identifier" && returned.has(property.value.name));
-    if (!returnsProp) {
-      return false;
+// 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}}."
     }
-    let found = false;
-    astVisit(param.typeAnnotation, [], (candidate) => {
-      if (candidate.type === "TSTypeReference" && candidate.typeName.type === "Identifier" && propsWithChildren.has(candidate.typeName.name)) {
-        found = true;
+  },
+  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 }
+          });
+        }
       }
-    });
-    return found;
-  });
-}
-function reactIsComponentValue(program, initializer) {
+    };
+  }
+});
+
+// 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;
+  }
+  const returned = new Set(expressions.flatMap((expression) => expression.type === "Identifier" ? [expression.name] : []));
+  const propsWithChildren = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" ? statement.specifiers.flatMap((specifier) => specifier.type === "ImportSpecifier" && astModuleName(specifier.imported) === "PropsWithChildren" ? [specifier.local.name] : []) : []));
+  return node.params.some((param) => {
+    const returnsProp = param.type === "ObjectPattern" && param.properties.some((property) => property.type === "Property" && property.value.type === "Identifier" && returned.has(property.value.name));
+    if (!returnsProp) {
+      return false;
+    }
+    let found = false;
+    astVisit(param.typeAnnotation, [], (candidate) => {
+      if (candidate.type === "TSTypeReference" && candidate.typeName.type === "Identifier" && propsWithChildren.has(candidate.typeName.name)) {
+        found = true;
+      }
+    });
+    return found;
+  });
+}
+function reactIsComponentValue(program, initializer) {
   if (!initializer) {
     return false;
   }
@@ -4362,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: [
@@ -4450,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);
@@ -4505,7 +4973,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule35({
+var filesConstantsOnly = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4604,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);
@@ -4622,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: [
@@ -4687,9 +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";
-var filesExports = defineRule37({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var filesExports = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4705,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"] }]
@@ -4743,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}", optionsEscape(pascalDomain)).replaceAll("{domain}", optionsEscape(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) {
@@ -4773,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: [
@@ -4804,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;
@@ -4871,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);
@@ -4882,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: [
@@ -5000,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: [
@@ -5049,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: [
@@ -5104,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: [
@@ -5137,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)) {
@@ -5157,7 +5622,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule43({
+var filesRoute = defineRule48({
   meta: {
     type: "problem",
     schema: [
@@ -5226,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] : []);
 }
@@ -5396,7 +6100,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule44({
+var filesTypesOnly = defineRule51({
   meta: {
     type: "problem",
     schema: [
@@ -5504,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",
@@ -5557,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",
@@ -5708,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);
@@ -5737,7 +6441,7 @@ var layoutCallArguments = defineRule46({
         hug(node, options.hug.max);
       }
       if (options.join && !(options.join.keep ?? []).includes(source.getText(node.callee)) && !(isPipe(node) && (node.arguments.length > 1 || options.pipe)) && astCallDepth(node) <= (options.join.nesting ?? Number.POSITIVE_INFINITY)) {
-        join3(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
+        join4(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
       }
     };
     const parameters = (node) => {
@@ -5747,7 +6451,7 @@ 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() {
@@ -5768,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",
@@ -5889,7 +6593,7 @@ var layoutCallArray = defineRule47({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
+import { defineRule as defineRule55 } from "@oxlint/plugins";
 function layoutCallDepthOuter(node, callbacks) {
   const parent = node.parent;
   if (!parent || !callbacks && (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression")) {
@@ -5904,7 +6608,7 @@ function layoutCallDepthOuter(node, callbacks) {
   }
   return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent, callbacks);
 }
-var layoutCallDepth = defineRule48({
+var layoutCallDepth = defineRule55({
   meta: {
     type: "layout",
     schema: [
@@ -5946,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",
@@ -6066,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",
@@ -6122,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",
@@ -6211,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",
@@ -6248,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);
 }
@@ -6256,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",
@@ -6301,7 +7005,7 @@ var layoutObject = defineRule53({
     let indentUnit = sourceIndentUnit();
     let newline = `
 `;
-    let join3;
+    let join4;
     let params = false;
     let nested = false;
     let siblings = false;
@@ -6359,7 +7063,7 @@ var layoutObject = defineRule53({
     }
     function joinBlocked(node, call) {
       const callee = call && astIsCall(call) ? astDottedName(call.callee) : undefined;
-      const kept = callee !== undefined && (join3?.keep ?? []).some((name) => callee === name || callee.endsWith(`.${name}`));
+      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) {
@@ -6422,7 +7126,7 @@ var layoutObject = defineRule53({
         scope = options.scope ?? "call-args";
         indentUnit = sourceIndentUnit(options.indent);
         newline = sourceNewline(context.sourceCode.text);
-        join3 = options.join;
+        join4 = options.join;
         params = options.params ?? false;
         nested = options.nested ?? false;
         siblings = options.siblings ?? false;
@@ -6447,7 +7151,7 @@ var layoutObject = defineRule53({
           return;
         }
         const split = full || holds;
-        if (split ? !astIsOneLine(node) : !join3 || astIsOneLine(node)) {
+        if (split ? !astIsOneLine(node) : !join4 || astIsOneLine(node)) {
           return;
         }
         const call = (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node) ? parent : undefined;
@@ -6461,7 +7165,7 @@ var layoutObject = defineRule53({
           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({
@@ -6480,7 +7184,7 @@ var layoutObject = defineRule53({
 });
 
 // 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",
@@ -6509,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",
@@ -6598,8 +7302,8 @@ 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" } } } }],
@@ -6640,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;
 }
@@ -6648,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",
@@ -6764,8 +7468,8 @@ var layoutTernary = defineRule56({
 });
 
 // src/rules/layout/layout-type-arguments.ts
-import { defineRule as defineRule57 } from "@oxlint/plugins";
-var layoutTypeArguments = defineRule57({
+import { defineRule as defineRule64 } from "@oxlint/plugins";
+var layoutTypeArguments = defineRule64({
   meta: {
     type: "layout",
     fixable: "code",
@@ -6824,13 +7528,14 @@ var layoutTypeArguments = defineRule57({
 });
 
 // src/rules/naming/naming-declarations.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule58({
+var namingDeclarations = defineRule65({
   meta: {
     type: "problem",
-    schema: [
-      {
+    schema: {
+      type: "array",
+      items: {
         type: "object",
         additionalProperties: false,
         properties: {
@@ -6841,56 +7546,61 @@ var namingDeclarations = defineRule58({
           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,
@@ -6903,33 +7613,14 @@ var namingDeclarations = defineRule58({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule59 } 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 = defineRule59({
+var namingExports = defineRule66({
   meta: {
     type: "problem",
     schema: {
@@ -6959,7 +7650,7 @@ var namingExports = defineRule59({
               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" }
@@ -6986,23 +7677,15 @@ var namingExports = defineRule59({
           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);
@@ -7014,7 +7697,7 @@ var namingExports = defineRule59({
               continue;
             }
             for (const item of functions) {
-              if (item.name !== expected2) {
+              if (!names2.includes(item.name)) {
                 context.report({
                   node: item.node,
                   messageId: "mismatch",
@@ -7036,7 +7719,9 @@ var namingExports = defineRule59({
             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;
@@ -7046,7 +7731,7 @@ var namingExports = defineRule59({
                 context.report({
                   node: item.node,
                   messageId: "pattern",
-                  data: { name: item.name, pattern: optionsPatternLabel(options.pattern) }
+                  data: { name: item.name, pattern: optionsPatternLabel(sources) }
                 });
               }
               continue;
@@ -7066,10 +7751,10 @@ var namingExports = defineRule59({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { defineRule as defineRule67 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule60({
+import { dirname as dirname5 } from "node:path";
+var namingFile = defineRule67({
   meta: {
     type: "problem",
     schema: {
@@ -7081,9 +7766,12 @@ var namingFile = defineRule60({
           pattern: optionsPatternSchema,
           message: { type: "string" },
           flags: { type: "string" },
-          unique: { type: "string", minLength: 1 }
+          unique: { type: "string", minLength: 1 },
+          template: optionsPatternSchema,
+          placeholder: { type: "string" }
         },
-        required: ["pattern", "message"]
+        required: ["message"],
+        anyOf: [{ required: ["pattern"] }, { required: ["template"] }]
       }
     },
     messages: {
@@ -7096,9 +7784,12 @@ var namingFile = defineRule60({
       Program(program) {
         const basename3 = namingBasename(context.filename);
         let siblings;
-        for (const { pattern, message, flags, unique } of optionsAll(context)) {
+        for (const { pattern, message, flags, unique, template, placeholder } of optionsAll(context)) {
           const patterns = optionsPatternsWithEmpty(pattern, flags);
-          if (!optionsPatternsTest(patterns, basename3)) {
+          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",
@@ -7119,7 +7810,7 @@ var namingFile = defineRule60({
           }
           if (!siblings) {
             try {
-              siblings = readdirSync2(dirname4(context.filename), { withFileTypes: true }).flatMap((entry) => entry.isFile() ? [entry.name] : []);
+              siblings = readdirSync2(dirname5(context.filename), { withFileTypes: true }).flatMap((entry) => entry.isFile() ? [entry.name] : []);
             } catch {
               siblings = [];
             }
@@ -7139,9 +7830,9 @@ var namingFile = defineRule60({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
-import { posix as posix3 } from "node:path";
-var namingFolder = defineRule61({
+import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { posix as posix2 } from "node:path";
+var namingFolder = defineRule68({
   meta: {
     type: "problem",
     schema: [
@@ -7164,7 +7855,7 @@ var namingFolder = defineRule61({
     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 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);
@@ -7205,9 +7896,451 @@ var namingFolder = defineRule61({
   }
 });
 
+// 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: "object",
+        additionalProperties: false,
+        properties: {
+          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: ["pairs"]
+      }
+    ],
+    messages: {
+      pair: "'{{second}}' in .{{secondMethod}}() must share its name with '{{first}}' in .{{firstMethod}}()."
+    }
+  },
+  createOnce(context) {
+    return {
+      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 (stem(first) !== stem(second)) {
+            context.report({
+              node: secondNode,
+              messageId: "pair",
+              data: { first, second, firstMethod, secondMethod }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/naming/naming-types.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
-var namingTypes = defineRule62({
+import { defineRule as defineRule73 } from "@oxlint/plugins";
+var namingTypes = defineRule73({
   meta: {
     type: "problem",
     schema: [{ type: "object", additionalProperties: false, properties: { pattern: optionsPatternSchema, message: { type: "string" } } }],
@@ -7236,8 +8369,8 @@ var namingTypes = defineRule62({
 });
 
 // src/rules/react/react-dynamic-classes.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
-var reactDynamicClasses = defineRule63({
+import { defineRule as defineRule74 } from "@oxlint/plugins";
+var reactDynamicClasses = defineRule74({
   meta: {
     type: "problem",
     schema: [
@@ -7277,8 +8410,8 @@ var reactDynamicClasses = defineRule63({
 });
 
 // src/rules/react/react-empty-effect.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
-var reactEmptyEffect = defineRule64({
+import { defineRule as defineRule75 } from "@oxlint/plugins";
+var reactEmptyEffect = defineRule75({
   meta: {
     type: "problem",
     schema: [
@@ -7318,8 +8451,8 @@ var reactEmptyEffect = defineRule64({
 });
 
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
-var reactMemo = defineRule65({
+import { defineRule as defineRule76 } from "@oxlint/plugins";
+var reactMemo = defineRule76({
   meta: {
     type: "problem",
     schema: [
@@ -7381,7 +8514,7 @@ var reactMemo = defineRule65({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule66 } 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 };
@@ -7408,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 = defineRule66({
+var reactProps = defineRule77({
   meta: {
     type: "problem",
     schema: [
@@ -7507,8 +8640,8 @@ var reactProps = defineRule66({
 });
 
 // src/rules/react/react-query-props.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
-var reactQueryProps = defineRule67({
+import { defineRule as defineRule78 } from "@oxlint/plugins";
+var reactQueryProps = defineRule78({
   meta: {
     type: "problem",
     schema: [
@@ -7589,7 +8722,7 @@ var reactQueryProps = defineRule67({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { defineRule as defineRule79 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -7625,7 +8758,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule68({
+var schemasInline = defineRule79({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -7674,11 +8807,11 @@ var schemasInline = defineRule68({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule69 } 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 = defineRule69({
+var schemasLocal = defineRule80({
   meta: {
     type: "problem",
     schema: [
@@ -7827,8 +8960,8 @@ var schemasLocal = defineRule69({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
-var schemasRederive = defineRule70({
+import { defineRule as defineRule81 } from "@oxlint/plugins";
+var schemasRederive = defineRule81({
   meta: {
     type: "problem",
     schema: [
@@ -7874,7 +9007,7 @@ var schemasRederive = defineRule70({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule71 } 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;
@@ -7888,7 +9021,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule71({
+var schemasSingleUse = defineRule82({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -7964,7 +9097,7 @@ var schemasSingleUse = defineRule71({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule72 } from "@oxlint/plugins";
+import { defineRule as defineRule83 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -8154,7 +9287,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule72({
+var testsAssertions = defineRule83({
   meta: {
     type: "problem",
     schema: [
@@ -8280,8 +9413,8 @@ var testsAssertions = defineRule72({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule73 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule73({
+import { defineRule as defineRule84 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule84({
   meta: {
     type: "problem",
     schema: [
@@ -8337,7 +9470,7 @@ var testsConcurrentDb = defineRule73({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule74 } 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"];
@@ -8356,7 +9489,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule74({
+var testsModifiers = defineRule85({
   meta: {
     type: "problem",
     schema: [
@@ -8410,9 +9543,9 @@ var testsModifiers = defineRule74({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule75 } from "@oxlint/plugins";
+import { defineRule as defineRule86 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule75({
+var testsTitles = defineRule86({
   meta: {
     type: "suggestion",
     schema: [
@@ -8490,11 +9623,11 @@ var testsTitles = defineRule75({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule76 } from "@oxlint/plugins";
+import { defineRule as defineRule87 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule76({
+var typesDeclarations = defineRule87({
   meta: {
     type: "problem",
     schema: [
@@ -8545,8 +9678,8 @@ var typesDeclarations = defineRule76({
 });
 
 // src/rules/types/types-duplicate.ts
-import { defineRule as defineRule77 } from "@oxlint/plugins";
-var typesDuplicate = defineRule77({
+import { defineRule as defineRule88 } from "@oxlint/plugins";
+var typesDuplicate = defineRule88({
   meta: {
     type: "suggestion",
     schema: [
@@ -8610,7 +9743,7 @@ var typesDuplicate = defineRule77({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule78 } from "@oxlint/plugins";
+import { defineRule as defineRule89 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -8622,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 = defineRule78({
+var typesImportedAlias = defineRule89({
   meta: {
     type: "problem",
     schema: [],
@@ -8684,7 +9817,7 @@ var typesImportedAlias = defineRule78({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule79 } from "@oxlint/plugins";
+import { defineRule as defineRule90 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -8694,7 +9827,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule79({
+var typesInline = defineRule90({
   meta: {
     type: "problem",
     schema: [
@@ -8806,8 +9939,8 @@ var typesInline = defineRule79({
 });
 
 // src/rules/types/types-local-alias.ts
-import { defineRule as defineRule80 } from "@oxlint/plugins";
-var typesLocalAlias = defineRule80({
+import { defineRule as defineRule91 } from "@oxlint/plugins";
+var typesLocalAlias = defineRule91({
   meta: {
     type: "problem",
     schema: [{ type: "object", additionalProperties: false, properties: { allow: optionsPatternSchema, message: { type: "string" } } }],
@@ -8836,8 +9969,8 @@ var typesLocalAlias = defineRule80({
 });
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule81 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule81({
+import { defineRule as defineRule92 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule92({
   meta: {
     type: "suggestion",
     schema: [
@@ -8879,8 +10012,8 @@ var typesNamespaceImport = defineRule81({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule82 } from "@oxlint/plugins";
-var typesService = defineRule82({
+import { defineRule as defineRule93 } from "@oxlint/plugins";
+var typesService = defineRule93({
   meta: {
     type: "problem",
     schema: [
@@ -8930,12 +10063,12 @@ var typesService = defineRule82({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule83 } 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 = defineRule83({
+var typesUnknown = defineRule94({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -8978,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,
@@ -8992,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,
@@ -9006,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,
@@ -9024,6 +10164,10 @@ var src_default = eslintCompatPlugin({
     "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,