oxlint-plugin-arch 0.4.0 → 0.6.0

package/dist/index.js

@@ -5,16 +5,7 @@ import { eslintCompatPlugin } from "@oxlint/plugins";
 import { defineRule } from "@oxlint/plugins";
 
 // src/utils/helpers/ast.ts
-var astVisitSkip = new Set([
-  "parent",
-  "type",
-  "start",
-  "end",
-  "range",
-  "loc",
-  "tokens",
-  "comments"
-]);
+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";
 }
@@ -103,6 +94,75 @@ function astResolvedCallName(node, aliases) {
   const name = astCallName(node);
   return name ? aliases.get(name) ?? 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/trivial.ts
+function trivialExpression(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 trivialUnwrap(expression) {
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "ChainExpression") {
+    return trivialUnwrap(expression.expression);
+  }
+  return expression.type === "AwaitExpression" ? trivialUnwrap(expression.argument) : expression;
+}
+function trivialCallRoot(expression) {
+  if (expression.type === "Identifier")
+    return expression.name;
+  if (expression.type === "MemberExpression" && !expression.computed && !expression.optional) {
+    return trivialCallRoot(expression.object);
+  }
+  return;
+}
+function trivialIsForwarder(node, expression) {
+  const value = trivialUnwrap(expression);
+  if (value.type === "Literal")
+    return !("regex" in value);
+  if (value.type === "TemplateLiteral")
+    return value.expressions.length === 0;
+  if (value.type === "Identifier")
+    return true;
+  if (value.type !== "CallExpression" || value.optional)
+    return false;
+  const root = trivialCallRoot(value.callee);
+  if (!root || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const parameters = node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : []);
+  const arguments_ = value.arguments;
+  const receiver = value.callee.type === "MemberExpression" ? root : undefined;
+  const forwarded = parameters.filter((name) => name !== receiver);
+  return arguments_.length === forwarded.length && arguments_.every((argument, index) => argument.type === "Identifier" && argument.name === forwarded[index]);
+}
+
 // src/utils/helpers/declarations.ts
 function declarationsTopLevelUnexportedFunctions(program) {
   return program.body.flatMap((statement) => {
@@ -284,6 +344,21 @@ function declarationsCollectFunctions(root) {
     return [];
   });
 }
+function declarationsPublicServiceMethods(program) {
+  return program.body.flatMap((statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration" || statement.declaration.kind !== "const")
+      return [];
+    return statement.declaration.declarations.flatMap((binding) => {
+      if (binding.id.type !== "Identifier" || !binding.init)
+        return [];
+      const value = trivialUnwrap(binding.init);
+      if (value.type !== "ObjectExpression" || value.properties.length === 0)
+        return [];
+      const methods = value.properties.flatMap((property) => property.type === "Property" && property.method && property.kind === "init" && !property.computed && property.key.type === "Identifier" && property.value.type === "FunctionExpression" ? [{ name: property.key.name, node: property.value, binding }] : []);
+      return methods.length === value.properties.length ? methods : [];
+    });
+  });
+}
 // src/utils/helpers/exports.ts
 function moduleExportName(node) {
   return node.type === "Identifier" ? node.name : node.value;
@@ -305,15 +380,17 @@ function declarationBindings(declaration) {
     }));
   }
   const name = declaration.id?.name ?? "<anonymous>";
-  return [{
-    exportedName: name,
-    localName: declaration.id?.name,
-    node: declaration,
-    declaration,
-    typeOnly: declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSDeclareFunction",
-    default: false,
-    reExport: false
-  }];
+  return [
+    {
+      exportedName: name,
+      localName: declaration.id?.name,
+      node: declaration,
+      declaration,
+      typeOnly: declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSDeclareFunction",
+      default: false,
+      reExport: false
+    }
+  ];
 }
 function localBindings(program) {
   const result = new Map;
@@ -335,29 +412,33 @@ function exportsCollect(program) {
   const locals = localBindings(program);
   return program.body.flatMap((statement) => {
     if (statement.type === "ExportAllDeclaration") {
-      return [{
-        exportedName: "*",
-        node: statement,
-        typeOnly: statement.exportKind === "type",
-        default: false,
-        reExport: true
-      }];
+      return [
+        {
+          exportedName: "*",
+          node: statement,
+          typeOnly: statement.exportKind === "type",
+          default: false,
+          reExport: true
+        }
+      ];
     }
     if (statement.type === "ExportDefaultDeclaration") {
       if (statement.declaration.type === "Identifier") {
         const local = locals.get(statement.declaration.name);
-        return [{
-          ...local ?? {
+        return [
+          {
+            ...local ?? {
+              exportedName: "default",
+              node: statement,
+              typeOnly: false,
+              default: true,
+              reExport: false
+            },
             exportedName: "default",
-            node: statement,
-            typeOnly: false,
-            default: true,
-            reExport: false
-          },
-          exportedName: "default",
-          localName: local?.localName ?? statement.declaration.name,
-          default: true
-        }];
+            localName: local?.localName ?? statement.declaration.name,
+            default: true
+          }
+        ];
       }
       if (statement.declaration.type.endsWith("Declaration")) {
         const bindings = declarationBindings(statement.declaration);
@@ -464,7 +545,7 @@ function namingMatchTemplate(basename, template, placeholderPattern = "[a-z0-9-]
 }
 var namingStemModes = ["before-first-dot", "full-basename"];
 function namingNormalized(value, normalize) {
-  return normalize === "none" ? value : value.replaceAll(/[-_]/g, "").toLowerCase();
+  return normalize === "none" ? value : value.replaceAll(/[-_.]/g, "").toLowerCase();
 }
 function namingFileStem(basename, mode = "before-first-dot", trailingRoles = [], roleSeparators = [".", "-"]) {
   const stem = mode === "full-basename" ? basename : basename.split(".")[0] ?? "";
@@ -504,13 +585,16 @@ function namingFilePrefixes(stem, normalize = "remove-separators", singularize =
 }
 
 // src/utils/helpers/factories.ts
-function factoriesExpandTemplate(template, groups) {
+function factoriesExpandTemplate(template, groups, camelCase = false) {
   return template.replaceAll(/\{([^}]+)\}/g, (placeholder, key) => {
     const group = groups[key.toLowerCase()];
     if (!group) {
       return placeholder;
     }
-    return /^[A-Z]/.test(key) ? namingPascalCase(group) : group;
+    if (/^[A-Z]/.test(key)) {
+      return namingPascalCase(group);
+    }
+    return camelCase ? namingCamelCase(group) : group;
   });
 }
 function factoriesCollectTopLevel(program, pattern) {
@@ -547,15 +631,130 @@ function factoriesObjectPropertyName(property) {
   }
   return property.key.type === "Literal" && typeof property.key.value === "string" ? property.key.value : undefined;
 }
+// src/utils/helpers/guards.ts
+var guardsPrimitiveNames = new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "undefined",
+  "bigint",
+  "symbol",
+  "function"
+]);
+function guardsValue(node, state) {
+  const value = trivialUnwrap(node);
+  if (value.type === "Identifier")
+    return state.values.has(value.name);
+  return value.type === "MemberExpression" && value.computed && value.object.type === "Identifier" && state.values.has(value.object.name) && value.property.type === "Identifier" && state.values.has(value.property.name);
+}
+function guardsFallback(node) {
+  return node.type === "Literal" && !("regex" in node) || node.type === "Identifier" && node.name === "undefined" || node.type === "ArrayExpression" && node.elements.length === 0 || node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function guardsPredicate(expression, state) {
+  const node = trivialUnwrap(expression);
+  if (node.type === "Identifier")
+    return state.predicates.has(node.name);
+  if (node.type === "UnaryExpression" && node.operator === "!")
+    return guardsPredicate(node.argument, state);
+  if (node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||")) {
+    return guardsPredicate(node.left, state) && guardsPredicate(node.right, state);
+  }
+  if (node.type === "BinaryExpression" && ["===", "!==", "==", "!="].includes(node.operator)) {
+    for (const [left, right] of [
+      [node.left, node.right],
+      [node.right, node.left]
+    ]) {
+      if (left.type === "UnaryExpression" && left.operator === "typeof" && right.type === "Literal" && typeof right.value === "string" && guardsPrimitiveNames.has(right.value) && guardsValue(left.argument, state)) {
+        state.primitive = true;
+        return true;
+      }
+      if (left.type !== "PrivateIdentifier" && guardsValue(left, state) && (right.type === "Literal" && right.value === null || right.type === "Identifier" && right.name === "undefined"))
+        return true;
+    }
+  }
+  if (node.type === "CallExpression" && !node.optional && node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement" && guardsValue(node.arguments[0], state) && node.callee.type === "MemberExpression" && !node.callee.computed && !node.callee.optional && node.callee.object.type === "Identifier" && node.callee.object.name === "Array" && node.callee.property.type === "Identifier" && node.callee.property.name === "isArray" && state.globalArray(node.callee.object)) {
+    state.primitive = true;
+    return true;
+  }
+  return false;
+}
+function guardsResult(node, state) {
+  const value = trivialUnwrap(node);
+  if (guardsValue(value, state) || guardsFallback(value) || guardsPredicate(value, state))
+    return true;
+  return value.type === "ConditionalExpression" && guardsPredicate(value.test, state) && guardsResult(value.consequent, state) && guardsResult(value.alternate, state);
+}
+function guardsStatement(node, state) {
+  if (node.type === "EmptyStatement" || node.type === "ExpressionStatement" && Boolean(node.directive))
+    return true;
+  if (node.type === "ReturnStatement" && node.argument) {
+    state.returned = true;
+    return guardsResult(node.argument, state);
+  }
+  if (node.type === "BlockStatement")
+    return node.body.every((statement) => guardsStatement(statement, state));
+  if (node.type === "IfStatement") {
+    return guardsPredicate(node.test, state) && guardsStatement(node.consequent, state) && (!node.alternate || guardsStatement(node.alternate, state));
+  }
+  if (node.type === "VariableDeclaration" && node.kind === "const") {
+    return node.declarations.every((declaration) => {
+      if (declaration.id.type !== "Identifier" || !declaration.init)
+        return false;
+      if (guardsValue(declaration.init, state)) {
+        state.values.add(declaration.id.name);
+        return true;
+      }
+      if (guardsPredicate(declaration.init, state)) {
+        state.predicates.add(declaration.id.name);
+        return true;
+      }
+      return guardsFallback(declaration.init);
+    });
+  }
+  return false;
+}
+function guardsIsGenericHelper(node, globalArray) {
+  if (!node.body || node.params.length === 0 || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const state = {
+    values: new Set(node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : [])),
+    predicates: new Set,
+    primitive: false,
+    returned: false,
+    globalArray
+  };
+  if (node.body.type !== "BlockStatement")
+    return guardsResult(node.body, state) && state.primitive;
+  return node.body.body.every((statement) => guardsStatement(statement, state)) && state.primitive && state.returned;
+}
+// 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/utils/helpers/options.ts
 function optionsFirst(context, fallback) {
   return context.options[0] ?? fallback;
 }
 var optionsPatternSchema = {
-  anyOf: [
-    { type: "string" },
-    { type: "array", items: { type: "string" }, minItems: 1 }
-  ]
+  anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, minItems: 1 }]
 };
 function optionsPatterns(pattern, flags) {
   return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
@@ -774,46 +973,13 @@ 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/utils/helpers/boundaries.ts
+import { resolve, dirname } from "node:path";
+function boundaryResolveTarget(options, file, source) {
+  const owner = [...options.web, ...options.backend].sort((a, b) => b.length - a.length).find((root) => file.startsWith(root + "/"));
+  const web = owner && options.web.includes(owner) ? owner : undefined;
+  const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
+  return alias ? resolve(alias[1], source.slice(alias[0].length).replace(/^\//, "")).replaceAll("\\", "/") : source.startsWith(".") ? resolve(dirname(file), source).replaceAll("\\", "/") : source.startsWith("@/") && web ? `${web}/${source.slice(2)}` : source.startsWith("#/") && owner ? `${owner}/${source.slice(2)}` : source.startsWith("#services/") && owner ? `${owner}/services/${source.slice(10)}` : source;
 }
 // src/rules/call-array-multiline.ts
 function callArrayMultilineCallee(node) {
@@ -886,15 +1052,17 @@ 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
-      }
-    }],
+    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."
     }
@@ -983,28 +1151,30 @@ 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: optionsPatternSchema
-            },
-            required: ["minDepth"]
-          }
+    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: optionsPatternSchema
+              },
+              required: ["minDepth"]
+            }
+          },
+          indent: layoutIndentSchema
         },
