oxlint-plugin-arch 0.2.5 → 0.3.1

package/dist/index.js

@@ -1,10 +1,20 @@
 // src/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/rules/declaration-name.ts
+// src/rules/call-array-multiline.ts
 import { defineRule } from "@oxlint/plugins";
 
 // src/utils/helpers/ast.ts
+var astVisitSkip = new Set([
+  "parent",
+  "type",
+  "start",
+  "end",
+  "range",
+  "loc",
+  "tokens",
+  "comments"
+]);
 function astIsNode(value) {
   return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
 }
@@ -19,11 +29,13 @@ function astVisit(node, ancestors, callback) {
     return;
   }
   callback(node, ancestors);
-  for (const [key, value] of Object.entries(node)) {
-    if (!["parent", "type", "start", "end", "range", "loc"].includes(key)) {
-      astVisit(value, [...ancestors, node], callback);
+  ancestors.push(node);
+  for (const key in node) {
+    if (Object.hasOwn(node, key) && !astVisitSkip.has(key)) {
+      astVisit(Reflect.get(node, key), ancestors, callback);
     }
   }
+  ancestors.pop();
 }
 function astContainsJsx(node) {
   let found = false;
@@ -52,6 +64,17 @@ function astDirectReturnExpressions(node) {
 function astStaticMemberName(node) {
   return !node.computed && node.property.type === "Identifier" ? node.property.name : undefined;
 }
+function astDottedName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type !== "MemberExpression") {
+    return;
+  }
+  const object = astDottedName(node.object);
+  const property = astStaticMemberName(node);
+  return object && property ? `${object}.${property}` : undefined;
+}
 function astCallName(node) {
   if (node.callee.type === "Identifier") {
     return node.callee.name;
@@ -233,6 +256,23 @@ function declarationsCollectNamed(root, kinds) {
   });
   return result;
 }
+function declarationsInsideForLoop(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement") {
+      return true;
+    }
+  }
+  return false;
+}
+function declarationsNamedFromNode(node) {
+  if (node.type === "VariableDeclarator") {
+    const kind = declarationsNamedKind(node, [node.parent]);
+    return kind && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind } : undefined;
+  }
+  const kind = declarationsNamedKind(node, []);
+  const name = "id" in node && node.id && "name" in node.id ? node.id.name : undefined;
+  return kind && name ? { name, node, kind } : undefined;
+}
 function declarationsCollectFunctions(root) {
   return declarationsCollectNamed(root).flatMap((item) => {
     if (item.node.type === "FunctionDeclaration") {
@@ -713,8 +753,301 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 function schemasTypeOperator(node, namespaces, operators) {
   return node.typeName.type === "TSQualifiedName" && node.typeName.left.type === "Identifier" && namespaces.has(node.typeName.left.name) && operators.has(node.typeName.right.name) ? node.typeName.right.name : undefined;
 }
+// src/utils/helpers/comments.ts
+var COMMENTS_DIRECTIVE = /^\s*(?:\/\s*<(?:reference\b|amd-[\w-]+\b)|@ts-(?:check|ignore|expect-error|nocheck)\b|(?:#|@)__(?:PURE|NO_SIDE_EFFECTS)__\b|@jsx(?:ImportSource|Runtime|Frag)?\b|@vite-ignore\b|(?:[#@]\s*)?sourceMappingURL=|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
+var COMMENTS_DISABLE_NEXT_LINE = /^(?:eslint|oxlint)-disable-next-line\b/;
+var COMMENTS_LEGAL_BLOCK = "\x00legal-block\x00";
+function commentsNormalizedValue(comment) {
+  const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
+  return comment.type === "Block" && comment.value.startsWith("!") ? COMMENTS_LEGAL_BLOCK + value : value;
+}
+function commentsIsDirective(value) {
+  return value.startsWith(COMMENTS_LEGAL_BLOCK) || COMMENTS_DIRECTIVE.test(value);
+}
+function commentsIsDisableNextLine(value) {
+  return COMMENTS_DISABLE_NEXT_LINE.test(value);
+}
+function commentsIsWhy(value) {
+  return value.startsWith("Why: ");
+}
+function commentsIsJsdoc(source, comment) {
+  return comment.type === "Block" && source.startsWith("/**", comment.range[0]);
+}
+// src/utils/helpers/layout.ts
+var layoutIndentSchema = {
+  anyOf: [
+    { type: "integer", minimum: 0 },
+    { type: "string", enum: ["tab"] }
+  ]
+};
+function layoutLineIndent(text, offset) {
+  const lineStart = text.lastIndexOf(`
+`, offset - 1) + 1;
+  return /^[\t ]*/.exec(text.slice(lineStart, offset))?.[0] ?? "";
+}
+function layoutIndentUnit(indent = 2) {
+  return indent === "tab" ? "\t" : " ".repeat(indent);
+}
+function layoutNewline(text) {
+  return text.includes(`\r
+`) ? `\r
+` : `
+`;
+}
+// src/rules/call-array-multiline.ts
+function callArrayMultilineCallee(node) {
+  if (node.type === "Identifier")
+    return { name: node.name, root: node };
+  if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier")
+    return null;
+  const object = callArrayMultilineCallee(node.object);
+  return object ? { name: `${object.name}.${node.property.name}`, root: object.root } : null;
+}
+function callArrayMultilineIsShadowed(context, root) {
+  if (root.type !== "Identifier")
+    return false;
+  let scope = context.sourceCode.getScope(root);
+  while (scope) {
+    const variable = scope.set.get(root.name);
+    if (variable)
+      return variable.defs.length > 0;
+    scope = scope.upper;
+  }
+  return false;
+}
+function callArrayMultilineEdits(array, text, elementIndent, baseIndent, newline) {
+  const elements = array.elements;
+  if (elements.some((element) => element === null))
+    return null;
+  const present = elements.filter((element) => element !== null);
+  const first = present[0];
+  const last = present.at(-1);
+  if (!first || !last)
+    return null;
+  const edits = [];
+  const openingRange = [array.range[0] + 1, first.range[0]];
+  if (!/^\s*$/.test(text.slice(...openingRange)))
+    return null;
+  edits.push({ range: openingRange, text: `${newline}${elementIndent}` });
+  for (let index = 1;index < present.length; index++) {
+    const previous = present[index - 1];
+    const current = present[index];
+    const gap = text.slice(previous.range[1], current.range[0]);
+    if (!/^,\s*$/.test(gap))
+      return null;
+    edits.push({
+      range: [previous.range[1] + 1, current.range[0]],
+      text: `${newline}${elementIndent}`
+    });
+  }
+  const closingRange = [last.range[1], array.range[1] - 1];
+  const closingGap = text.slice(...closingRange);
+  if (!/^,?\s*$/.test(closingGap))
+    return null;
+  edits.push({
+    range: [closingRange[0] + (closingGap.startsWith(",") ? 1 : 0), closingRange[1]],
+    text: `${newline}${baseIndent}`
+  });
+  return edits;
+}
+var callArrayMultiline = defineRule({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        callees: { type: "array", items: { type: "string" } },
+        minElements: { type: "integer", minimum: 1 },
+        indent: layoutIndentSchema
+      }
+    }],
+    messages: {
+      multiline: "Put every array element in this call on its own line."
+    }
+  },
+  createOnce(context) {
+    let callees = new Set(["Promise.all", "Promise.allSettled"]);
+    let minElements = 2;
+    let indentUnit = layoutIndentUnit();
+    let newline = `
+`;
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        callees = new Set(options.callees ?? ["Promise.all", "Promise.allSettled"]);
+        minElements = options.minElements ?? 2;
+        indentUnit = layoutIndentUnit(options.indent);
+        newline = layoutNewline(context.sourceCode.text);
+        if (callees.size === 0)
+          return false;
+      },
+      CallExpression(node) {
+        const callee = callArrayMultilineCallee(node.callee);
+        if (!callee || !callees.has(callee.name))
+          return;
+        const array = node.arguments[0];
+        if (array?.type !== "ArrayExpression" || array.elements.length < minElements)
+          return;
+        if (array.loc.start.line !== array.loc.end.line)
+          return;
+        if (callee.root.type === "Identifier" && callee.root.name === "Promise" && callArrayMultilineIsShadowed(context, callee.root))
+          return;
+        const source = context.sourceCode;
+        const text = source.text;
+        const baseIndent = layoutLineIndent(text, array.range[0]);
+        const hasComments = source.getCommentsInside(array).length > 0;
+        const edits = hasComments ? null : callArrayMultilineEdits(array, text, baseIndent + indentUnit, baseIndent, newline);
+        context.report({
+          node: array,
+          messageId: "multiline",
+          fix: edits ? (fixer) => edits.map((edit) => fixer.replaceTextRange(edit.range, edit.text)) : undefined
+        });
+      }
+    };
+  }
+});
+
+// src/rules/chain-newline.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+function chainNewlineCollect(node) {
+  const links = [];
+  let current = node;
+  while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+    const member = current.callee;
+    links.push({
+      call: current,
+      member,
+      methodName: !member.computed && member.property.type === "Identifier" ? member.property.name : null
+    });
+    current = member.object;
+  }
+  links.reverse();
+  return { root: current, links };
+}
+function chainNewlineRootIdentifier(node) {
+  let current = node;
+  while (current.type === "ChainExpression" || current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current.type === "Identifier" ? current.name : null;
+}
+function chainNewlineMatches(root, links, group) {
+  if (links.length < group.minDepth)
+    return false;
+  const hasCriteria = group.methods !== undefined || group.onlyMethods !== undefined || group.rootPattern !== undefined;
+  if (!hasCriteria)
+    return true;
+  if (group.methods && links.some((link) => link.methodName !== null && group.methods?.has(link.methodName))) {
+    return true;
+  }
+  if (group.onlyMethods && links.every((link) => link.methodName !== null && group.onlyMethods?.has(link.methodName)))
+    return true;
+  const rootName = chainNewlineRootIdentifier(root);
+  return rootName !== null && group.rootPattern !== undefined && group.rootPattern.test(rootName);
+}
+var chainNewline = defineRule2({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        groups: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              minDepth: { type: "integer", minimum: 1 },
+              methods: { type: "array", items: { type: "string" } },
+              onlyMethods: { type: "array", items: { type: "string" } },
+              rootPattern: { type: "string" }
+            },
+            required: ["minDepth"]
+          }
+        },
+        indent: layoutIndentSchema
+      },
+      required: ["groups"]
+    }],
+    messages: {
+      newline: "Put every method in this call chain on its own line."
+    }
+  },
+  createOnce(context) {
+    let groups = [];
+    let indentUnit = layoutIndentUnit();
+    let newline = `
+`;
+    let processed = new WeakSet;
+    return {
+      before() {
+        const options = optionsFirst(context, { groups: [] });
+        groups = (options.groups ?? []).map((group) => ({
+          minDepth: group.minDepth,
+          methods: group.methods ? new Set(group.methods) : undefined,
+          onlyMethods: group.onlyMethods ? new Set(group.onlyMethods) : undefined,
+          rootPattern: group.rootPattern === undefined ? undefined : new RegExp(group.rootPattern)
+        }));
+        indentUnit = layoutIndentUnit(options.indent);
+        newline = layoutNewline(context.sourceCode.text);
+        processed = new WeakSet;
+        if (groups.length === 0)
+          return false;
+      },
+      CallExpression(node) {
+        if (processed.has(node))
+          return;
+        const parent = node.parent;
+        if (parent?.type === "MemberExpression" && parent.object === node && parent.parent?.type === "CallExpression" && parent.parent.callee === parent)
+          return;
+        const { root, links } = chainNewlineCollect(node);
+        for (const link of links)
+          processed.add(link.call);
+        if (!groups.some((group) => chainNewlineMatches(root, links, group)))
+          return;
+        const source = context.sourceCode;
+        const text = source.text;
+        const chainIndent = layoutLineIndent(text, root.range[0]) + indentUnit;
+        const replacements = [];
+        let fixable = true;
+        let needsFix = false;
+        for (const link of links) {
+          if (link.member.computed) {
+            fixable = false;
+            needsFix = true;
+            continue;
+          }
+          const range = [link.member.object.range[1], link.member.property.range[0]];
+          const gap = text.slice(...range);
+          const operator = link.member.optional ? "?." : ".";
+          const expected = `${newline}${chainIndent}${operator}`;
+          if (source.commentsExistBetween(link.member.object, link.member.property) || gap.trim() !== operator) {
+            fixable = false;
+          }
+          if (gap !== expected) {
+            needsFix = true;
+            replacements.push({ range, text: expected });
+          }
+        }
+        if (!needsFix)
+          return;
+        context.report({
+          node,
+          messageId: "newline",
+          fix: fixable ? (fixer) => replacements.map((replacement) => fixer.replaceTextRange(replacement.range, replacement.text)) : undefined
+        });
+      }
+    };
+  }
+});
+
 // src/rules/declaration-name.ts
-var declarationName = defineRule({
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var declarationName = defineRule3({
   meta: {
     type: "problem",
     schema: [{
@@ -741,40 +1074,53 @@ var declarationName = defineRule({
     }
   },
   createOnce(context) {
+    let options = {};
+    let kinds = null;
+    let allowed = null;
+    let expected = null;
+    let prefixes = [];
+    function check(node) {
+      const item = declarationsNamedFromNode(node);
+      if (!item || kinds && !kinds.has(item.kind) || allowed?.test(item.name)) {
+        return;
+      }
+      const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+      const matches = expected ? expected.test(item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
+      if (matches) {
+        return;
+      }
+      context.report({
+        node: item.node,
+        messageId: expected ? "pattern" : "prefix",
+        data: expected ? { name: item.name, pattern: options.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
+      });
+    }
     return {
-      Program(program) {
-        const options = optionsFirst(context, {
+      before() {
+        options = optionsFirst(context, {
           stem: "before-first-dot",
           normalize: "remove-separators"
         });
-        const allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
-        const expected = options.pattern ? new RegExp(options.pattern, options.flags) : null;
+        kinds = options.kinds && options.kinds.length > 0 ? new Set(options.kinds) : null;
+        allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
+        expected = options.pattern ? new RegExp(options.pattern, options.flags) : null;
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
         const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
-        const prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
-        const seen = new Set;
-        for (const item of declarationsCollectNamed(program, options.kinds)) {
-          const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
-          const matches = expected ? expected.test(item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
-          if (seen.has(key) || allowed?.test(item.name) || matches) {
-            continue;
-          }
-          seen.add(key);
-          context.report({
-            node: item.node,
-            messageId: expected ? "pattern" : "prefix",
-            data: expected ? { name: item.name, pattern: options.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
-          });
-        }
-      }
+        prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
+      },
+      FunctionDeclaration: check,
+      ClassDeclaration: check,
+      TSTypeAliasDeclaration: check,
+      TSInterfaceDeclaration: check,
+      TSEnumDeclaration: check,
+      VariableDeclarator: check
     };
   }
 });
 
 // src/rules/export-file-prefix.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
-var exportFilePrefix = defineRule2({
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule4({
   meta: {
     type: "problem",
     schema: [{
@@ -829,8 +1175,8 @@ var exportFilePrefix = defineRule2({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
-var exportNamePattern = defineRule3({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var exportNamePattern = defineRule5({
   meta: {
     type: "problem",
     schema: [{
@@ -880,8 +1226,8 @@ var exportNamePattern = defineRule3({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var filenameExportName = defineRule4({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var filenameExportName = defineRule6({
   meta: {
     type: "problem",
     schema: [{
@@ -942,8 +1288,8 @@ var filenameExportName = defineRule4({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var filenameMatch = defineRule5({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var filenameMatch = defineRule7({
   meta: {
     type: "problem",
     schema: [{
@@ -977,8 +1323,8 @@ var filenameMatch = defineRule5({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var folderPrefix = defineRule6({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var folderPrefix = defineRule8({
   meta: {
     type: "problem",
     schema: [{
@@ -1025,127 +1371,554 @@ var folderPrefix = defineRule6({
   }
 });
 
-// src/rules/no-extra-exports.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noExtraExports = defineRule7({
+// src/rules/jsx-attributes-multiline.ts
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, newline) {
+  const first = node.attributes[0];
+  const last = node.attributes.at(-1);
+  if (!first || !last)
+    return null;
+  const prefix = node.typeArguments ?? node.name;
+  const openingRange = [prefix.range[1], first.range[0]];
+  if (!/^\s*$/.test(text.slice(...openingRange)))
+    return null;
+  const edits = [{
+    range: openingRange,
+    text: `${newline}${attributeIndent}`
+  }];
+  for (let index = 1;index < node.attributes.length; index++) {
+    const previous = node.attributes[index - 1];
+    const current = node.attributes[index];
+    const range = [previous.range[1], current.range[0]];
+    if (!/^\s*$/.test(text.slice(...range)))
+      return null;
+    edits.push({ range, text: `${newline}${attributeIndent}` });
+  }
+  const closing = node.range[1] - (node.selfClosing ? 2 : 1);
+  const closingRange = [last.range[1], closing];
+  if (!/^\s*$/.test(text.slice(...closingRange)))
+    return null;
+  edits.push({ range: closingRange, text: `${newline}${baseIndent}` });
+  return edits;
+}
+var jsxAttributesMultiline = defineRule9({
   meta: {
-    type: "problem",
+    type: "layout",
+    fixable: "whitespace",
     schema: [{
       type: "object",
       additionalProperties: false,
       properties: {
-        names: { type: "array", items: { type: "string" } },
-        domainStem: { type: "string", enum: [...namingStemModes] },
-        trailingRoles: { type: "array", items: { type: "string" } },
-        roleSeparators: { type: "array", items: { type: "string" } },
-        allowTypeExports: { type: "boolean" }
-      },
-      required: ["names"]
+        minAttributes: { type: "integer", minimum: 1 },
+        indent: layoutIndentSchema
+      }
     }],
     messages: {
-      extraExport: "Export '{{name}}' is not allowed; expected one of: {{allowed}}."
+      multiline: "Put every JSX attribute and the closing token on its own line."
     }
   },
   createOnce(context) {
+    let minAttributes = 3;
+    let indentUnit = layoutIndentUnit();
+    let newline = `
+`;
     return {
-      Program(program) {
-        const options = optionsFirst(context);
-        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
-        const domain = namingFileStem(basename, options.domainStem, options.trailingRoles, options.roleSeparators);
-        const allowed = options.names.map((template) => template.replaceAll("{Domain}", namingPascalCase(domain)).replaceAll("{domain}", namingCamelCase(domain)));
-        for (const binding of exportsCollect(program)) {
-          if (options.allowTypeExports && binding.typeOnly) {
-            continue;
-          }
-          const name = binding.localName ?? binding.exportedName;
-          if (!allowed.includes(name)) {
-            context.report({
-              node: binding.node,
-              messageId: "extraExport",
-              data: { name, allowed: allowed.join(", ") }
-            });
-          }
-        }
+      before() {
+        const options = optionsFirst(context, {});
+        minAttributes = options.minAttributes ?? 3;
+        indentUnit = layoutIndentUnit(options.indent);
+        newline = layoutNewline(context.sourceCode.text);
+      },
+      JSXOpeningElement(node) {
+        if (node.attributes.length < minAttributes || node.loc.start.line !== node.loc.end.line)
+          return;
+        const source = context.sourceCode;
+        const text = source.text;
+        const baseIndent = layoutLineIndent(text, node.range[0]);
+        const hasComments = source.getCommentsInside(node).length > 0;
+        const edits = hasComments ? null : jsxAttributesMultilineEdits(node, text, baseIndent + indentUnit, baseIndent, newline);
+        context.report({
+          node,
+          messageId: "multiline",
+          fix: edits ? (fixer) => edits.map((edit) => fixer.replaceTextRange(edit.range, edit.text)) : undefined
+        });
       }
     };
   }
 });
 
-// src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var noExtraFactoryKeys = defineRule8({
+// src/rules/key-value-same-line.ts
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+var keyValueSameLine = defineRule10({
   meta: {
-    type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        keys: { type: "array", items: { type: "string" } },
-        factoryPattern: { type: "string" }
-      },
-      required: ["keys"]
-    }],
+    type: "layout",
+    fixable: "whitespace",
+    schema: [],
     messages: {
-      extraKey: "Factory '{{factory}}' must not return key '{{key}}'; allowed keys: {{allowed}}."
+      sameLine: "Keep the object key and the start of its value on the same line."
     }
   },
   createOnce(context) {
+    let source;
     return {
-      Program(program) {
-        const { keys, factoryPattern = "^make[A-Z]" } = optionsFirst(context);
-        for (const factory of factoriesCollectTopLevel(program, new RegExp(factoryPattern))) {
-          for (const object of factoriesDirectlyReturnedObjects(factory)) {
-            for (const property of object.properties) {
-              const key = factoriesObjectPropertyName(property);
-              if (!key || !keys.includes(key)) {
-                context.report({
-                  node: property,
-                  messageId: "extraKey",
-                  data: { factory: factory.name, key: key ?? "<computed or spread>", allowed: keys.join(", ") }
-                });
-              }
-            }
+      before() {
+        source = context.sourceCode;
+      },
+      Property(node) {
+        if (node.parent.type !== "ObjectExpression" || node.shorthand || node.method || node.kind !== "init") {
+          return;
+        }
+        let keyEnd = node.key.range[1];
+        let keyEndLine = node.key.loc.end.line;
+        if (node.computed) {
+          const bracket = source.getTokensBetween(node.key, node.value).find((token) => token.value === "]");
+          if (bracket) {
+            keyEnd = bracket.range[1];
+            keyEndLine = bracket.loc.end.line;
           }
         }
+        const tokens = source.getTokensBetween(node.key, node.value);
+        const valueStart = tokens[tokens.findIndex((token) => token.value === ":") + 1] ?? node.value;
+        if (keyEndLine === valueStart.loc.start.line) {
+          return;
+        }
+        const between = source.text.slice(keyEnd, node.value.range[0]);
+        const commentsBetween = source.commentsExistBetween(node.key, node.value);
+        const onlyColonAndSpace = /^[\s:]*$/.test(between) && between.includes(":");
+        context.report({
+          node,
+          messageId: "sameLine",
+          fix(fixer) {
+            return !commentsBetween && onlyColonAndSpace ? fixer.replaceTextRange([keyEnd, node.value.range[0]], ": ") : null;
+          }
+        });
       }
     };
   }
 });
 
-// src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule9({
+// src/rules/no-comments.ts
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var NO_COMMENTS_LINE_GAP = /^[\t \r\n\u2028\u2029]*$/;
+var NO_COMMENTS_LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/;
+var NO_COMMENTS_TRAILING_LINES = /^[\t ]*(?:\r\n|[\n\r\u2028\u2029])(?:[\t ]*(?:\r\n|[\n\r\u2028\u2029]))*/;
+var NO_COMMENTS_HORIZONTAL_SPACE = /^[\t ]*$/;
+function noCommentsCreateLineIndex(text) {
+  const starts = [0];
+  const ends = [];
+  for (let index = 0;index < text.length; index++) {
+    const character = text[index];
+    if (character === "\r") {
+      ends.push(index);
+      if (text[index + 1] === `
+`)
+        index++;
+      starts.push(index + 1);
+    } else if (character === `
+` || character === "\u2028" || character === "\u2029") {
+      ends.push(index);
+      starts.push(index + 1);
+    }
+  }
+  ends.push(text.length);
+  return { starts, ends };
+}
+function noCommentsLineNumber(lines, offset) {
+  let low = 0;
+  let high = lines.starts.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (lines.starts[middle] <= offset)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return low - 1;
+}
+function noCommentsLineStart(lines, offset) {
+  return lines.starts[noCommentsLineNumber(lines, offset)];
+}
+function noCommentsLineEnd(lines, offset) {
+  return lines.ends[noCommentsLineNumber(lines, offset)];
+}
+function noCommentsIncludesLine(lines, start, end) {
+  let low = 0;
+  let high = lines.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (lines[middle] < start)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return lines[low] <= end;
+}
+function noCommentsFollowsOpeningBrace(text, offset) {
+  for (let index = offset - 1;index >= 0; index--) {
+    const character = text[index];
+    if (!/\s/.test(character))
+      return character === "{";
+  }
+  return false;
+}
+function noCommentsGroups(comments, text) {
+  const groups = [];
+  for (const comment of comments) {
+    const current = groups.at(-1);
+    const previous = current?.at(-1);
+    if (current && previous) {
+      const between = text.slice(previous.range[1], comment.range[0]);
+      if (NO_COMMENTS_LINE_GAP.test(between)) {
+        current.push(comment);
+        continue;
+      }
+    }
+    groups.push([comment]);
+  }
+  return groups;
+}
+function noCommentsJsxEmptyContainer(containers, start, end) {
+  let low = 0;
+  let high = containers.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (containers[middle].range[0] <= start)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  const container = containers[low - 1];
+  return container?.range[1] >= end ? container : undefined;
+}
+var noComments = defineRule11({
   meta: {
-    type: "problem",
+    type: "suggestion",
+    fixable: "code",
     schema: [{
       type: "object",
       additionalProperties: false,
       properties: {
-        allowPattern: { type: "string" },
-        detectComponents: { type: "boolean" },
-        hookPattern: { type: "string" }
+        allowWhy: { type: "boolean", default: true },
+        allowPatterns: { type: "array", items: { type: "string" } },
+        allowJsdoc: { type: "boolean", default: false }
       }
     }],
     messages: {
-      helper: "File-level helper {{name}} must move inside its owning component or hook."
+      comment: "Remove this comment."
     }
   },
   createOnce(context) {
+    let allowWhy = true;
+    let allowJsdoc = false;
+    let allowed = [];
     return {
+      before() {
+        const options = optionsFirst(context, {});
+        allowWhy = options.allowWhy ?? true;
+        allowJsdoc = options.allowJsdoc ?? false;
+        allowed = (options.allowPatterns ?? []).map((pattern) => new RegExp(pattern));
+      },
       Program(program) {
-        const {
-          allowPattern,
-          detectComponents = true,
-          hookPattern = "^use[A-Z]"
-        } = optionsFirst(context, {});
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
-        const hooks = new RegExp(hookPattern);
-        for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
-          if (detectComponents && reactComponentsIsLike(program, candidate) || hooks.test(candidate.name) || allowed?.test(candidate.name)) {
-            continue;
+        const source = context.sourceCode;
+        const text = source.text;
+        const comments = source.getAllComments().filter((comment) => comment.type !== "Shebang");
+        const removable = [];
+        const protectedTargetLines = [];
+        let mightContainJsxComment = false;
+        let whyContinuation = false;
+        let previousComment;
+        for (const comment of comments) {
+          const value = commentsNormalizedValue(comment);
+          if (!mightContainJsxComment && comment.type === "Block" && noCommentsFollowsOpeningBrace(text, comment.range[0])) {
+            mightContainJsxComment = true;
           }
-          context.report({
-            node: candidate.node,
+          const directlyFollowsPrevious = previousComment !== undefined && comment.loc.start.line === previousComment.loc.end.line + 1 && NO_COMMENTS_LINE_GAP.test(text.slice(previousComment.range[1], comment.range[0]));
+          const continuesWhy = comment.type === "Line" && whyContinuation && directlyFollowsPrevious;
+          const isWhy = commentsIsWhy(value) || continuesWhy;
+          if (commentsIsDisableNextLine(value)) {
+            protectedTargetLines.push(comment.loc.end.line + 1);
+          }
+          whyContinuation = comment.type === "Line" && isWhy;
+          previousComment = comment;
+          if (allowWhy && isWhy)
+            continue;
+          if (commentsIsDirective(value))
+            continue;
+          if (allowJsdoc && commentsIsJsdoc(text, comment))
+            continue;
+          if (allowed.some((pattern) => pattern.test(value.trim())))
+            continue;
+          removable.push(comment);
+        }
+        if (removable.length === 0)
+          return;
+        const lines = noCommentsCreateLineIndex(text);
+        const jsxContainers = [];
+        if (mightContainJsxComment) {
+          astVisit(program, [], (node) => {
+            if (node.type === "JSXExpressionContainer" && node.expression.type === "JSXEmptyExpression") {
+              jsxContainers.push(node);
+            }
+          });
+          jsxContainers.sort((left, right) => left.range[0] - right.range[0]);
+        }
+        for (const group of noCommentsGroups(removable, text)) {
+          const first = group[0];
+          const final = group[group.length - 1];
+          const container = noCommentsJsxEmptyContainer(jsxContainers, first.range[0], final.range[1]);
+          let embeddedUnicodeLineTerminator;
+          for (const comment of group) {
+            if (comment.type === "Block" && embeddedUnicodeLineTerminator === undefined) {
+              embeddedUnicodeLineTerminator = text.slice(comment.range[0], comment.range[1]).match(/[\u2028\u2029]/)?.[0];
+            }
+          }
+          const reportOnly = container !== undefined || noCommentsIncludesLine(protectedTargetLines, first.loc.start.line, final.loc.end.line);
+          const range0 = first.range[0];
+          const range1 = final.range[1];
+          context.report({
+            loc: { start: first.loc.start, end: final.loc.end },
+            messageId: "comment",
+            ...reportOnly ? {} : {
+              fix(fixer) {
+                const lineStart = noCommentsLineStart(lines, range0);
+                const before = text.slice(lineStart, range0);
+                if (NO_COMMENTS_HORIZONTAL_SPACE.test(before)) {
+                  const trailingLines = text.slice(range1).match(NO_COMMENTS_TRAILING_LINES);
+                  if (trailingLines) {
+                    const end = range1 + trailingLines[0].length;
+                    return embeddedUnicodeLineTerminator ? fixer.replaceTextRange([lineStart, end], embeddedUnicodeLineTerminator) : fixer.removeRange([lineStart, end]);
+                  }
+                }
+                const removed = text.slice(range0, range1);
+                const lineBreak = removed.match(NO_COMMENTS_LINE_TERMINATOR)?.[0];
+                let afterOnLine;
+                if (lineBreak) {
+                  afterOnLine = text.slice(range1, noCommentsLineEnd(lines, range1));
+                  if (/\S/.test(before) && /\S/.test(afterOnLine)) {
+                    return fixer.replaceTextRange([range0, range1], lineBreak);
+                  }
+                }
+                if (embeddedUnicodeLineTerminator) {
+                  return fixer.replaceTextRange([range0, range1], embeddedUnicodeLineTerminator);
+                }
+                afterOnLine ??= text.slice(range1, noCommentsLineEnd(lines, range1));
+                if (NO_COMMENTS_HORIZONTAL_SPACE.test(afterOnLine)) {
+                  const start = range0 - (/[\t ]*$/.exec(before)?.[0].length ?? 0);
+                  return fixer.removeRange([start, range1]);
+                }
+                const left = text[range0 - 1];
+                const right = text[range1];
+                const separator = left && right && !/\s/.test(left) && !/\s/.test(right) ? " " : "";
+                return fixer.replaceTextRange([range0, range1], separator);
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-extra-exports.ts
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var noExtraExports = defineRule12({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        names: { type: "array", items: { type: "string" } },
+        patterns: { type: "array", items: { type: "string" } },
+        domainStem: { type: "string", enum: [...namingStemModes] },
+        trailingRoles: { type: "array", items: { type: "string" } },
+        roleSeparators: { type: "array", items: { type: "string" } },
+        allowTypeExports: { type: "boolean" }
+      },
+      required: ["names"]
+    }],
+    messages: {
+      extraExport: "Export '{{name}}' is not allowed; expected one of: {{allowed}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options = optionsFirst(context);
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
+        const domain = namingFileStem(basename, options.domainStem, options.trailingRoles, options.roleSeparators);
+        const replacements = {
+          Domain: namingPascalCase(domain),
+          domain: namingCamelCase(domain)
+        };
+        const allowed = options.names.map((template) => template.replaceAll("{Domain}", replacements.Domain).replaceAll("{domain}", replacements.domain));
+        const patterns = (options.patterns ?? []).map((template) => {
+          const source = template.replaceAll("{Domain}", replacements.Domain.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).replaceAll("{domain}", replacements.domain.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+          return new RegExp(`^(?:${source})$`);
+        });
+        for (const binding of exportsCollect(program)) {
+          if (options.allowTypeExports && binding.typeOnly) {
+            continue;
+          }
+          const name = binding.localName ?? binding.exportedName;
+          if (!allowed.includes(name) && !patterns.some((pattern) => pattern.test(name))) {
+            context.report({
+              node: binding.node,
+              messageId: "extraExport",
+              data: {
+                name,
+                allowed: [...allowed, ...patterns.map((pattern) => pattern.toString())].join(", ")
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-extra-factory-keys.ts
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+function compileFactoryKeys(pattern, keys, requireKeys) {
+  const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
+  return {
+    pattern: new RegExp(pattern),
+    allowed: new Set(allowedList),
+    allowedList,
+    requireKeys
+  };
+}
+var noExtraFactoryKeys = defineRule13({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        keys: { type: "array", items: { type: "string" } },
+        factoryPattern: { type: "string" },
+        requireKeys: { type: "array", items: { type: "string" } },
+        keySets: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              factoryPattern: { type: "string" },
+              keys: { type: "array", items: { type: "string" } },
+              requireKeys: { type: "array", items: { type: "string" } }
+            },
+            required: ["factoryPattern", "keys"]
+          }
+        }
+      }
+    }],
+    messages: {
+      extraKey: "Factory '{{factory}}' must not return key '{{key}}'; allowed keys: {{allowed}}.",
+      missingKey: "Factory '{{factory}}' must return key '{{key}}'.",
+      emptyObject: "Factory '{{factory}}' must not return an empty object."
+    }
+  },
+  createOnce(context) {
+    let keySets = [];
+    let fallback;
+    function resolveFactoryKeys(name) {
+      const matched = keySets.find((item) => item.pattern.test(name));
+      if (matched) {
+        return matched;
+      }
+      if (fallback?.pattern.test(name)) {
+        return fallback;
+      }
+    }
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        const { keys, factoryPattern = "^make[A-Z]", requireKeys = [], keySets: configured } = options;
+        if (!keys && !configured) {
+          return false;
+        }
+        keySets = (configured ?? []).map((item) => compileFactoryKeys(item.factoryPattern, item.keys, item.requireKeys ?? []));
+        fallback = keys ? compileFactoryKeys(factoryPattern, keys, requireKeys) : undefined;
+      },
+      Program(program) {
+        for (const factory of factoriesCollectTopLevel(program, /^/)) {
+          const resolved = resolveFactoryKeys(factory.name);
+          if (!resolved) {
+            continue;
+          }
+          for (const object of factoriesDirectlyReturnedObjects(factory)) {
+            const present = new Set(object.properties.flatMap((property) => {
+              const key = factoriesObjectPropertyName(property);
+              return key ? [key] : [];
+            }));
+            if (object.properties.length === 0 && resolved.requireKeys.length > 0) {
+              context.report({
+                node: object,
+                messageId: "emptyObject",
+                data: { factory: factory.name }
+              });
+            }
+            for (const property of object.properties) {
+              const key = factoriesObjectPropertyName(property);
+              if (!key || !resolved.allowed.has(key)) {
+                context.report({
+                  node: property,
+                  messageId: "extraKey",
+                  data: { factory: factory.name, key: key ?? "<computed or spread>", allowed: resolved.allowedList.join(", ") }
+                });
+              }
+            }
+            for (const key of resolved.requireKeys) {
+              if (!present.has(key)) {
+                context.report({
+                  node: object,
+                  messageId: "missingKey",
+                  data: { factory: factory.name, key }
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-file-level-helpers.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule14({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowPattern: { type: "string" },
+        detectComponents: { type: "boolean" },
+        hookPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      helper: "File-level helper {{name}} must move inside its owning component or hook."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const {
+          allowPattern,
+          detectComponents = true,
+          hookPattern = "^use[A-Z]"
+        } = optionsFirst(context, {});
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const hooks = new RegExp(hookPattern);
+        for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
+          if (detectComponents && reactComponentsIsLike(program, candidate) || hooks.test(candidate.name) || allowed?.test(candidate.name)) {
+            continue;
+          }
+          context.report({
+            node: candidate.node,
             messageId: "helper",
             data: { name: candidate.name }
           });
@@ -1156,7 +1929,7 @@ var noFileLevelHelpers = defineRule9({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || !imports.has(declaration.typeAnnotation.typeName.name)) {
     return;
@@ -1166,7 +1939,7 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule10({
+var noImportedTypeAlias = defineRule15({
   meta: {
     type: "problem",
     schema: [],
@@ -1216,8 +1989,8 @@ var noImportedTypeAlias = defineRule10({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule11({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule16({
   meta: {
     type: "problem",
     schema: [{
@@ -1265,7 +2038,7 @@ var noInlineSchemaElements = defineRule11({
 });
 
 // src/rules/no-inline-types.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -1275,7 +2048,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var noInlineTypes = defineRule12({
+var noInlineTypes = defineRule17({
   meta: {
     type: "problem",
     schema: [{
@@ -1284,7 +2057,8 @@ var noInlineTypes = defineRule12({
       properties: {
         parameters: { type: "boolean" },
         returns: { type: "boolean" },
-        functionTypes: { type: "boolean" }
+        functionTypes: { type: "boolean" },
+        minMembers: { type: "integer", minimum: 1 }
       }
     }],
     messages: {
@@ -1292,48 +2066,111 @@ var noInlineTypes = defineRule12({
     }
   },
   createOnce(context) {
+    let checkParameters = true;
+    let checkReturns = true;
+    let checkFunctionTypes = true;
+    let minMembers = 1;
+    function isInline(node) {
+      return node.type === "TSTypeLiteral" && (minMembers === 1 || node.members.length >= minMembers) || checkFunctionTypes && (node.type === "TSFunctionType" || node.type === "TSConstructorType");
+    }
+    function check(annotation, position) {
+      astVisit(annotation, [], (node, ancestors) => {
+        if (!isInline(node) || ancestors.some(isInline)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "inlineType",
+          data: { kind: node.type === "TSTypeLiteral" ? "object" : "function", position }
+        });
+      });
+    }
+    function checkFunction(node) {
+      if (checkParameters) {
+        for (const parameter of node.params) {
+          check(parameterAnnotation(parameter), "parameter");
+        }
+      }
+      if (checkReturns) {
+        check(node.returnType, "return");
+      }
+    }
     return {
-      Program(program) {
-        const { parameters = true, returns = true, functionTypes = true } = optionsFirst(context, {});
-        const isInline = (node) => node.type === "TSTypeLiteral" || functionTypes && (node.type === "TSFunctionType" || node.type === "TSConstructorType");
-        function check(annotation, position) {
-          astVisit(annotation, [], (node, ancestors) => {
-            if (!isInline(node) || ancestors.some(isInline)) {
-              return;
-            }
-            context.report({
-              node,
-              messageId: "inlineType",
-              data: { kind: node.type === "TSTypeLiteral" ? "object" : "function", position }
-            });
+      before() {
+        const options = optionsFirst(context, {});
+        checkParameters = options.parameters ?? true;
+        checkReturns = options.returns ?? true;
+        checkFunctionTypes = options.functionTypes ?? true;
+        minMembers = options.minMembers ?? 1;
+        if (!checkParameters && !checkReturns) {
+          return false;
+        }
+      },
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+      TSDeclareFunction: checkFunction,
+      TSEmptyBodyFunctionExpression: checkFunction
+    };
+  }
+});
+
+// src/rules/no-literal-in.ts
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+function literalKey(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+  }
+}
+var noLiteralIn = defineRule18({
+  meta: {
+    type: "suggestion",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allow: { type: "array", items: { type: "string" } }
+      }
+    }],
+    defaultOptions: [{ allow: [] }],
+    messages: {
+      literalIn: "Avoid '{{key}}' in value; use Object.hasOwn() or a discriminated union."
+    }
+  },
+  createOnce(context) {
+    let allow = new Set;
+    return {
+      before() {
+        allow = new Set(optionsFirst(context, { allow: [] }).allow);
+      },
+      BinaryExpression(node) {
+        if (node.operator !== "in") {
+          return;
+        }
+        const key = literalKey(node.left);
+        if (key !== undefined && !allow.has(key)) {
+          context.report({
+            node: node.left,
+            messageId: "literalIn",
+            data: { key }
           });
         }
-        astVisit(program, [], (node) => {
-          if (node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression" && node.type !== "ArrowFunctionExpression" && node.type !== "TSDeclareFunction" && node.type !== "TSEmptyBodyFunctionExpression") {
-            return;
-          }
-          if (parameters) {
-            for (const parameter of node.params) {
-              check(parameterAnnotation(parameter), "parameter");
-            }
-          }
-          if (returns) {
-            check(node.returnType, "return");
-          }
-        });
       }
     };
   }
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 var defaultRuntimeImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var defaultConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 function formatMessage(template, data) {
   return Object.entries(data).reduce((result, [key, value]) => result.replaceAll(`{{${key}}}`, value), template);
 }
-var noLocalSchemaConstruction = defineRule13({
+var noLocalSchemaConstruction = defineRule19({
   meta: {
     type: "problem",
     schema: [{
@@ -1445,9 +2282,8 @@ var noLocalSchemaConstruction = defineRule13({
 });
 
 // src/rules/no-member-comments.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var DIRECTIVE = /^\s*(?:@ts-(?:ignore|expect-error|nocheck)|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
-var noMemberComments = defineRule14({
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var noMemberComments = defineRule20({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -1479,8 +2315,8 @@ var noMemberComments = defineRule14({
       let previousLine = -1;
       const removable = [];
       for (const comment of comments) {
-        const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
-        const isWhy = value.startsWith("Why: ") || comment.type === "Line" && whyContinuation && comment.loc.start.line === previousLine + 1;
+        const value = commentsNormalizedValue(comment);
+        const isWhy = commentsIsWhy(value) || comment.type === "Line" && whyContinuation && comment.loc.start.line === previousLine + 1;
         whyContinuation = comment.type === "Line" && isWhy;
         previousLine = comment.loc.end.line;
         if (reported.has(comment.range[0]))
@@ -1488,7 +2324,7 @@ var noMemberComments = defineRule14({
         reported.add(comment.range[0]);
         if (allowWhy && isWhy)
           continue;
-        if (DIRECTIVE.test(value))
+        if (commentsIsDirective(value))
           continue;
         removable.push(comment);
       }
@@ -1540,36 +2376,249 @@ var noMemberComments = defineRule14({
   }
 });
 
-// src/rules/no-rederive-schema.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule15({
+// src/rules/no-module-mutable-state.ts
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+function moduleMutableStateBindings(pattern) {
+  if (pattern.type === "Identifier") {
+    return [{ name: pattern.name, node: pattern }];
+  }
+  if (pattern.type === "AssignmentPattern") {
+    return moduleMutableStateBindings(pattern.left);
+  }
+  if (pattern.type === "RestElement") {
+    return moduleMutableStateBindings(pattern.argument);
+  }
+  if (pattern.type === "ObjectPattern") {
+    return pattern.properties.flatMap((property) => property.type === "RestElement" ? moduleMutableStateBindings(property) : moduleMutableStateBindings(property.value));
+  }
+  if (pattern.type === "ArrayPattern") {
+    return pattern.elements.flatMap((element) => element ? moduleMutableStateBindings(element) : []);
+  }
+  return [];
+}
+function moduleMutableStateInsideFunction(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression" || current.type === "TSDeclareFunction" || current.type === "TSEmptyBodyFunctionExpression" || current.type === "StaticBlock") {
+      return true;
+    }
+  }
+  return false;
+}
+function moduleMutableStateIsModuleLet(node) {
+  const parent = node.parent;
+  return parent?.type === "Program" || parent?.type === "ExportNamedDeclaration" && parent.parent?.type === "Program";
+}
+function moduleMutableStateInsideAmbient(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (current.type === "TSModuleDeclaration" && (current.declare || current.global || current.id.type === "Literal")) {
+      return true;
+    }
+  }
+  return false;
+}
+var noModuleMutableState = defineRule21({
   meta: {
     type: "problem",
     schema: [{
       type: "object",
       additionalProperties: false,
       properties: {
-        from: { type: "array", items: { type: "string" } },
-        namespaces: { type: "array", items: { type: "string" } },
-        operators: { type: "array", items: { type: "string" } }
-      },
-      required: ["from"]
+        kinds: {
+          type: "array",
+          items: { type: "string", enum: ["let", "var"] }
+        },
+        allowNamePattern: { type: "string" }
+      }
     }],
     messages: {
-      rederive: "Do not derive {{operator}} from imported schema {{schema}}; import its DTO type."
+      moduleState: "module state is shared across requests/tests; keep it local."
     }
   },
   createOnce(context) {
-    let imported = new Set;
+    let kindSet = new Set(["let", "var"]);
+    let allowed = null;
     return {
-      Program(program) {
-        const { from } = optionsFirst(context);
-        imported = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && from.includes(statement.source.value) ? statement.specifiers.map((specifier) => specifier.local.name) : []));
+      before() {
+        const { kinds = ["let", "var"], allowNamePattern } = optionsFirst(context, {});
+        kindSet = new Set(kinds);
+        allowed = allowNamePattern ? new RegExp(allowNamePattern) : null;
       },
-      TSTypeReference(node) {
-        const {
-          namespaces = ["z"],
-          operators = ["infer", "input"]
+      VariableDeclaration(node) {
+        if (node.declare || !kindSet.has(node.kind)) {
+          return;
+        }
+        if (node.kind === "let" && !moduleMutableStateIsModuleLet(node) || node.kind === "var" && moduleMutableStateInsideFunction(node) || moduleMutableStateInsideAmbient(node)) {
+          return;
+        }
+        for (const declarator of node.declarations) {
+          for (const binding of moduleMutableStateBindings(declarator.id)) {
+            if (!allowed?.test(binding.name)) {
+              context.report({
+                node: binding.node,
+                messageId: "moduleState"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-promise-all-mutation.ts
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+function mutationBinding(node) {
+  if (node.type === "Identifier") {
+    return node;
+  }
+  if (node.type === "MemberExpression") {
+    return mutationBinding(node.object);
+  }
+  if (node.type === "ChainExpression" || node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression") {
+    return mutationBinding(node.expression);
+  }
+}
+function mutationBindings(node) {
+  switch (node.type) {
+    case "ArrayPattern":
+      return node.elements.flatMap((element) => element ? mutationBindings(element) : []);
+    case "ObjectPattern":
+      return node.properties.flatMap((property) => property.type === "RestElement" ? mutationBindings(property) : mutationBindings(property.value));
+    case "AssignmentPattern":
+      return mutationBindings(node.left);
+    case "RestElement":
+      return mutationBindings(node.argument);
+    default: {
+      const binding = mutationBinding(node);
+      return binding ? [binding] : [];
+    }
+  }
+}
+var noPromiseAllMutation = defineRule22({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        combinators: { type: "array", items: { type: "string" } },
+        methods: { type: "array", items: { type: "string" } },
+        checkAssignments: { type: "boolean" }
+      }
+    }],
+    defaultOptions: [{
+      combinators: ["Promise.all", "Promise.allSettled", "Promise.any", "Promise.race"],
+      methods: ["push", "unshift", "splice", "set", "add"],
+      checkAssignments: true
+    }],
+    messages: {
+      mutation: "Do not mutate outer binding '{{name}}' inside {{combinator}}()."
+    }
+  },
+  createOnce(context) {
+    const references = new Map;
+    const reported = new Set;
+    let combinators = new Set;
+    let methods = new Set;
+    let checkAssignments = true;
+    let referencesReady = false;
+    function ensureReferences() {
+      if (referencesReady) {
+        return;
+      }
+      referencesReady = true;
+      for (const scope of context.sourceCode.scopeManager.scopes) {
+        for (const reference of scope.references) {
+          references.set(reference.identifier.range[0], reference.resolved);
+        }
+      }
+    }
+    function isOuterBinding(identifier, call) {
+      const variable = references.get(identifier.range[0]);
+      return variable !== undefined && variable !== null && variable.identifiers.length > 0 && variable.identifiers.every((declaration) => declaration.range[0] < call.range[0] || declaration.range[1] > call.range[1]);
+    }
+    function reportMutation(node, binding, call, combinator) {
+      if (!binding || reported.has(binding.range[0]) || !isOuterBinding(binding, call)) {
+        return;
+      }
+      reported.add(binding.range[0]);
+      context.report({
+        node,
+        messageId: "mutation",
+        data: { name: binding.name, combinator }
+      });
+    }
+    return {
+      before() {
+        const options = optionsFirst(context);
+        combinators = new Set(options.combinators);
+        methods = new Set(options.methods);
+        checkAssignments = options.checkAssignments;
+        references.clear();
+        reported.clear();
+        referencesReady = false;
+      },
+      CallExpression(node) {
+        const combinator = astDottedName(node.callee);
+        if (!combinator || !combinators.has(combinator)) {
+          return;
+        }
+        ensureReferences();
+        for (const argument of node.arguments) {
+          astVisit(argument, [node], (candidate) => {
+            if (candidate.type === "CallExpression" && candidate.callee.type === "MemberExpression") {
+              const method = astStaticMemberName(candidate.callee);
+              if (method && methods.has(method)) {
+                reportMutation(candidate, mutationBinding(candidate.callee.object), node, combinator);
+              }
+              return;
+            }
+            if (checkAssignments && candidate.type === "AssignmentExpression") {
+              for (const binding of mutationBindings(candidate.left)) {
+                reportMutation(candidate, binding, node, combinator);
+              }
+              return;
+            }
+            if (checkAssignments && candidate.type === "UpdateExpression") {
+              reportMutation(candidate, mutationBinding(candidate.argument), node, combinator);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-rederive-schema.ts
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule23({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        from: { type: "array", items: { type: "string" } },
+        namespaces: { type: "array", items: { type: "string" } },
+        operators: { type: "array", items: { type: "string" } }
+      },
+      required: ["from"]
+    }],
+    messages: {
+      rederive: "Do not derive {{operator}} from imported schema {{schema}}; import its DTO type."
+    }
+  },
+  createOnce(context) {
+    let imported = new Set;
+    return {
+      Program(program) {
+        const { from } = optionsFirst(context);
+        imported = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && from.includes(statement.source.value) ? statement.specifiers.map((specifier) => specifier.local.name) : []));
+      },
+      TSTypeReference(node) {
+        const {
+          namespaces = ["z"],
+          operators = ["infer", "input"]
         } = optionsFirst(context);
         const operator = schemasTypeOperator(node, new Set(namespaces), new Set(operators));
         const parameter = node.typeArguments?.params[0];
@@ -1586,9 +2635,98 @@ var noRederiveSchema = defineRule15({
   }
 });
 
+// src/rules/no-restricted-constructor.ts
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+function restrictedConstructorEntries(constructors) {
+  const entries = new Map;
+  for (const item of constructors) {
+    if (typeof item === "string") {
+      if (!entries.has(item)) {
+        entries.set(item, undefined);
+      }
+      continue;
+    }
+    if (!entries.has(item.name)) {
+      entries.set(item.name, item.message);
+    }
+  }
+  return entries;
+}
+var noRestrictedConstructor = defineRule24({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        constructors: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  name: { type: "string" },
+                  message: { type: "string" }
+                },
+                required: ["name"]
+              }
+            ]
+          }
+        },
+        checkCalls: { type: "boolean", default: false },
+        message: { type: "string" }
+      },
+      required: ["constructors"]
+    }],
+    messages: {
+      construct: "Do not construct '{{name}}'.{{suffix}}",
+      call: "Do not call '{{name}}'.{{suffix}}"
+    }
+  },
+  createOnce(context) {
+    let entries = new Map;
+    let checkCalls = false;
+    let fallbackMessage;
+    function report(node, messageId) {
+      const name = astDottedName(node.callee);
+      if (!name || !entries.has(name)) {
+        return;
+      }
+      const extra = entries.get(name) ?? fallbackMessage;
+      context.report({
+        node,
+        messageId,
+        data: { name, suffix: extra ? ` ${extra}` : "" }
+      });
+    }
+    return {
+      before() {
+        const options = optionsFirst(context);
+        entries = restrictedConstructorEntries(options.constructors);
+        checkCalls = options.checkCalls === true;
+        fallbackMessage = options.message;
+        if (entries.size === 0) {
+          return false;
+        }
+      },
+      NewExpression(node) {
+        report(node, "construct");
+      },
+      CallExpression(node) {
+        if (checkCalls) {
+          report(node, "call");
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule16({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule25({
   meta: {
     type: "problem",
     schema: [{
@@ -1618,7 +2756,7 @@ var noRestrictedFiles = defineRule16({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -1626,7 +2764,10 @@ function tokenIsTypeOnlyImport(node) {
   }
   return (parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") && parent.parent.type === "ImportDeclaration" && parent.parent.importKind === "type";
 }
-var noRestrictedToken = defineRule17({
+function memberMatches(node, restriction) {
+  return restriction.startsWith("*.") ? astStaticMemberName(node) === restriction.slice(2) : astDottedName(node) === restriction;
+}
+var noRestrictedToken = defineRule26({
   meta: {
     type: "problem",
     schema: [{
@@ -1635,32 +2776,86 @@ var noRestrictedToken = defineRule17({
       properties: {
         token: { type: "string" },
         allowIn: { type: "array", items: { type: "string" } },
-        allowPathPatterns: { type: "array", items: { type: "string" } }
+        allowPathPatterns: { type: "array", items: { type: "string" } },
+        restrictions: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              token: { type: "string" },
+              member: { type: "string" },
+              allowIn: { type: "array", items: { type: "string" } },
+              allowPathPatterns: { type: "array", items: { type: "string" } },
+              message: { type: "string" }
+            },
+            oneOf: [
+              { required: ["token"], not: { required: ["member"] } },
+              { required: ["member"], not: { required: ["token"] } }
+            ]
+          }
+        }
       },
-      required: ["token", "allowIn"]
+      anyOf: [
+        { required: ["token"] },
+        { required: ["restrictions"] }
+      ]
     }],
     messages: {
-      restricted: "'{{token}}' may only appear in configured owner paths."
+      restricted: "'{{token}}' may only appear in configured owner paths.",
+      restrictedWithMessage: "'{{token}}' may only appear in configured owner paths. {{custom}}"
     }
   },
   createOnce(context) {
+    let restrictions = [];
+    function report(node, restriction) {
+      context.report({
+        node,
+        messageId: restriction.message === undefined ? "restricted" : "restrictedWithMessage",
+        data: { token: restriction.value, custom: restriction.message ?? "" }
+      });
+    }
     return {
       before() {
         const options = optionsFirst(context);
+        const configured = [
+          ...options.token ? [{
+            token: options.token,
+            allowIn: options.allowIn,
+            allowPathPatterns: options.allowPathPatterns
+          }] : [],
+          ...options.restrictions ?? []
+        ];
         const filename = namingPosixPath(context.filename);
-        const allowed = options.allowIn.some((suffix) => filename.endsWith(suffix)) || (options.allowPathPatterns ?? []).some((pattern) => new RegExp(pattern).test(filename));
-        if (allowed) {
+        restrictions = configured.flatMap((restriction) => {
+          const allowed = (restriction.allowIn ?? []).some((suffix) => filename.endsWith(suffix)) || (restriction.allowPathPatterns ?? []).some((pattern) => new RegExp(pattern).test(filename));
+          if (allowed) {
+            return [];
+          }
+          if (restriction.token) {
+            return [{ kind: "token", value: restriction.token, message: restriction.message }];
+          }
+          return restriction.member ? [{ kind: "member", value: restriction.member, message: restriction.message }] : [];
+        });
+        if (restrictions.length === 0) {
           return false;
         }
       },
       Identifier(node) {
-        const { token } = optionsFirst(context);
-        if (node.name === token && !tokenIsTypeOnlyImport(node)) {
-          context.report({
-            node,
-            messageId: "restricted",
-            data: { token }
-          });
+        if (tokenIsTypeOnlyImport(node)) {
+          return;
+        }
+        for (const restriction of restrictions) {
+          if (restriction.kind === "token" && node.name === restriction.value) {
+            report(node, restriction);
+          }
+        }
+      },
+      MemberExpression(node) {
+        for (const restriction of restrictions) {
+          if (restriction.kind === "member" && memberMatches(node, restriction.value)) {
+            report(node, restriction);
+          }
         }
       }
     };
@@ -1668,8 +2863,224 @@ var noRestrictedToken = defineRule17({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-var noRuntimeInTypes = defineRule18({
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+function isTypeOnlyImport(statement) {
+  return statement.importKind === "type" || statement.specifiers.length > 0 && statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+}
+function exportLocalName(specifier) {
+  return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+}
+function importEqualsSource(declaration) {
+  return declaration.moduleReference.type === "TSExternalModuleReference" ? declaration.moduleReference.expression.value : undefined;
+}
+function importEqualsDeclaration(statement) {
+  if (statement.type === "TSImportEqualsDeclaration") {
+    return statement;
+  }
+  return statement.type === "ExportNamedDeclaration" && statement.declaration?.type === "TSImportEqualsDeclaration" ? statement.declaration : undefined;
+}
+function isAllowedSource(source, allowedImportSources) {
+  return allowedImportSources.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(source);
+  });
+}
+function runtimeInTypesIsAmbientFile(filename) {
+  return filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts");
+}
+function runtimeInTypesUnwrapped(statement) {
+  return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? undefined : statement;
+}
+function runtimeInTypesEntityRootName(node) {
+  let current = node;
+  while (current.type === "TSQualifiedName") {
+    current = current.left;
+  }
+  return current.type === "Identifier" ? current.name : undefined;
+}
+function importEqualsRootName(declaration) {
+  return declaration.moduleReference.type === "TSExternalModuleReference" ? undefined : runtimeInTypesEntityRootName(declaration.moduleReference);
+}
+function runtimeInTypesModuleBindingName(node) {
+  return node.type === "TSModuleDeclaration" ? runtimeInTypesEntityRootName(node.id) : undefined;
+}
+function runtimeInTypesIsInternalValueAlias(declaration, valueNames) {
+  if (declaration.importKind === "type" || importEqualsSource(declaration) !== undefined) {
+    return false;
+  }
+  const root = importEqualsRootName(declaration);
+  return root !== undefined && valueNames.has(root);
+}
+function runtimeInTypesModuleName(node) {
+  if (node.type !== "TSModuleDeclaration") {
+    return "namespace";
+  }
+  return node.id.type === "Identifier" ? node.id.name : node.id.type === "Literal" ? String(node.id.value) : "namespace";
+}
+function runtimeInTypesNamespaceIsRuntime(node, isAmbientFile, valueNames) {
+  if (isAmbientFile || node.type !== "TSModuleDeclaration" || node.declare || node.global || node.id.type === "Literal" || !node.body) {
+    return false;
+  }
+  return node.body.body.some((statement) => runtimeInTypesNamespaceMemberIsRuntime(statement, isAmbientFile, valueNames));
+}
+function runtimeInTypesNamespaceMemberIsRuntime(node, isAmbientFile, valueNames) {
+  if (node.type === "ExportNamedDeclaration") {
+    if (node.exportKind === "type") {
+      return false;
+    }
+    return node.declaration ? runtimeInTypesNamespaceMemberIsRuntime(node.declaration, isAmbientFile, valueNames) : node.specifiers.some((specifier) => specifier.exportKind !== "type");
+  }
+  if (node.type === "TSModuleDeclaration") {
+    return runtimeInTypesNamespaceIsRuntime(node, isAmbientFile, valueNames);
+  }
+  if (node.type === "TSImportEqualsDeclaration") {
+    return node.importKind !== "type" && (node.moduleReference.type === "TSExternalModuleReference" || runtimeInTypesIsInternalValueAlias(node, valueNames));
+  }
+  if (node.type === "TSExportAssignment") {
+    return true;
+  }
+  return declarationsIsRuntime(node) && !node.declare;
+}
+function runtimeInTypesMemberHasValue(node) {
+  if (node.type === "ExportNamedDeclaration") {
+    if (node.exportKind === "type") {
+      return false;
+    }
+    return node.declaration ? runtimeInTypesMemberHasValue(node.declaration) : node.specifiers.some((specifier) => specifier.exportKind !== "type");
+  }
+  if (node.type === "TSModuleDeclaration") {
+    return runtimeInTypesNamespaceHasValueMembers(node);
+  }
+  if (node.type === "TSImportEqualsDeclaration") {
+    return node.importKind !== "type" && node.moduleReference.type === "TSExternalModuleReference";
+  }
+  if (node.type === "TSExportAssignment") {
+    return true;
+  }
+  return declarationsIsRuntime(node);
+}
+function runtimeInTypesNamespaceHasValueMembers(node) {
+  if (node.type !== "TSModuleDeclaration" || node.global || node.id.type === "Literal" || !node.body) {
+    return false;
+  }
+  return node.body.body.some((statement) => runtimeInTypesMemberHasValue(statement));
+}
+function runtimeInTypesMemberReferencesValue(node, valueNames) {
+  if (node.type === "ExportNamedDeclaration") {
+    return node.declaration ? runtimeInTypesMemberReferencesValue(node.declaration, valueNames) : false;
+  }
+  if (node.type === "TSModuleDeclaration") {
+    return runtimeInTypesNamespaceHasValueMembers(node) || runtimeInTypesNamespaceReferencesValue(node, valueNames);
+  }
+  if (node.type === "TSImportEqualsDeclaration") {
+    return runtimeInTypesIsInternalValueAlias(node, valueNames);
+  }
+  return false;
+}
+function runtimeInTypesNamespaceReferencesValue(node, valueNames) {
+  if (node.type !== "TSModuleDeclaration" || !node.body) {
+    return false;
+  }
+  return node.body.body.some((statement) => runtimeInTypesMemberReferencesValue(statement, valueNames));
+}
+function runtimeInTypesSeedValueName(declaration, valueNames) {
+  if (declaration.type === "VariableDeclaration") {
+    for (const item of declaration.declarations) {
+      if (item.id.type === "Identifier") {
+        valueNames.add(item.id.name);
+      }
+    }
+    return;
+  }
+  if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" || declaration.type === "TSEnumDeclaration") && declaration.id) {
+    valueNames.add(declaration.id.name);
+    return;
+  }
+  if (declaration.type === "TSModuleDeclaration") {
+    const name = runtimeInTypesModuleBindingName(declaration);
+    if (name && runtimeInTypesNamespaceHasValueMembers(declaration)) {
+      valueNames.add(name);
+    }
+  }
+}
+function runtimeInTypesValueNames(statements) {
+  const valueNames = new Set;
+  for (const statement of statements) {
+    if (statement.type === "ImportDeclaration") {
+      if (isTypeOnlyImport(statement)) {
+        continue;
+      }
+      for (const specifier of statement.specifiers) {
+        if (specifier.type !== "ImportSpecifier" || specifier.importKind !== "type") {
+          valueNames.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    const importEquals = importEqualsDeclaration(statement);
+    if (importEquals) {
+      if (importEquals.importKind !== "type" && importEqualsSource(importEquals) !== undefined) {
+        valueNames.add(importEquals.id.name);
+      }
+      continue;
+    }
+    const declaration = runtimeInTypesUnwrapped(statement);
+    if (declaration) {
+      runtimeInTypesSeedValueName(declaration, valueNames);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const statement of statements) {
+      const importEquals = importEqualsDeclaration(statement);
+      if (importEquals && runtimeInTypesIsInternalValueAlias(importEquals, valueNames)) {
+        if (!valueNames.has(importEquals.id.name)) {
+          valueNames.add(importEquals.id.name);
+          changed = true;
+        }
+        continue;
+      }
+      const declaration = runtimeInTypesUnwrapped(statement);
+      if (declaration?.type !== "TSModuleDeclaration") {
+        continue;
+      }
+      const name = runtimeInTypesModuleBindingName(declaration);
+      if (name && !valueNames.has(name) && runtimeInTypesNamespaceReferencesValue(declaration, valueNames)) {
+        valueNames.add(name);
+        changed = true;
+      }
+    }
+  }
+  return valueNames;
+}
+function runtimeInTypesExportAssignmentExpression(node) {
+  let expression = node.expression;
+  while (expression.type === "ParenthesizedExpression") {
+    expression = expression.expression;
+  }
+  return expression;
+}
+function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbientFile) {
+  if (statement.exportKind === "type") {
+    return false;
+  }
+  if (statement.type === "ExportAllDeclaration") {
+    return true;
+  }
+  if (statement.declaration?.type === "TSImportEqualsDeclaration") {
+    const declaration = statement.declaration;
+    if (declaration.importKind === "type" || isAmbientFile) {
+      return false;
+    }
+    return importEqualsSource(declaration) !== undefined || runtimeInTypesIsInternalValueAlias(declaration, valueNames);
+  }
+  if (statement.source) {
+    return statement.specifiers.length === 0 || statement.specifiers.some((specifier) => specifier.exportKind !== "type");
+  }
+  return statement.specifiers.some((specifier) => specifier.exportKind !== "type" && runtimeImportLocals.has(exportLocalName(specifier)));
+}
+var noRuntimeInTypes = defineRule27({
   meta: {
     type: "problem",
     schema: [{
@@ -1679,18 +3090,80 @@ var noRuntimeInTypes = defineRule18({
         allow: {
           type: "array",
           items: { type: "string", enum: ["class", "default", "enum", "function", "variable"] }
+        },
+        runtimeImports: { type: "string", enum: ["allow", "ban"] },
+        allowImportSources: { type: "array", items: { type: "string" } },
+        banReExports: { type: "boolean" }
+      }
+    }],
+    messages: {
+      runtimeValue: "Types files must not contain runtime value {{name}}.",
+      runtimeImport: "Types files must not contain runtime imports from {{source}}.",
+      runtimeReExport: "Types files must not contain runtime re-exports."
+    }
+  },
+  createOnce(context) {
+    let allow = [];
+    let runtimeImports = "allow";
+    let allowedImportSources = [];
+    let banReExports = false;
+    let isAmbientFile = false;
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        allow = options.allow ?? [];
+        runtimeImports = options.runtimeImports ?? "allow";
+        allowedImportSources = (options.allowImportSources ?? []).map((pattern) => new RegExp(pattern));
+        banReExports = options.banReExports === true;
+        isAmbientFile = runtimeInTypesIsAmbientFile(context.filename);
+      },
+      Program(program) {
+        const runtimeImportLocals = new Set;
+        const valueNames = runtimeInTypesValueNames(program.body);
+        for (const statement of program.body) {
+          if (statement.type === "ImportDeclaration") {
+            if (isTypeOnlyImport(statement)) {
+              continue;
+            }
+            for (const specifier of statement.specifiers) {
+              if (specifier.type !== "ImportSpecifier" || specifier.importKind !== "type") {
+                runtimeImportLocals.add(specifier.local.name);
+              }
+            }
+            const source = String(statement.source.value);
+            if (runtimeImports === "ban" && !isAllowedSource(source, allowedImportSources)) {
+              context.report({
+                node: statement,
+                messageId: "runtimeImport",
+                data: { source }
+              });
+            }
+            continue;
+          }
+          const declaration = importEqualsDeclaration(statement);
+          if (!declaration || declaration.importKind === "type") {
+            continue;
+          }
+          const source = importEqualsSource(declaration);
+          if (source === undefined) {
+            continue;
+          }
+          runtimeImportLocals.add(declaration.id.name);
+          if (runtimeImports === "ban" && !isAllowedSource(source, allowedImportSources)) {
+            context.report({
+              node: declaration,
+              messageId: "runtimeImport",
+              data: { source }
+            });
+          }
         }
-      }
-    }],
-    messages: {
-      runtimeValue: "Types files must not contain runtime value {{name}}."
-    }
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const { allow = [] } = optionsFirst(context, {});
         for (const statement of program.body) {
+          if (banReExports && (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbientFile)) {
+            context.report({
+              node: statement,
+              messageId: "runtimeReExport"
+            });
+          }
           const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
           if (!declaration) {
             continue;
@@ -1705,6 +3178,36 @@ var noRuntimeInTypes = defineRule18({
             }
             continue;
           }
+          if (declaration.type === "TSModuleDeclaration") {
+            if (runtimeInTypesNamespaceIsRuntime(declaration, isAmbientFile, valueNames)) {
+              context.report({
+                node: declaration,
+                messageId: "runtimeValue",
+                data: { name: runtimeInTypesModuleName(declaration) }
+              });
+            }
+            continue;
+          }
+          if (statement.type === "TSExportAssignment" && !allow.includes("default")) {
+            const expression = runtimeInTypesExportAssignmentExpression(statement);
+            if (expression.type !== "Identifier" || valueNames.has(expression.name)) {
+              context.report({
+                node: statement,
+                messageId: "runtimeValue",
+                data: { name: expression.type === "Identifier" ? expression.name : "default" }
+              });
+            }
+            continue;
+          }
+          const importEquals = importEqualsDeclaration(statement);
+          if (!isAmbientFile && importEquals && runtimeInTypesIsInternalValueAlias(importEquals, valueNames)) {
+            context.report({
+              node: importEquals,
+              messageId: "runtimeValue",
+              data: { name: importEquals.id.name }
+            });
+            continue;
+          }
           if (!allow.includes("default") && statement.type === "ExportDefaultDeclaration" && declaration.type !== "TSInterfaceDeclaration" && declaration.type !== "TSTypeAliasDeclaration") {
             context.report({
               node: statement,
@@ -1719,7 +3222,7 @@ var noRuntimeInTypes = defineRule18({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -1753,7 +3256,7 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options,
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
   return Boolean(method && options.methods.includes(method) && schemasElements(call).includes(identifier));
 }
-var noSingleUseScalarSchema = defineRule19({
+var noSingleUseScalarSchema = defineRule28({
   meta: {
     type: "suggestion",
     schema: [{
@@ -1821,8 +3324,8 @@ var noSingleUseScalarSchema = defineRule19({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule20({
+import { defineRule as defineRule29 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule29({
   meta: {
     type: "problem",
     schema: [{
@@ -1879,15 +3382,43 @@ var noTopLevelFunctions = defineRule20({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var noTrivialFunctions = defineRule21({
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+function forwardedExpression(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return node.body;
+  }
+  if (!node.body || node.body.type !== "BlockStatement") {
+    return null;
+  }
+  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  if (statements.length !== 1) {
+    return null;
+  }
+  const statement = statements[0];
+  if (statement.type === "ReturnStatement") {
+    return statement.argument;
+  }
+  return statement.type === "ExpressionStatement" ? statement.expression : null;
+}
+function forwardedCall(expression) {
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "ChainExpression") {
+    return forwardedCall(expression.expression);
+  }
+  if (expression.type === "AwaitExpression") {
+    return forwardedCall(expression.argument);
+  }
+  return expression.type === "CallExpression" ? expression : null;
+}
+var noTrivialFunctions = defineRule30({
   meta: {
     type: "problem",
     schema: [{
       type: "object",
       additionalProperties: false,
       properties: {
-        allowPattern: { type: "string" }
+        allowPattern: { type: "string" },
+        allowCallees: { type: "array", items: { type: "string" } },
+        allowAsync: { type: "boolean" }
       }
     }],
     messages: {
@@ -1895,16 +3426,29 @@ var noTrivialFunctions = defineRule21({
     }
   },
   createOnce(context) {
+    let allowed = null;
+    let allowedCallees = [];
+    let allowAsync = false;
     return {
+      before() {
+        const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = optionsFirst(context, {});
+        allowed = allowPattern ? new RegExp(allowPattern) : null;
+        allowedCallees = calleePatterns.map((pattern) => new RegExp(pattern));
+        allowAsync = asyncAllowed;
+      },
       Program(program) {
-        const { allowPattern } = optionsFirst(context, {});
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
         const seen = new Set;
         for (const item of [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)]) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
           if (seen.has(key) || allowed?.test(item.name) || !declarationsIsTrivialFunction(item.node)) {
             continue;
           }
+          const expression = forwardedExpression(item.node);
+          const call = expression && forwardedCall(expression);
+          const path = call && astDottedName(call.callee);
+          if (allowAsync && item.node.async && call || path && allowedCallees.some((pattern) => pattern.test(path))) {
+            continue;
+          }
           seen.add(key);
           context.report({
             node: item.node,
@@ -1918,8 +3462,8 @@ var noTrivialFunctions = defineRule21({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule22({
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule31({
   meta: {
     type: "problem",
     schema: [{
@@ -1934,28 +3478,31 @@ var noTypeDeclarations = defineRule22({
     }
   },
   createOnce(context) {
+    let allowed = null;
+    function check(node) {
+      if (allowed?.test(node.id.name)) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "typeDeclaration",
+        data: { name: node.id.name }
+      });
+    }
     return {
-      Program(program) {
+      before() {
         const { allowPattern } = optionsFirst(context, {});
-        const allowed = allowPattern ? new RegExp(allowPattern) : null;
-        for (const item of declarationsCollectNamed(program)) {
-          if (item.node.type !== "TSTypeAliasDeclaration" && item.node.type !== "TSInterfaceDeclaration" || allowed?.test(item.name)) {
-            continue;
-          }
-          context.report({
-            node: item.node,
-            messageId: "typeDeclaration",
-            data: { name: item.name }
-          });
-        }
-      }
+        allowed = allowPattern ? new RegExp(allowPattern) : null;
+      },
+      TSTypeAliasDeclaration: check,
+      TSInterfaceDeclaration: check
     };
   }
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule23({
+import { defineRule as defineRule32 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule32({
   meta: {
     type: "problem",
     schema: [{
@@ -2000,31 +3547,150 @@ var noUnescapedLike = defineRule23({
   }
 });
 
+// src/rules/object-multiline.ts
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+function objectMultilineIsCallArg(node) {
+  const parent = node.parent;
+  return (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node);
+}
+function objectMultilineIsWhitespace(text) {
+  return /^[\t\n\r\f ]*$/.test(text);
+}
+function objectMultilineGaps(text, node) {
+  const gaps = [];
+  const close = node.range[1] - 1;
+  const first = node.properties[0];
+  if (!objectMultilineIsWhitespace(text.slice(node.range[0] + 1, first.range[0]))) {
+    return null;
+  }
+  gaps.push([node.range[0] + 1, first.range[0]]);
+  for (let index = 0;index < node.properties.length; index++) {
+    const property = node.properties[index];
+    const next = node.properties[index + 1];
+    const after = property.range[1];
+    const limit = next ? next.range[0] : close;
+    const between = text.slice(after, limit);
+    const comma = between.indexOf(",");
+    if (comma === -1) {
+      if (next || !objectMultilineIsWhitespace(between)) {
+        return null;
+      }
+      gaps.push([after, close]);
+      continue;
+    }
+    if (!objectMultilineIsWhitespace(between.slice(0, comma)) || !objectMultilineIsWhitespace(between.slice(comma + 1))) {
+      return null;
+    }
+    gaps.push([after + comma + 1, limit]);
+  }
+  return gaps;
+}
+var objectMultiline = defineRule33({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        minProperties: { type: "integer", minimum: 1, default: 3 },
+        scope: { type: "string", enum: ["call-args", "all"], default: "call-args" },
+        indent: { ...layoutIndentSchema, default: 2 }
+      }
+    }],
+    messages: {
+      callArgs: "Object with {{min}}+ properties in a call should have each property on its own line.",
+      always: "Object with {{min}}+ properties should have each property on its own line."
+    }
+  },
+  createOnce(context) {
+    let minProperties = 3;
+    let scope = "call-args";
+    let indentUnit = layoutIndentUnit();
+    let newline = `
+`;
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        minProperties = options.minProperties ?? 3;
+        scope = options.scope ?? "call-args";
+        indentUnit = layoutIndentUnit(options.indent);
+        newline = layoutNewline(context.sourceCode.text);
+      },
+      ObjectExpression(node) {
+        if (node.properties.length < minProperties || node.loc.start.line !== node.loc.end.line) {
+          return;
+        }
+        if (scope === "call-args" && !objectMultilineIsCallArg(node)) {
+          return;
+        }
+        const source = context.sourceCode;
+        const gaps = source.getCommentsInside(node).length > 0 ? null : objectMultilineGaps(source.text, node);
+        const baseIndent = layoutLineIndent(source.text, node.range[0]);
+        const propIndent = `${baseIndent}${indentUnit}`;
+        context.report({
+          node,
+          messageId: scope === "all" ? "always" : "callArgs",
+          data: { min: String(minProperties) },
+          fix(fixer) {
+            if (!gaps) {
+              return null;
+            }
+            return gaps.map((gap, index) => fixer.replaceTextRange(gap, `${newline}${index === gaps.length - 1 ? baseIndent : propIndent}`));
+          }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/only-export-components.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule24({
+import { defineRule as defineRule34 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule34({
   meta: {
     type: "problem",
     schema: [{
       type: "object",
       additionalProperties: false,
       properties: {
-        matchFileName: { type: "boolean" }
+        matchFileName: { type: "boolean" },
+        allowTypeExports: { type: "boolean" },
+        denyTypePattern: { type: "string" }
       }
     }],
     messages: {
       nonComponent: "Export '{{name}}' must be a React component or type.",
-      nameMismatch: "Component export '{{name}}' must match '{{expected}}' or its prefix."
+      nameMismatch: "Component export '{{name}}' must match '{{expected}}' or its prefix.",
+      typeExport: "Type export '{{name}}' is not allowed.",
+      deniedType: "Type export '{{name}}' is denied by denyTypePattern."
     }
   },
   createOnce(context) {
     return {
       Program(program) {
-        const { matchFileName = true } = optionsFirst(context, {});
+        const {
+          matchFileName = true,
+          allowTypeExports = true,
+          denyTypePattern
+        } = optionsFirst(context, {});
         const expected = reactComponentsPascalFromBasename(namingFileBasename(context.filename));
+        const denied = denyTypePattern ? new RegExp(denyTypePattern) : null;
         const components = [];
         for (const candidate of reactComponentsExportCandidates(program)) {
           if (candidate.typeOnly) {
+            if (!allowTypeExports) {
+              context.report({
+                node: candidate.node,
+                messageId: "typeExport",
+                data: { name: candidate.name, expected }
+              });
+            } else if (denied?.test(candidate.name)) {
+              context.report({
+                node: candidate.node,
+                messageId: "deniedType",
+                data: { name: candidate.name, expected }
+              });
+            }
             continue;
           }
           if (!reactComponentsIsLike(program, candidate)) {
@@ -2058,7 +3724,7 @@ var onlyExportComponents = defineRule24({
 });
 
 // src/rules/only-export-constants.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } from "@oxlint/plugins";
 function bindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
@@ -2113,7 +3779,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var onlyExportConstants = defineRule25({
+var onlyExportConstants = defineRule35({
   meta: {
     type: "problem",
     schema: [{
@@ -2194,9 +3860,128 @@ var onlyExportConstants = defineRule25({
   }
 });
 
+// src/rules/padding-between-statements.ts
+import { defineRule as defineRule36 } from "@oxlint/plugins";
+function paddingKind(node) {
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+    return node.declaration ? paddingKind(node.declaration) : "other";
+  }
+  switch (node.type) {
+    case "VariableDeclaration":
+      return "variable";
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      return "block";
+    case "IfStatement":
+    case "ForStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+    case "WhileStatement":
+    case "DoWhileStatement":
+    case "SwitchStatement":
+    case "TryStatement":
+      return "control";
+    case "ReturnStatement":
+      return "return";
+    default:
+      return "other";
+  }
+}
+function paddingHasBlankLine(gap) {
+  const lines = gap.split(`
+`);
+  for (let index = 1;index < lines.length - 1; index++) {
+    if (/^[\t\r ]*$/.test(lines[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+function paddingBlankLineFix(sourceText, comments, prev, curr, newline) {
+  const gap = sourceText.slice(prev.range[1], curr.range[0]);
+  const match = /\r?\n/.exec(gap);
+  if (!match) {
+    return null;
+  }
+  const newlineStart = prev.range[1] + match.index;
+  const newlineEnd = newlineStart + match[0].length;
+  if (comments.some((comment) => comment.range[0] < newlineEnd && comment.range[1] > newlineStart)) {
+    return null;
+  }
+  if (comments.some((comment) => comment.loc.start.line === prev.loc.end.line && /^\s*[A-Za-z][\w-]*-disable-next-line\b/.test(commentsNormalizedValue(comment)))) {
+    return null;
+  }
+  return { newlineEnd, newline };
+}
+var paddingBetweenStatements = defineRule36({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        returnMinStatements: { type: "integer", minimum: 1, default: 3 }
+      }
+    }],
+    messages: {
+      variableAndBlock: "Expected a blank line between a variable declaration and a function/class.",
+      beforeBlock: "Expected a blank line before a function/class declaration.",
+      afterBlock: "Expected a blank line after a function/class declaration.",
+      variableAndControl: "Expected a blank line between a variable declaration and control flow.",
+      controlAndVariable: "Expected a blank line between control flow and a variable declaration.",
+      consecutiveControl: "Expected a blank line between control flow statements.",
+      beforeReturn: "Expected a blank line before return statement."
+    }
+  },
+  createOnce(context) {
+    let returnMinStatements = 3;
+    let newline = `
+`;
+    let source;
+    function checkStatements(statements) {
+      for (let index = 1;index < statements.length; index++) {
+        const prev = statements[index - 1];
+        const curr = statements[index];
+        const gap = source.text.slice(prev.range[1], curr.range[0]);
+        if (!/\r?\n/.test(gap) || paddingHasBlankLine(gap)) {
+          continue;
+        }
+        const prevKind = paddingKind(prev);
+        const currKind = paddingKind(curr);
+        const messageId = prevKind === "variable" && currKind === "block" || prevKind === "block" && currKind === "variable" ? "variableAndBlock" : currKind === "block" ? "beforeBlock" : prevKind === "block" ? "afterBlock" : prevKind === "variable" && currKind === "control" ? "variableAndControl" : prevKind === "control" && currKind === "variable" ? "controlAndVariable" : prevKind === "control" && currKind === "control" ? "consecutiveControl" : currKind === "return" && prevKind !== "variable" && statements.length >= returnMinStatements ? "beforeReturn" : null;
+        if (!messageId) {
+          continue;
+        }
+        const comments = source.getCommentsAfter(prev).filter((comment) => comment.range[1] <= curr.range[0]);
+        const insert = paddingBlankLineFix(source.text, comments, prev, curr, newline);
+        context.report({
+          node: curr,
+          messageId,
+          fix: insert ? (fixer) => fixer.insertTextAfterRange([insert.newlineEnd, insert.newlineEnd], insert.newline) : undefined
+        });
+      }
+    }
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        returnMinStatements = options.returnMinStatements ?? 3;
+        source = context.sourceCode;
+        newline = layoutNewline(source.text);
+      },
+      Program(node) {
+        checkStatements(node.body);
+      },
+      BlockStatement(node) {
+        checkStatements(node.body);
+      }
+    };
+  }
+});
+
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
-var requireFileFactory = defineRule26({
+import { defineRule as defineRule37 } from "@oxlint/plugins";
+var requireFileFactory = defineRule37({
   meta: {
     type: "problem",
     schema: [{
@@ -2242,24 +4027,46 @@ var requireFileFactory = defineRule26({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
-var requireObjectParams = defineRule27({
+import { defineRule as defineRule38 } from "@oxlint/plugins";
+var requireObjectParams = defineRule38({
   meta: {
     type: "problem",
-    schema: [],
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxParams: { type: "integer", minimum: 1 },
+        allDeclarations: { type: "boolean" },
+        allowPattern: { type: "string" }
+      }
+    }],
     messages: {
-      objectParams: "Exported function {{name}} must accept at most one object parameter."
+      objectParams: "{{label}} {{name}} must accept at most {{maxParams}} object parameter{{s}}."
     }
   },
   createOnce(context) {
     return {
       Program(program) {
-        for (const item of exportsCollectFunctions(program)) {
-          if (item.node.params.length > 1 || item.node.params.some((param) => !declarationsIsObjectParam(param))) {
+        const { maxParams = 1, allDeclarations = false, allowPattern } = optionsFirst(context, {});
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const seen = new Set;
+        const functions = allDeclarations ? [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)] : exportsCollectFunctions(program);
+        for (const item of functions) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`;
+          if (seen.has(key) || allowed?.test(item.name)) {
+            continue;
+          }
+          seen.add(key);
+          if (item.node.params.length > maxParams || item.node.params.some((param) => !declarationsIsObjectParam(param))) {
             context.report({
               node: item.node,
               messageId: "objectParams",
-              data: { name: item.name }
+              data: {
+                label: allDeclarations ? "Function" : "Exported function",
+                name: item.name,
+                maxParams: maxParams === 1 ? "one" : String(maxParams),
+                s: maxParams === 1 ? "" : "s"
+              }
             });
           }
         }
@@ -2269,8 +4076,8 @@ var requireObjectParams = defineRule27({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule28({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule39({
   meta: {
     type: "problem",
     schema: [{
@@ -2312,8 +4119,8 @@ var requireOrpcOutput = defineRule28({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
-var requirePairedCall = defineRule29({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requirePairedCall = defineRule40({
   meta: {
     type: "problem",
     schema: [{
@@ -2321,9 +4128,24 @@ var requirePairedCall = defineRule29({
       additionalProperties: false,
       properties: {
         when: { type: "string" },
-        require: { type: "string" }
+        require: { type: "string" },
+        pairs: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              when: { type: "string" },
+              require: { type: "string" }
+            },
+            required: ["when", "require"]
+          }
+        }
       },
-      required: ["when", "require"]
+      anyOf: [
+        { required: ["when", "require"] },
+        { required: ["pairs"] }
+      ]
     }],
     messages: {
       paired: "{{when}} requires a call to {{require}} in the same file."
@@ -2331,45 +4153,50 @@ var requirePairedCall = defineRule29({
   },
   createOnce(context) {
     let aliases = new Map;
-    let firstWhen = null;
-    let sawRequired = false;
+    let pairs = [];
     return {
       before() {
+        const options = optionsFirst(context);
+        const configured = [
+          ...options.when && options.require ? [{ when: options.when, require: options.require }] : [],
+          ...options.pairs ?? []
+        ];
         aliases = new Map;
-        firstWhen = null;
-        sawRequired = false;
+        pairs = configured.map((pair) => ({ ...pair, firstWhen: null, sawRequired: false }));
       },
       Program(program) {
         aliases = astImportedCallAliases(program);
       },
       CallExpression(node) {
-        const { when, require: require2 } = optionsFirst(context);
         const name = astResolvedCallName(node, aliases);
-        if (name === when && !firstWhen) {
-          firstWhen = node;
-        }
-        if (name === require2) {
-          sawRequired = true;
+        for (const pair of pairs) {
+          if (name === pair.when && !pair.firstWhen) {
+            pair.firstWhen = node;
+          }
+          if (name === pair.require) {
+            pair.sawRequired = true;
+          }
         }
       },
       after() {
-        if (!firstWhen || sawRequired) {
-          return;
+        for (const pair of pairs) {
+          if (!pair.firstWhen || pair.sawRequired) {
+            continue;
+          }
+          context.report({
+            node: pair.firstWhen,
+            messageId: "paired",
+            data: { when: pair.when, require: pair.require }
+          });
         }
-        const { when, require: require2 } = optionsFirst(context);
-        context.report({
-          node: firstWhen,
-          messageId: "paired",
-          data: { when, require: require2 }
-        });
       }
     };
   }
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
-var routeSurface = defineRule30({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var routeSurface = defineRule41({
   meta: {
     type: "problem",
     schema: [{
@@ -2410,25 +4237,140 @@ var routeSurface = defineRule30({
   }
 });
 
+// src/rules/test-title-pattern.ts
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "todo", "each"]);
+function isConfiguredName(name, callees) {
+  if (!name) {
+    return false;
+  }
+  return callees.some((callee) => {
+    if (name === callee) {
+      return true;
+    }
+    if (!name.startsWith(`${callee}.`)) {
+      return false;
+    }
+    return name.slice(callee.length + 1).split(".").every((part) => TEST_MODIFIERS.has(part));
+  });
+}
+function isConfiguredCall(node, callees) {
+  if (isConfiguredName(astDottedName(node.callee), callees)) {
+    return true;
+  }
+  if (node.callee.type === "CallExpression") {
+    return isConfiguredName(astDottedName(node.callee.callee), callees);
+  }
+  return node.callee.type === "TaggedTemplateExpression" && isConfiguredName(astDottedName(node.callee.tag), callees);
+}
+function titleText(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+  }
+}
+function regexMatches(regex, value) {
+  regex.lastIndex = 0;
+  return regex.test(value);
+}
+var testTitlePattern = defineRule42({
+  meta: {
+    type: "suggestion",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        callees: { type: "array", items: { type: "string" } },
+        forbid: { type: "string" },
+        require: { type: "string" },
+        flags: { type: "string", pattern: "^[dgimsuvy]*$" }
+      }
+    }],
+    defaultOptions: [{
+      callees: ["describe", "it", "test"],
+      flags: ""
+    }],
+    messages: {
+      forbidden: "Test title matches forbidden pattern '{{pattern}}'.",
+      required: "Test title must match required pattern '{{pattern}}'."
+    }
+  },
+  createOnce(context) {
+    let callees = [];
+    let forbid;
+    let required;
+    return {
+      before() {
+        const options = optionsFirst(context);
+        callees = options.callees;
+        const flags = options.flags ?? "";
+        forbid = options.forbid === undefined ? undefined : { regex: new RegExp(options.forbid, flags), pattern: options.forbid };
+        required = options.require === undefined ? undefined : { regex: new RegExp(options.require, flags), pattern: options.require };
+        if (forbid === undefined && required === undefined) {
+          return false;
+        }
+      },
+      CallExpression(node) {
+        if (!isConfiguredCall(node, callees)) {
+          return;
+        }
+        const title = node.arguments[0];
+        if (!title) {
+          return;
+        }
+        const text = titleText(title);
+        if (text === undefined) {
+          return;
+        }
+        if (forbid && regexMatches(forbid.regex, text)) {
+          context.report({
+            node: title,
+            messageId: "forbidden",
+            data: { pattern: forbid.pattern }
+          });
+        }
+        if (required && !regexMatches(required.regex, text)) {
+          context.report({
+            node: title,
+            messageId: "required",
+            data: { pattern: required.pattern }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/index.ts
 var src_default = eslintCompatPlugin({
   meta: { name: "arch" },
   rules: {
+    "call-array-multiline": callArrayMultiline,
+    "chain-newline": chainNewline,
     "declaration-name": declarationName,
     "export-file-prefix": exportFilePrefix,
     "export-name-pattern": exportNamePattern,
     "filename-export-name": filenameExportName,
     "filename-match": filenameMatch,
     "folder-prefix": folderPrefix,
+    "jsx-attributes-multiline": jsxAttributesMultiline,
+    "key-value-same-line": keyValueSameLine,
+    "no-comments": noComments,
     "no-extra-exports": noExtraExports,
     "no-extra-factory-keys": noExtraFactoryKeys,
     "no-file-level-helpers": noFileLevelHelpers,
     "no-imported-type-alias": noImportedTypeAlias,
     "no-inline-schema-elements": noInlineSchemaElements,
     "no-inline-types": noInlineTypes,
+    "no-literal-in": noLiteralIn,
     "no-local-schema-construction": noLocalSchemaConstruction,
     "no-member-comments": noMemberComments,
+    "no-module-mutable-state": noModuleMutableState,
+    "no-promise-all-mutation": noPromiseAllMutation,
     "no-rederive-schema": noRederiveSchema,
+    "no-restricted-constructor": noRestrictedConstructor,
     "no-restricted-files": noRestrictedFiles,
     "no-restricted-token": noRestrictedToken,
     "no-runtime-in-types": noRuntimeInTypes,
@@ -2437,13 +4379,16 @@ var src_default = eslintCompatPlugin({
     "no-trivial-functions": noTrivialFunctions,
     "no-type-declarations": noTypeDeclarations,
     "no-unescaped-like": noUnescapedLike,
+    "object-multiline": objectMultiline,
     "only-export-components": onlyExportComponents,
     "only-export-constants": onlyExportConstants,
+    "padding-between-statements": paddingBetweenStatements,
     "require-file-factory": requireFileFactory,
     "require-object-params": requireObjectParams,
     "require-orpc-output": requireOrpcOutput,
     "require-paired-call": requirePairedCall,
-    "route-surface": routeSurface
+    "route-surface": routeSurface,
+    "test-title-pattern": testTitlePattern
   }
 });
 export {