-        indent: layoutIndentSchema
-      },
-      required: ["groups"]
-    }],
+        required: ["groups"]
+      }
+    ],
     messages: {
       newline: "Put every method in this call chain on its own line."
     }
@@ -1082,29 +1252,152 @@ var chainNewline = defineRule2({
   }
 });
 
-// src/rules/declaration-name.ts
+// src/rules/component-props.ts
 import { defineRule as defineRule3 } from "@oxlint/plugins";
-var declarationName = defineRule3({
+function unwrapExport(statement) {
+  return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+}
+function topLevelComponents(program) {
+  return program.body.flatMap((statement, index) => {
+    const declaration = unwrapExport(statement);
+    if (declaration?.type === "FunctionDeclaration" && declaration.id) {
+      return [{ candidate: { name: declaration.id.name, node: declaration, declaration }, index }];
+    }
+    if (declaration?.type !== "VariableDeclaration") {
+      return [];
+    }
+    return declaration.declarations.flatMap((item) => item.id.type === "Identifier" ? [{ candidate: { name: item.id.name, node: item, declaration, initializer: item.init }, index }] : []);
+  });
+}
+function propsTarget(node) {
+  if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
+    return { fn: node };
+  }
+  if (node?.type !== "CallExpression") {
+    return;
+  }
+  const name = astCallName(node);
+  const inner = name === "memo" || name === "forwardRef" ? propsTarget(node.arguments[0]) : undefined;
+  const typeArgument = name === "forwardRef" ? node.typeArguments?.params[1] : undefined;
+  return inner && typeArgument ? { ...inner, typeArgument } : inner;
+}
+function parameterType(parameter) {
+  if (parameter?.type === "AssignmentPattern") {
+    return parameterType(parameter.left);
+  }
+  return parameter && parameter.type !== "TSParameterProperty" ? parameter.typeAnnotation?.typeAnnotation : undefined;
+}
+function containsTypeLiteral(node) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    found ||= candidate.type === "TSTypeLiteral";
+  });
+  return found;
+}
+function isPassThrough(type) {
+  if (type.type !== "TSTypeReference") {
+    return false;
+  }
+  const { typeName } = type;
+  const name = typeName.type === "TSQualifiedName" ? typeName.right.name : typeName.type === "Identifier" ? typeName.name : "";
+  const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
+  return name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
+}
+var componentProps = defineRule3({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        kinds: {
-          type: "array",
-          items: { type: "string", enum: [...declarationsKinds] }
-        },
-        pattern: optionsPatternSchema,
-        flags: { type: "string" },
-        stem: { type: "string", enum: [...namingStemModes] },
-        trailingRoles: { type: "array", items: { type: "string" } },
-        roleSeparators: { type: "array", items: { type: "string" } },
-        normalize: { type: "string", enum: ["remove-separators", "none"] },
-        singularize: { type: "string", enum: ["none", "trailing-s"] },
-        allowPattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          filePrefix: { type: "boolean" }
+        }
+      }
+    ],
+    messages: {
+      inline: "'{{name}}' props are typed inline. Declare `interface {{expected}}` directly above it and use that.",
+      name: "'{{name}}' props must use `interface {{expected}}` declared directly above it, not '{{actual}}'.",
+      placement: "Move `interface {{expected}}` directly above '{{name}}', with only blank lines between them.",
+      rename: "Local component '{{name}}' would need `interface {{expected}}`, which breaks the file prefix '{{prefix}}'. Rename the component to start with '{{prefix}}' (for example '{{prefix}}Item')."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { filePrefix = false } = optionsFirst(context, {});
+        const stem = namingFileStem(namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, ""));
+        const exported = new Set(exportsCollect(program).flatMap((binding) => binding.typeOnly ? [] : [binding.localName]));
+        const interfaces = new Map(program.body.flatMap((statement, index) => {
+          const declaration = unwrapExport(statement);
+          return declaration?.type === "TSInterfaceDeclaration" ? [[declaration.id.name, index]] : [];
+        }));
+        for (const { candidate, index } of topLevelComponents(program)) {
+          const target = propsTarget(candidate.initializer ?? candidate.declaration);
+          const parameter = target?.fn.params[0];
+          if (!target || !parameter || !reactComponentsIsLike(program, candidate)) {
+            continue;
+          }
+          const type = target.typeArgument ?? parameterType(parameter);
+          const expected = `${candidate.name}Props`;
+          const data = { name: candidate.name, expected };
+          if (filePrefix && !exported.has(candidate.name) && !candidate.name.toLowerCase().startsWith(namingNormalized(stem, "remove-separators"))) {
+            context.report({ node: candidate.node, messageId: "rename", data: { ...data, prefix: namingPascalCase(stem) } });
+            continue;
+          }
+          if (type && containsTypeLiteral(type)) {
+            context.report({ node: type, messageId: "inline", data });
+            continue;
+          }
+          if (type && isPassThrough(type)) {
+            continue;
+          }
+          const declared = interfaces.get(expected);
+          if (declared === undefined || type?.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeName.name !== expected) {
+            context.report({
+              node: type ?? parameter,
+              messageId: "name",
+              data: { ...data, actual: type ? context.sourceCode.getText(type) : "untyped" }
+            });
+            continue;
+          }
+          const previous = program.body[declared];
+          const statement = program.body[index];
+          const between = previous && statement ? context.sourceCode.text.slice(previous.range[1], statement.range[0]) : "";
+          if (declared !== index - 1 || between.trim() !== "") {
+            context.report({ node: type, messageId: "placement", data });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/declaration-name.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var declarationName = defineRule4({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          kinds: {
+            type: "array",
+            items: { type: "string", enum: [...declarationsKinds] }
+          },
+          pattern: optionsPatternSchema,
+          flags: { type: "string" },
+          stem: { type: "string", enum: [...namingStemModes] },
+          trailingRoles: { type: "array", items: { type: "string" } },
+          roleSeparators: { type: "array", items: { type: "string" } },
+          normalize: { type: "string", enum: ["remove-separators", "none"] },
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
+          allowPattern: optionsPatternSchema
+        }
+      }
+    ],
     messages: {
       prefix: "'{{name}}' must start with file prefix '{{prefix}}'.",
       pattern: "'{{name}}' must match {{pattern}}."
@@ -1129,7 +1422,10 @@ var declarationName = defineRule3({
       context.report({
         node: item.node,
         messageId: expected.length > 0 ? "pattern" : "prefix",
-        data: expected.length > 0 ? { name: item.name, pattern: optionsPatternLabel([options.pattern ?? []].flat().filter((source) => source !== "")) } : { name: item.name, prefix: prefixes.join(" or ") }
+        data: expected.length > 0 ? {
+          name: item.name,
+          pattern: optionsPatternLabel([options.pattern ?? []].flat().filter((source) => source !== ""))
+        } : { name: item.name, prefix: prefixes.join(" or ") }
       });
     }
     return {
@@ -1156,23 +1452,27 @@ var declarationName = defineRule3({
 });
 
 // src/rules/export-file-prefix.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var exportFilePrefix = defineRule4({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var exportFilePrefix = defineRule5({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        stem: { type: "string", enum: [...namingStemModes] },
-        trailingRoles: { type: "array", items: { type: "string" } },
-        roleSeparators: { type: "array", items: { type: "string" } },
-        normalize: { type: "string", enum: ["remove-separators", "none"] },
-        singularize: { type: "string", enum: ["none", "trailing-s"] },
-        allDeclarations: { type: "boolean" },
-        allowPattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          stem: { type: "string", enum: [...namingStemModes] },
+          trailingRoles: { type: "array", items: { type: "string" } },
+          roleSeparators: { type: "array", items: { type: "string" } },
+          normalize: { type: "string", enum: ["remove-separators", "none"] },
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
+          serviceMethods: { type: "boolean" },
+          allFunctions: { type: "boolean" },
+          allDeclarations: { type: "boolean" },
+          allowPattern: optionsPatternSchema
+        }
+      }
+    ],
     messages: {
       prefix: "'{{name}}' must start with file prefix '{{prefix}}'."
     }
@@ -1192,6 +1492,12 @@ var exportFilePrefix = defineRule4({
           name: binding.localName ?? binding.exportedName,
           node: binding.node
         }));
+        if (options.allFunctions && !options.allDeclarations) {
+          const exportedNames = new Set(names.map((item) => item.name));
+          names.push(...declarationsCollectNamed(program).filter((item) => !exportedNames.has(item.name) && (item.node.type === "FunctionDeclaration" || item.node.type === "VariableDeclarator" && (item.node.init?.type === "ArrowFunctionExpression" || item.node.init?.type === "FunctionExpression"))));
+        }
+        if (options.serviceMethods)
+          names.push(...declarationsPublicServiceMethods(program));
         const seen = new Set;
         for (const item of names) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
@@ -1212,22 +1518,24 @@ var exportFilePrefix = defineRule4({
 });
 
 // src/rules/export-name-pattern.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var exportNamePattern = defineRule5({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var exportNamePattern = defineRule6({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        pattern: optionsPatternSchema,
-        flags: { type: "string" },
-        ignoreTypeExports: { type: "boolean" },
-        allDeclarations: { type: "boolean" },
-        allowPattern: optionsPatternSchema
-      },
-      required: ["pattern"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          pattern: optionsPatternSchema,
+          flags: { type: "string" },
+          ignoreTypeExports: { type: "boolean" },
+          allDeclarations: { type: "boolean" },
+          allowPattern: optionsPatternSchema
+        },
+        required: ["pattern"]
+      }
+    ],
     messages: {
       pattern: "'{{name}}' must match {{pattern}}."
     }
@@ -1264,24 +1572,27 @@ var exportNamePattern = defineRule5({
 });
 
 // src/rules/filename-export-name.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var filenameExportName = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var filenameExportName = defineRule7({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        file: { type: "string" },
-        export: { type: "string" },
-        mode: { type: "string", enum: ["all", "some"] },
-        placeholderPattern: { type: "string" },
-        allDeclarations: { type: "boolean" }
-      },
-      required: ["file", "export"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          file: { type: "string" },
+          export: { type: "string" },
+          mode: { type: "string", enum: ["all", "some"] },
+          placeholderPattern: { type: "string" },
+          camelCase: { type: "boolean" },
+          allDeclarations: { type: "boolean" }
+        },
+        required: ["file", "export"]
+      }
+    ],
     messages: {
-      mismatch: "Function '{{actual}}' must match '{{expected}}'."
+      mismatch: "Function '{{actual}}' must be named '{{expected}}' for file '{{file}}'."
     }
   },
   createOnce(context) {
@@ -1292,13 +1603,14 @@ var filenameExportName = defineRule6({
           export: exportTemplate,
           mode = "all",
           placeholderPattern,
-          allDeclarations = false
+          allDeclarations = false,
+          camelCase = false
         } = optionsFirst(context);
         const groups = namingMatchTemplate(namingFileBasename(context.filename), file, placeholderPattern);
         if (!groups) {
           return;
         }
-        const expected = factoriesExpandTemplate(exportTemplate, groups);
+        const expected = factoriesExpandTemplate(exportTemplate, groups, camelCase);
         const functions = allDeclarations ? declarationsCollectFunctions(program) : exportsCollectFunctions(program);
         if (mode === "some") {
           if (!functions.some((item) => item.name === expected)) {
@@ -1306,7 +1618,7 @@ var filenameExportName = defineRule6({
             context.report({
               node: first?.node ?? program,
               messageId: "mismatch",
-              data: { actual: first?.name ?? "<none>", expected }
+              data: { actual: first?.name ?? "<none>", expected, file: namingFileBasename(context.filename) }
             });
           }
           return;
@@ -1316,7 +1628,7 @@ var filenameExportName = defineRule6({
             context.report({
               node: item.node,
               messageId: "mismatch",
-              data: { actual: item.name, expected }
+              data: { actual: item.name, expected, file: namingFileBasename(context.filename) }
             });
           }
         }
@@ -1326,20 +1638,22 @@ var filenameExportName = defineRule6({
 });
 
 // src/rules/filename-match.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var filenameMatch = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var filenameMatch = defineRule8({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        pattern: optionsPatternSchema,
-        message: { type: "string" },
-        flags: { type: "string" }
-      },
-      required: ["pattern", "message"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          pattern: optionsPatternSchema,
+          message: { type: "string" },
+          flags: { type: "string" }
+        },
+        required: ["pattern", "message"]
+      }
+    ],
     messages: {
       mismatch: "{{message}}"
     }
@@ -1362,21 +1676,24 @@ var filenameMatch = defineRule7({
 });
 
 // src/rules/folder-prefix.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var folderPrefix = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var folderPrefix = defineRule9({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        singularize: { type: "string", enum: ["none", "trailing-s"] },
-        separators: { type: "array", items: { type: "string" } },
-        after: { type: "string" }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
+          separators: { type: "array", items: { type: "string" } },
+          after: { type: "string" },
+          stripPrefixes: { type: "array", items: { type: "string", minLength: 1 } }
+        }
+      }
+    ],
     messages: {
-      prefix: "File '{{file}}' must start with folder name '{{folder}}' or an allowed singular form."
+      prefix: "File '{{file}}' must start with '{{expected}}' to match its domain folder '{{folder}}'."
     }
   },
   createOnce(context) {
@@ -1385,7 +1702,8 @@ var folderPrefix = defineRule8({
         const {
           singularize = "trailing-s",
           separators = ["-"],
-          after
+          after,
+          stripPrefixes = []
         } = optionsFirst(context, {});
         const filename = namingPosixPath(context.filename);
         const folders = after ? namingSegmentsAfter(filename, after) : [namingDirSegments(filename).at(-1) ?? ""];
@@ -1396,13 +1714,19 @@ var folderPrefix = defineRule8({
         const separator = separators[0] ?? "-";
         const prefixes = namingFolderPrefixes(resolved, separator, singularize);
         const file = namingFileBasename(filename);
-        const stem = file.replace(/\.(tsx?|jsx?)$/, "");
+        const rawStem = file.replace(/\.(tsx?|jsx?)$/, "");
+        const strip = stripPrefixes.find((prefix) => rawStem.startsWith(prefix));
+        const stem = strip ? rawStem.slice(strip.length) : rawStem;
         const valid = prefixes.some((prefix) => stem === prefix || separators.some((item) => stem.startsWith(`${prefix}${item}`)));
         if (!valid) {
           context.report({
             node: program,
             messageId: "prefix",
-            data: { file, folder: prefixes[0] ?? "" }
+            data: {
+              file,
+              folder: resolved.join("/"),
+              expected: prefixes.map((prefix) => `${stripPrefixes[0] ?? ""}${prefix}`).join(" or ")
+            }
           });
         }
       }
@@ -1411,7 +1735,7 @@ var folderPrefix = defineRule8({
 });
 
 // src/rules/jsx-attributes-multiline.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, newline) {
   const first = node.attributes[0];
   const last = node.attributes.at(-1);
@@ -1421,10 +1745,12 @@ function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, ne
   const openingRange = [prefix.range[1], first.range[0]];
   if (!/^\s*$/.test(text.slice(...openingRange)))
     return null;
-  const edits = [{
-    range: openingRange,
-    text: `${newline}${attributeIndent}`
-  }];
+  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];
@@ -1440,18 +1766,20 @@ function jsxAttributesMultilineEdits(node, text, attributeIndent, baseIndent, ne
   edits.push({ range: closingRange, text: `${newline}${baseIndent}` });
   return edits;
 }
-var jsxAttributesMultiline = defineRule9({
+var jsxAttributesMultiline = defineRule10({
   meta: {
     type: "layout",
     fixable: "whitespace",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        minAttributes: { type: "integer", minimum: 1 },
-        indent: layoutIndentSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          minAttributes: { type: "integer", minimum: 1 },
+          indent: layoutIndentSchema
+        }
+      }
+    ],
     messages: {
       multiline: "Put every JSX attribute and the closing token on its own line."
     }
@@ -1487,8 +1815,8 @@ var jsxAttributesMultiline = defineRule9({
 });
 
 // src/rules/key-value-same-line.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
-var keyValueSameLine = defineRule10({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var keyValueSameLine = defineRule11({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -1537,7 +1865,7 @@ var keyValueSameLine = defineRule10({
 });
 
 // src/rules/no-comments.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } 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]))*/;
@@ -1629,19 +1957,21 @@ function noCommentsJsxEmptyContainer(containers, start, end) {
   const container = containers[low - 1];
   return container?.range[1] >= end ? container : undefined;
 }
-var noComments = defineRule11({
+var noComments = defineRule12({
   meta: {
     type: "suggestion",
     fixable: "code",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowWhy: { type: "boolean", default: true },
-        allowPatterns: { type: "array", items: { type: "string" } },
-        allowJsdoc: { type: "boolean", default: false }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowWhy: { type: "boolean", default: true },
+          allowPatterns: { type: "array", items: { type: "string" } },
+          allowJsdoc: { type: "boolean", default: false }
+        }
+      }
+    ],
     messages: {
       comment: "Remove this comment."
     }
@@ -1759,23 +2089,25 @@ var noComments = defineRule11({
 });
 
 // src/rules/no-extra-exports.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var noExtraExports = defineRule12({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noExtraExports = defineRule13({
   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"]
-    }],
+    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}}."
     }
@@ -1817,7 +2149,7 @@ var noExtraExports = defineRule12({
 });
 
 // src/rules/no-extra-factory-keys.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 function compileFactoryKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return {
@@ -1827,31 +2159,33 @@ function compileFactoryKeys(pattern, keys, requireKeys) {
     requireKeys
   };
 }
-var noExtraFactoryKeys = defineRule13({
+var noExtraFactoryKeys = defineRule14({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        keys: { type: "array", items: { type: "string" } },
-        factoryPattern: optionsPatternSchema,
-        requireKeys: { type: "array", items: { type: "string" } },
-        keySets: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-              factoryPattern: optionsPatternSchema,
-              keys: { type: "array", items: { type: "string" } },
-              requireKeys: { type: "array", items: { type: "string" } }
-            },
-            required: ["factoryPattern", "keys"]
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          keys: { type: "array", items: { type: "string" } },
+          factoryPattern: optionsPatternSchema,
+          requireKeys: { type: "array", items: { type: "string" } },
+          keySets: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                factoryPattern: optionsPatternSchema,
+                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}}'.",
@@ -1904,7 +2238,11 @@ var noExtraFactoryKeys = defineRule13({
                 context.report({
                   node: property,
                   messageId: "extraKey",
-                  data: { factory: factory.name, key: key ?? "<computed or spread>", allowed: resolved.allowedList.join(", ") }
+                  data: {
+                    factory: factory.name,
+                    key: key ?? "<computed or spread>",
+                    allowed: resolved.allowedList.join(", ")
+                  }
                 });
               }
             }
@@ -1925,21 +2263,24 @@ var noExtraFactoryKeys = defineRule13({
 });
 
 // src/rules/no-file-level-helpers.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var noFileLevelHelpers = defineRule14({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule15({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowPattern: optionsPatternSchema,
-        detectComponents: { type: "boolean" },
-        hookPattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowPattern: optionsPatternSchema,
+          message: { type: "string" },
+          detectComponents: { type: "boolean" },
+          hookPattern: optionsPatternSchema
+        }
+      }
+    ],
     messages: {
-      helper: "File-level helper {{name}} must move inside its owning component or hook."
+      helper: "{{name}}: {{message}}"
     }
   },
   createOnce(context) {
@@ -1947,6 +2288,7 @@ var noFileLevelHelpers = defineRule14({
       Program(program) {
         const {
           allowPattern,
+          message = "Keep this helper inside its owning component or hook.",
           detectComponents = true,
           hookPattern = "^use[A-Z]"
         } = optionsFirst(context, {});
@@ -1959,7 +2301,7 @@ var noFileLevelHelpers = defineRule14({
           context.report({
             node: candidate.node,
             messageId: "helper",
-            data: { name: candidate.name }
+            data: { name: candidate.name, message }
           });
         }
       }
@@ -1968,9 +2310,9 @@ var noFileLevelHelpers = defineRule14({
 });
 
 // src/rules/no-imported-type-alias.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } 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)) {
+  if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || Boolean(declaration.typeAnnotation.typeArguments?.params.length) || !imports.has(declaration.typeAnnotation.typeName.name)) {
     return;
   }
   return declaration.typeAnnotation.typeName.name;
@@ -1978,18 +2320,34 @@ function importedAliasTarget(declaration, imports) {
 function specifierLocalName(specifier) {
   return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
 }
-var noImportedTypeAlias = defineRule15({
+var noImportedTypeAlias = defineRule16({
   meta: {
     type: "problem",
     schema: [],
     messages: {
-      alias: "Exported type '{{alias}}' must not re-alias imported type '{{name}}'."
+      alias: "Import '{{name}}' from '{{source}}' at the callers instead of exporting alias '{{alias}}'. Keep genuine derivations; do not substitute an empty interface."
     }
   },
   createOnce(context) {
     return {
       Program(program) {
-        const imports = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" ? statement.specifiers.map((specifier) => specifier.local.name) : []));
+        const imports = new Set;
+        const sources = new Map;
+        const names = new Map;
+        for (const statement of program.body) {
+          if (statement.type !== "ImportDeclaration")
+            continue;
+          for (const specifier of statement.specifiers) {
+            const local = specifier.local.name;
+            let name = local;
+            if (specifier.type === "ImportSpecifier") {
+              name = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+            }
+            imports.add(local);
+            sources.set(local, statement.source.value);
+            names.set(local, name);
+          }
+        }
         const aliases = new Map;
         for (const statement of program.body) {
           const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
@@ -2007,7 +2365,11 @@ var noImportedTypeAlias = defineRule15({
             context.report({
               node: statement.declaration,
               messageId: "alias",
-              data: { alias: statement.declaration.id.name, name: inline }
+              data: {
+                alias: statement.declaration.id.name,
+                name: names.get(inline) ?? inline,
+                source: sources.get(inline) ?? "<import source>"
+              }
             });
           }
           for (const specifier of statement.specifiers) {
@@ -2017,7 +2379,11 @@ var noImportedTypeAlias = defineRule15({
               context.report({
                 node: specifier,
                 messageId: "alias",
-                data: { alias: local, name: imported }
+                data: {
+                  alias: local,
+                  name: names.get(imported) ?? imported,
+                  source: sources.get(imported) ?? "<import source>"
+                }
               });
             }
           }
@@ -2028,26 +2394,39 @@ var noImportedTypeAlias = defineRule15({
 });
 
 // src/rules/no-inline-schema-elements.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var noInlineSchemaElements = defineRule16({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule17({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        namespaces: { type: "array", items: { type: "string" } },
-        methods: { type: "array", items: { type: "string" } },
-        structuralMethods: { type: "array", items: { type: "string" } },
-        allowZodScalars: { type: "boolean" }
-      }
-    }],
-    defaultOptions: [{
-      namespaces: ["z"],
-      methods: ["array", "union", "record", "tuple"],
-      structuralMethods: ["array", "discriminatedUnion", "intersection", "lazy", "object", "record", "tuple", "union"],
-      allowZodScalars: true
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          namespaces: { type: "array", items: { type: "string" } },
+          methods: { type: "array", items: { type: "string" } },
+          structuralMethods: { type: "array", items: { type: "string" } },
+          allowZodScalars: { type: "boolean" }
+        }
+      }
+    ],
+    defaultOptions: [
+      {
+        namespaces: ["z"],
+        methods: ["array", "union", "record", "tuple"],
+        structuralMethods: [
+          "array",
+          "discriminatedUnion",
+          "intersection",
+          "lazy",
+          "object",
+          "record",
+          "tuple",
+          "union"
+        ],
+        allowZodScalars: true
+      }
+    ],
     messages: { inline: "z.{{method}}() elements must use named schemas." }
   },
   createOnce(context) {
@@ -2077,7 +2456,7 @@ var noInlineSchemaElements = defineRule16({
 });
 
 // src/rules/no-inline-types.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -2087,19 +2466,21 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var noInlineTypes = defineRule17({
+var noInlineTypes = defineRule18({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        parameters: { type: "boolean" },
-        returns: { type: "boolean" },
-        functionTypes: { type: "boolean" },
-        minMembers: { type: "integer", minimum: 1 }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          parameters: { type: "boolean" },
+          returns: { type: "boolean" },
+          functionTypes: { type: "boolean" },
+          minMembers: { type: "integer", minimum: 1 }
+        }
+      }
+    ],
     messages: {
       inlineType: "Use a named type instead of an inline {{kind}} type in this {{position}} annotation."
     }
@@ -2155,7 +2536,7 @@ var noInlineTypes = defineRule17({
 });
 
 // src/rules/no-literal-in.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function literalKey(node) {
   if (node.type === "Literal" && typeof node.value === "string") {
     return node.value;
@@ -2164,16 +2545,18 @@ function literalKey(node) {
     return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
   }
 }
-var noLiteralIn = defineRule18({
+var noLiteralIn = defineRule19({
   meta: {
     type: "suggestion",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allow: { type: "array", items: { type: "string" } }
+    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."
@@ -2203,32 +2586,36 @@ var noLiteralIn = defineRule18({
 });
 
 // src/rules/no-local-schema-construction.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } 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 = defineRule19({
+var noLocalSchemaConstruction = defineRule20({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        packages: { type: "array", items: { type: "string" } },
-        namespaces: { type: "array", items: { type: "string" } },
-        allowIn: { type: "array", items: { type: "string" } },
-        allowPathPatterns: { type: "array", items: { type: "string" } },
-        message: { type: "string" },
-        runtimeImportMessage: { type: "string" },
-        constructionMessage: { type: "string" }
-      }
-    }],
-    defaultOptions: [{
-      packages: ["zod"],
-      namespaces: ["z"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          packages: { type: "array", items: { type: "string" } },
+          namespaces: { type: "array", items: { type: "string" } },
+          allowIn: { type: "array", items: { type: "string" } },
+          allowPathPatterns: { type: "array", items: { type: "string" } },
+          message: { type: "string" },
+          runtimeImportMessage: { type: "string" },
+          constructionMessage: { type: "string" }
+        }
+      }
+    ],
+    defaultOptions: [
+      {
+        packages: ["zod"],
+        namespaces: ["z"]
+      }
+    ],
     messages: {
       runtimeImport: "{{message}}",
       construction: "{{message}}"
@@ -2265,7 +2652,9 @@ var noLocalSchemaConstruction = defineRule19({
           node,
           messageId: "runtimeImport",
           data: {
-            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, {
+              source: node.source.value
+            })
           }
         });
       },
@@ -2282,7 +2671,9 @@ var noLocalSchemaConstruction = defineRule19({
           node,
           messageId: "runtimeImport",
           data: {
-            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, {
+              source: node.source.value
+            })
           }
         });
       },
@@ -2299,7 +2690,9 @@ var noLocalSchemaConstruction = defineRule19({
           node,
           messageId: "runtimeImport",
           data: {
-            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, {
+              source: node.source.value
+            })
           }
         });
       },
@@ -2321,18 +2714,20 @@ var noLocalSchemaConstruction = defineRule19({
 });
 
 // src/rules/no-member-comments.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var noMemberComments = defineRule20({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var noMemberComments = defineRule21({
   meta: {
     type: "suggestion",
     fixable: "code",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowWhy: { type: "boolean", default: true }
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowWhy: { type: "boolean", default: true }
+        }
       }
-    }],
+    ],
     messages: {
       memberComment: "Remove this comment from the type member."
     }
@@ -2416,7 +2811,7 @@ var noMemberComments = defineRule20({
 });
 
 // src/rules/no-module-mutable-state.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 function moduleMutableStateBindings(pattern) {
   if (pattern.type === "Identifier") {
     return [{ name: pattern.name, node: pattern }];
@@ -2455,20 +2850,22 @@ function moduleMutableStateInsideAmbient(node) {
   }
   return false;
 }
-var noModuleMutableState = defineRule21({
+var noModuleMutableState = defineRule22({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        kinds: {
-          type: "array",
-          items: { type: "string", enum: ["let", "var"] }
-        },
-        allowNamePattern: optionsPatternSchema
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          kinds: {
+            type: "array",
+            items: { type: "string", enum: ["let", "var"] }
+          },
+          allowNamePattern: optionsPatternSchema
+        }
       }
-    }],
+    ],
     messages: {
       moduleState: "module state is shared across requests/tests; keep it local."
     }
@@ -2505,7 +2902,7 @@ var noModuleMutableState = defineRule21({
 });
 
 // src/rules/no-promise-all-mutation.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2533,23 +2930,27 @@ function mutationBindings(node) {
     }
   }
 }
-var noPromiseAllMutation = defineRule22({
+var noPromiseAllMutation = defineRule23({
   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
-    }],
+    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}}()."
     }
@@ -2629,20 +3030,22 @@ var noPromiseAllMutation = defineRule22({
 });
 
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule23({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule24({
   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"]
-    }],
+    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."
     }
@@ -2655,10 +3058,7 @@ var noRederiveSchema = defineRule23({
         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 { namespaces = ["z"], operators = ["infer", "input"] } = optionsFirst(context);
         const operator = schemasTypeOperator(node, new Set(namespaces), new Set(operators));
         const parameter = node.typeArguments?.params[0];
         if (!operator || parameter?.type !== "TSTypeQuery" || parameter.exprName.type !== "Identifier" || !imported.has(parameter.exprName.name)) {
@@ -2675,7 +3075,7 @@ var noRederiveSchema = defineRule23({
 });
 
 // src/rules/no-restricted-constructor.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 function restrictedConstructorEntries(constructors) {
   const entries = new Map;
   for (const item of constructors) {
@@ -2691,35 +3091,37 @@ function restrictedConstructorEntries(constructors) {
   }
   return entries;
 }
-var noRestrictedConstructor = defineRule24({
+var noRestrictedConstructor = defineRule25({
   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"]
-              }
-            ]
-          }
+    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" }
         },
-        checkCalls: { type: "boolean", default: false },
-        message: { type: "string" }
-      },
-      required: ["constructors"]
-    }],
+        required: ["constructors"]
+      }
+    ],
     messages: {
       construct: "Do not construct '{{name}}'.{{suffix}}",
       call: "Do not call '{{name}}'.{{suffix}}"
@@ -2764,18 +3166,20 @@ var noRestrictedConstructor = defineRule24({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule25({
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule26({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        message: { type: "string" }
-      },
-      required: ["message"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          message: { type: "string" }
+        },
+        required: ["message"]
+      }
+    ],
     messages: {
       restricted: "{{message}}"
     }
@@ -2795,7 +3199,7 @@ var noRestrictedFiles = defineRule25({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -2806,40 +3210,39 @@ function tokenIsTypeOnlyImport(node) {
 function memberMatches(node, restriction) {
   return restriction.startsWith("*.") ? astStaticMemberName(node) === restriction.slice(2) : astDottedName(node) === restriction;
 }
-var noRestrictedToken = defineRule26({
+var noRestrictedToken = defineRule27({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        token: { type: "string" },
-        allowIn: { 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"] } }
-            ]
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          token: { type: "string" },
+          allowIn: { 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"] } }
+              ]
+            }
           }
-        }
-      },
-      anyOf: [
-        { required: ["token"] },
-        { required: ["restrictions"] }
-      ]
-    }],
+        },
+        anyOf: [{ required: ["token"] }, { required: ["restrictions"] }]
+      }
+    ],
     messages: {
       restricted: "'{{token}}' may only appear in configured owner paths.",
       restrictedWithMessage: "'{{token}}' may only appear in configured owner paths. {{custom}}"
@@ -2858,11 +3261,13 @@ var noRestrictedToken = defineRule26({
       before() {
         const options = optionsFirst(context);
         const configured = [
-          ...options.token ? [{
-            token: options.token,
-            allowIn: options.allowIn,
-            allowPathPatterns: options.allowPathPatterns
-          }] : [],
+          ...options.token ? [
+            {
+              token: options.token,
+              allowIn: options.allowIn,
+              allowPathPatterns: options.allowPathPatterns
+            }
+          ] : [],
           ...options.restrictions ?? []
         ];
         const filename = namingPosixPath(context.filename);
@@ -2902,7 +3307,7 @@ var noRestrictedToken = defineRule26({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 function isTypeOnlyImport(statement) {
   return statement.importKind === "type" || statement.specifiers.length > 0 && statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
 }
@@ -3119,22 +3524,24 @@ function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbient
   }
   return statement.specifiers.some((specifier) => specifier.exportKind !== "type" && runtimeImportLocals.has(exportLocalName(specifier)));
 }
-var noRuntimeInTypes = defineRule27({
+var noRuntimeInTypes = defineRule28({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        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" }
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          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}}.",
@@ -3261,7 +3668,7 @@ var noRuntimeInTypes = defineRule27({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -3295,25 +3702,42 @@ 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 = defineRule28({
+var noSingleUseScalarSchema = defineRule29({
   meta: {
     type: "suggestion",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        namespaces: { type: "array", items: { type: "string" } },
-        methods: { type: "array", items: { type: "string" } },
-        structuralMethods: { type: "array", items: { type: "string" } },
-        allowZodScalars: { type: "boolean" }
-      }
-    }],
-    defaultOptions: [{
-      namespaces: ["z"],
-      methods: ["array", "union", "record", "tuple"],
-      structuralMethods: ["and", "array", "discriminatedUnion", "intersection", "lazy", "object", "or", "pipe", "record", "transform", "tuple", "union"],
-      allowZodScalars: true
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          namespaces: { type: "array", items: { type: "string" } },
+          methods: { type: "array", items: { type: "string" } },
+          structuralMethods: { type: "array", items: { type: "string" } },
+          allowZodScalars: { type: "boolean" }
+        }
+      }
+    ],
+    defaultOptions: [
+      {
+        namespaces: ["z"],
+        methods: ["array", "union", "record", "tuple"],
+        structuralMethods: [
+          "and",
+          "array",
+          "discriminatedUnion",
+          "intersection",
+          "lazy",
+          "object",
+          "or",
+          "pipe",
+          "record",
+          "transform",
+          "tuple",
+          "union"
+        ],
+        allowZodScalars: true
+      }
+    ],
     messages: { inline: "Inline single-use scalar schema {{name}} at its only structural use." }
   },
   create(context) {
@@ -3363,18 +3787,20 @@ var noSingleUseScalarSchema = defineRule28({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule29({
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule30({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        banReExports: { type: "boolean" },
-        allowPattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          banReExports: { type: "boolean" },
+          allowPattern: optionsPatternSchema
+        }
+      }
+    ],
     defaultOptions: [{ banReExports: true }],
     messages: {
       noFunction: "Files in this scope must not contain top-level function {{name}}.",
@@ -3421,74 +3847,127 @@ var noTopLevelFunctions = defineRule29({
 });
 
 // src/rules/no-trivial-functions.ts
-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({
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+
+// src/constants/trivial.constants.ts
+var trivialBannedNames = [
+  "isRecord",
+  "isPlainObject",
+  "isObject",
+  "isString",
+  "isNumber",
+  "isBoolean",
+  "isArray",
+  "asRecord",
+  "asArray"
+];
+
+// src/rules/no-trivial-functions.ts
+var noTrivialFunctions = defineRule31({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowPattern: optionsPatternSchema,
-        allowCallees: { type: "array", items: { type: "string" } },
-        allowAsync: { type: "boolean" }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowPattern: optionsPatternSchema,
+          allowCallees: { type: "array", items: { type: "string" } },
+          allowAsync: { type: "boolean" },
+          checkServiceMethods: { type: "boolean" },
+          mode: { type: "string", enum: ["legacy", "precise"] },
+          bannedNames: { type: "array", items: { type: "string" }, uniqueItems: true },
+          checkGenericGuards: { type: "boolean" }
+        }
+      }
+    ],
     messages: {
-      trivial: "Function {{name}} does nothing useful; inline it at the call site."
+      trivial: "Function {{name}} adds no transformation; inline it or use a value for a constant result. Keep deliberate adapters through an explicit rule exclusion.",
+      bannedName: "Helper {{name}} is forbidden by this policy. Inline the local check, or validate external input at its boundary; renaming the guard does not fix it.",
+      genericGuard: "Helper {{name}} only performs generic runtime type checks or fallback reads. Inline the local check, or validate external input at its boundary; do not add a schema merely to retain this helper."
     }
   },
   createOnce(context) {
     let allowed = [];
     let allowedCallees = [];
     let allowAsync = false;
+    let mode = "legacy";
+    let bannedNames = new Set;
+    let checkGenericGuards = false;
+    let checkServiceMethods = false;
+    const reported = new Set;
+    const checked = new Set;
+    function globalArray(node) {
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.set.get("Array");
+        if (variable)
+          return variable.defs.length === 0;
+        scope = scope.upper;
+      }
+      return true;
+    }
+    function checkHelper(node) {
+      if (bannedNames.size === 0 && !checkGenericGuards || checked.has(node.start))
+        return;
+      checked.add(node.start);
+      const parent = node.parent;
+      const name = node.type !== "ArrowFunctionExpression" && node.id ? node.id.name : parent.type === "VariableDeclarator" && parent.id.type === "Identifier" ? parent.id.name : parent.type === "Property" && !parent.computed && parent.key.type === "Identifier" ? parent.key.name : "<anonymous>";
+      if (optionsPatternsTest(allowed, name))
+        return;
+      if (bannedNames.has(name)) {
+        reported.add(node.start);
+        context.report({ node, messageId: "bannedName", data: { name } });
+        return;
+      }
+      if (checkGenericGuards && guardsIsGenericHelper(node, globalArray)) {
+        reported.add(node.start);
+        context.report({ node, messageId: "genericGuard", data: { name } });
+      }
+    }
     return {
       before() {
-        const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = optionsFirst(context, {});
+        const options = optionsFirst(context, {});
+        const { allowPattern, allowCallees: calleePatterns = [], allowAsync: asyncAllowed = false } = options;
+        mode = options.mode ?? "legacy";
+        checkServiceMethods = options.checkServiceMethods ?? false;
+        bannedNames = new Set(options.bannedNames ?? (mode === "precise" ? trivialBannedNames : []));
+        checkGenericGuards = options.checkGenericGuards ?? mode === "precise";
+        reported.clear();
+        checked.clear();
         allowed = optionsOptionalPatterns(allowPattern);
         allowedCallees = calleePatterns.map((pattern) => new RegExp(pattern));
         allowAsync = asyncAllowed;
       },
+      FunctionDeclaration: checkHelper,
+      FunctionExpression: checkHelper,
+      ArrowFunctionExpression: checkHelper,
       Program(program) {
         const seen = new Set;
-        for (const item of [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)]) {
+        for (const item of [
+          ...exportsCollectFunctions(program),
+          ...declarationsTopLevelUnexportedFunctions(program),
+          ...checkServiceMethods ? declarationsPublicServiceMethods(program) : []
+        ]) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          if (seen.has(key) || optionsPatternsTest(allowed, item.name) || !declarationsIsTrivialFunction(item.node)) {
+          if (seen.has(key) || optionsPatternsTest(allowed, item.name)) {
             continue;
           }
-          const expression = forwardedExpression(item.node);
-          const call = expression && forwardedCall(expression);
+          seen.add(key);
+          checkHelper(item.node);
+          if (reported.has(item.node.start))
+            continue;
+          const expression = trivialExpression(item.node);
+          const trivial = mode === "legacy" ? declarationsIsTrivialFunction(item.node) : expression ? trivialIsForwarder(item.node, expression) : declarationsIsTrivialFunction(item.node);
+          if (!trivial)
+            continue;
+          const value = expression && trivialUnwrap(expression);
+          const call = value?.type === "CallExpression" ? value : null;
           const path = call && astDottedName(call.callee);
           if (allowAsync && item.node.async && call || path && allowedCallees.some((pattern) => pattern.test(path))) {
             continue;
           }
-          seen.add(key);
+          reported.add(item.node.start);
           context.report({
             node: item.node,
             messageId: "trivial",
@@ -3501,17 +3980,19 @@ var noTrivialFunctions = defineRule30({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule31({
+import { defineRule as defineRule32 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule32({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowPattern: optionsPatternSchema
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowPattern: optionsPatternSchema
+        }
       }
-    }],
+    ],
     messages: {
       typeDeclaration: "Type '{{name}}' must not be declared in this file."
     }
@@ -3545,20 +4026,23 @@ var noTypeDeclarations = defineRule31({
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule32({
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule33({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        methods: { type: "array", items: { type: "string" } },
-        sanitizers: { type: "array", items: { type: "string" } },
-        allowSanitizedBindings: { type: "boolean" }
-      },
-      required: ["methods", "sanitizers"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          methods: { type: "array", items: { type: "string" } },
+          sanitizers: { type: "array", items: { type: "string" } },
+          allowSanitizedBindings: { type: "boolean" },
+          operatorMethods: { type: "array", items: { type: "string" } }
+        },
+        required: ["methods", "sanitizers"]
+      }
+    ],
     messages: { unescaped: ".{{method}}() values must use a configured sanitizer." }
   },
   createOnce(context) {
@@ -3572,9 +4056,11 @@ var noUnescapedLike = defineRule32({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { methods, sanitizers } = optionsFirst(context);
+        const { methods, sanitizers, operatorMethods = [] } = optionsFirst(context);
         const method = astStaticMemberName(node.callee);
-        if (!method || !methods.includes(method)) {
+        const operator = node.arguments[1];
+        const operatorCall = method && operatorMethods.includes(method) && operator?.type === "Literal" && typeof operator.value === "string" && methods.includes(operator.value);
+        if (!method || !methods.includes(method) && !operatorCall) {
           return;
         }
         const value = node.arguments.at(-1);
@@ -3592,7 +4078,7 @@ var noUnescapedLike = defineRule32({
 });
 
 // src/rules/object-multiline.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 function objectMultilineIsCallArg(node) {
   const parent = node.parent;
   return (parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node);
@@ -3629,19 +4115,21 @@ function objectMultilineGaps(text, node) {
   }
   return gaps;
 }
-var objectMultiline = defineRule33({
+var objectMultiline = defineRule34({
   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 }
-      }
-    }],
+    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."
@@ -3689,19 +4177,21 @@ var objectMultiline = defineRule33({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule34({
+import { defineRule as defineRule35 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule35({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        matchFileName: { type: "boolean" },
-        allowTypeExports: { type: "boolean" },
-        denyTypePattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          matchFileName: { type: "boolean" },
+          allowTypeExports: { type: "boolean" },
+          denyTypePattern: optionsPatternSchema
+        }
+      }
+    ],
     messages: {
       nonComponent: "Export '{{name}}' must be a React component or type.",
       nameMismatch: "Component export '{{name}}' must match '{{expected}}' or its prefix.",
@@ -3768,7 +4258,7 @@ var onlyExportComponents = defineRule34({
 });
 
 // src/rules/only-export-constants.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 function bindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
@@ -3823,18 +4313,20 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var onlyExportConstants = defineRule35({
+var onlyExportConstants = defineRule36({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        allowFunctionValues: { type: "boolean" },
-        allowTypeExports: { type: "boolean" },
-        allowReExports: { type: "boolean" }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowFunctionValues: { type: "boolean" },
+          allowTypeExports: { type: "boolean" },
+          allowReExports: { type: "boolean" }
+        }
+      }
+    ],
     messages: {
       nonConstant: "Export '{{name}}' must be a local const binding with an allowed value; types and re-exports require explicit options."
     }
@@ -3842,7 +4334,11 @@ var onlyExportConstants = defineRule35({
   createOnce(context) {
     return {
       Program(program) {
-        const { allowFunctionValues = false, allowTypeExports = false, allowReExports = false } = optionsFirst(context, {});
+        const {
+          allowFunctionValues = false,
+          allowTypeExports = false,
+          allowReExports = false
+        } = optionsFirst(context, {});
         const bindings = collectBindings(program);
         function hasForbiddenValue(binding, seen = new Set) {
           if (seen.has(binding) || binding.kind === "class") {
@@ -3905,7 +4401,7 @@ var onlyExportConstants = defineRule35({
 });
 
 // src/rules/padding-between-statements.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function paddingKind(node) {
   if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
     return node.declaration ? paddingKind(node.declaration) : "other";
@@ -3957,17 +4453,20 @@ function paddingBlankLineFix(sourceText, comments, prev, curr, newline) {
   }
   return { newlineEnd, newline };
 }
-var paddingBetweenStatements = defineRule36({
+var paddingBetweenStatements = defineRule37({
   meta: {
     type: "layout",
     fixable: "whitespace",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        returnMinStatements: { type: "integer", minimum: 1, default: 3 }
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          returnMinStatements: { type: "integer", minimum: 1, default: 3 },
+          multilineVariables: { type: "boolean" }
+        }
       }
-    }],
+    ],
     messages: {
       variableAndBlock: "Expected a blank line between a variable declaration and a function/class.",
       beforeBlock: "Expected a blank line before a function/class declaration.",
@@ -3975,11 +4474,13 @@ var paddingBetweenStatements = defineRule36({
       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."
+      beforeReturn: "Expected a blank line before return statement.",
+      multilineVariable: "Expected a blank line around a multiline variable declaration."
     }
   },
   createOnce(context) {
     let returnMinStatements = 3;
+    let multilineVariables = false;
     let newline = `
 `;
     let source;
@@ -3993,7 +4494,8 @@ var paddingBetweenStatements = defineRule36({
         }
         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;
+        const multiline = multilineVariables && (prevKind === "variable" && prev.loc.start.line !== prev.loc.end.line || currKind === "variable" && curr.loc.start.line !== curr.loc.end.line);
+        const messageId = multiline ? "multilineVariable" : 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;
         }
@@ -4010,6 +4512,7 @@ var paddingBetweenStatements = defineRule36({
       before() {
         const options = optionsFirst(context, {});
         returnMinStatements = options.returnMinStatements ?? 3;
+        multilineVariables = options.multilineVariables ?? false;
         source = context.sourceCode;
         newline = layoutNewline(source.text);
       },
@@ -4024,7 +4527,7 @@ var paddingBetweenStatements = defineRule36({
 });
 
 // src/rules/prefer-namespace-type-import.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 var bindingName = /^[A-Za-z_$][\w$]*$/;
 var reservedNames = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield implements interface let package private protected public static arguments eval".split(" "));
 function namespaceName(source, names) {
@@ -4048,21 +4551,23 @@ function safeReference(node) {
   }
   return parent?.type === "TSTypeReference" && parent.typeName === current || parent?.type === "TSTypeQuery" && parent.exprName === current || (parent?.type === "TSInterfaceHeritage" || parent?.type === "TSClassImplements") && parent.expression === current;
 }
-var preferNamespaceTypeImport = defineRule37({
+var preferNamespaceTypeImport = defineRule38({
   meta: {
     type: "suggestion",
     fixable: "code",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        max: { type: "integer", minimum: 0 },
-        names: { type: "object", additionalProperties: { type: "string", pattern: bindingName.source } }
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          max: { type: "integer", minimum: 0 },
+          names: { type: "object", additionalProperties: { type: "string", pattern: bindingName.source } }
+        }
+      }
+    ],
     defaultOptions: [{ max: 3, names: {} }],
     messages: {
-      namespace: "Use a type namespace '{{name}}' for {{count}} named imports (maximum {{max}}).{{reason}}"
+      namespace: "Use `import type * as {{name}} from '{{source}}'` for {{count}} type imports (max {{max}}); keep exported domain names.{{reason}}"
     }
   },
   createOnce(context) {
@@ -4147,7 +4652,13 @@ var preferNamespaceTypeImport = defineRule37({
           context.report({
             node,
             messageId: "namespace",
-            data: { name, count: node.specifiers.length, max, reason: reason ? ` Autofix skipped: ${reason}.` : "" },
+            data: {
+              name,
+              source: node.source.value,
+              count: node.specifiers.length,
+              max,
+              reason: reason ? ` Autofix skipped: ${reason}.` : ""
+            },
             fix: reason ? undefined : (fixer) => edits.map((edit) => fixer.replaceTextRange(edit.range, edit.text))
           });
         }
@@ -4157,19 +4668,21 @@ var preferNamespaceTypeImport = defineRule37({
 });
 
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-var requireFileFactory = defineRule38({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var requireFileFactory = defineRule39({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        factory: { type: "string" },
-        allDeclarations: { type: "boolean" }
-      },
-      required: ["factory"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          factory: { type: "string" },
+          allDeclarations: { type: "boolean" }
+        },
+        required: ["factory"]
+      }
+    ],
     messages: {
       factory: "Function '{{actual}}' must be named '{{expected}}'."
     }
@@ -4204,19 +4717,22 @@ var requireFileFactory = defineRule38({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireObjectParams = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var requireObjectParams = defineRule40({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        maxParams: { type: "integer", minimum: 1 },
-        allDeclarations: { type: "boolean" },
-        allowPattern: optionsPatternSchema
-      }
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          maxParams: { type: "integer", minimum: 1 },
+          serviceMethods: { type: "boolean" },
+          allDeclarations: { type: "boolean" },
+          allowPattern: optionsPatternSchema
+        }
+      }
+    ],
     messages: {
       objectParams: "{{label}} {{name}} must accept at most {{maxParams}} object parameter{{s}}."
     }
@@ -4224,10 +4740,17 @@ var requireObjectParams = defineRule39({
   createOnce(context) {
     return {
       Program(program) {
-        const { maxParams = 1, allDeclarations = false, allowPattern } = optionsFirst(context, {});
+        const {
+          maxParams = 1,
+          allDeclarations = false,
+          serviceMethods = false,
+          allowPattern
+        } = optionsFirst(context, {});
         const allowed = optionsOptionalPatterns(allowPattern);
         const seen = new Set;
         const functions = allDeclarations ? [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)] : exportsCollectFunctions(program);
+        if (serviceMethods)
+          functions.push(...declarationsPublicServiceMethods(program));
         for (const item of functions) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
           if (seen.has(key) || optionsPatternsTest(allowed, item.name)) {
@@ -4253,20 +4776,22 @@ var requireObjectParams = defineRule39({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule41({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        composers: { type: "array", items: { type: "string" } },
-        handlerMethod: { type: "string" },
-        outputMethod: { type: "string" }
-      },
-      required: ["composers"]
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          composers: { type: "array", items: { type: "string" } },
+          handlerMethod: { type: "string" },
+          outputMethod: { type: "string" }
+        },
+        required: ["composers"]
+      }
+    ],
     messages: {
       missing: "oRPC procedures must declare .output() before .handler().",
       invalid: "oRPC .output() must use a named schema or configured composer with a named schema."
@@ -4278,7 +4803,11 @@ var requireOrpcOutput = defineRule40({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { composers, handlerMethod = "handler", outputMethod = "output" } = optionsFirst(context);
+        const {
+          composers,
+          handlerMethod = "handler",
+          outputMethod = "output"
+        } = optionsFirst(context);
         if (astStaticMemberName(node.callee) !== handlerMethod) {
           return;
         }
@@ -4296,34 +4825,33 @@ var requireOrpcOutput = defineRule40({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var requirePairedCall = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var requirePairedCall = defineRule42({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        when: { type: "string" },
-        require: { type: "string" },
-        pairs: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-              when: { type: "string" },
-              require: { type: "string" }
-            },
-            required: ["when", "require"]
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          when: { type: "string" },
+          require: { type: "string" },
+          pairs: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                when: { type: "string" },
+                require: { type: "string" }
+              },
+              required: ["when", "require"]
+            }
           }
-        }
-      },
-      anyOf: [
-        { required: ["when", "require"] },
-        { required: ["pairs"] }
-      ]
-    }],
+        },
+        anyOf: [{ required: ["when", "require"] }, { required: ["pairs"] }]
+      }
+    ],
     messages: {
       paired: "{{when}} requires a call to {{require}} in the same file."
     }
@@ -4372,20 +4900,24 @@ var requirePairedCall = defineRule41({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
-var routeSurface = defineRule42({
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var routeSurface = defineRule43({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        exportName: { type: "string" },
-        bannedHooks: { type: "array", items: { type: "string" } },
-        banIntrinsicJsx: { type: "boolean" }
-      }
-    }],
-    defaultOptions: [{ exportName: "Route", bannedHooks: ["useState", "useEffect", "useMutation"], banIntrinsicJsx: true }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          exportName: { type: "string" },
+          bannedHooks: { type: "array", items: { type: "string" } },
+          banIntrinsicJsx: { type: "boolean" }
+        }
+      }
+    ],
+    defaultOptions: [
+      { exportName: "Route", bannedHooks: ["useState", "useEffect", "useMutation"], banIntrinsicJsx: true }
+    ],
     messages: {
       extraExport: "Route files may only export '{{expected}}'; found '{{actual}}'.",
       hostJsx: "Route adapter {{name}} must not render intrinsic JSX.",
@@ -4415,8 +4947,8 @@ var routeSurface = defineRule42({
 });
 
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "todo", "each"]);
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
 function isConfiguredName(name, callees) {
   if (!name) {
     return false;
@@ -4455,23 +4987,27 @@ function regexMatches(regex, value) {
 function titlePatterns(pattern, flags) {
   return pattern === undefined ? [] : [pattern].flat().map((source) => ({ regex: new RegExp(source, flags), pattern: source }));
 }
-var testTitlePattern = defineRule43({
+var testTitlePattern = defineRule44({
   meta: {
     type: "suggestion",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        callees: { type: "array", items: { type: "string" } },
-        forbid: optionsPatternSchema,
-        require: optionsPatternSchema,
-        flags: { type: "string", pattern: "^[dgimsuvy]*$" }
-      }
-    }],
-    defaultOptions: [{
-      callees: ["describe", "it", "test"],
-      flags: ""
-    }],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          callees: { type: "array", items: { type: "string" } },
+          forbid: optionsPatternSchema,
+          require: optionsPatternSchema,
+          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}}'."
@@ -4532,6 +5068,7 @@ var src_default = eslintCompatPlugin({
   rules: {
     "call-array-multiline": callArrayMultiline,
     "chain-newline": chainNewline,
+    "component-props": componentProps,
     "declaration-name": declarationName,
     "export-file-prefix": exportFilePrefix,
     "export-name-pattern": exportNamePattern,