oxlint-plugin-arch 0.4.0 → 0.5.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."
     }
@@ -1087,24 +1257,26 @@ import { defineRule as defineRule3 } from "@oxlint/plugins";
 var declarationName = 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: {
+          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 +1301,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 {
@@ -1160,19 +1335,23 @@ import { defineRule as defineRule4 } from "@oxlint/plugins";
 var exportFilePrefix = defineRule4({
   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 +1371,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}`;
@@ -1216,18 +1401,20 @@ import { defineRule as defineRule5 } from "@oxlint/plugins";
 var exportNamePattern = defineRule5({
   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}}."
     }
@@ -1268,20 +1455,23 @@ import { defineRule as defineRule6 } from "@oxlint/plugins";
 var filenameExportName = defineRule6({
   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 +1482,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 +1497,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 +1507,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) }
             });
           }
         }
@@ -1330,16 +1521,18 @@ import { defineRule as defineRule7 } from "@oxlint/plugins";
 var filenameMatch = defineRule7({
   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}}"
     }
@@ -1366,17 +1559,20 @@ import { defineRule as defineRule8 } from "@oxlint/plugins";
 var folderPrefix = defineRule8({
   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 +1581,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 +1593,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 ")
+            }
           });
         }
       }
@@ -1421,10 +1624,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];
@@ -1444,14 +1649,16 @@ var jsxAttributesMultiline = defineRule9({
   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."
     }
@@ -1633,15 +1840,17 @@ var noComments = defineRule11({
   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."
     }
@@ -1763,19 +1972,21 @@ import { defineRule as defineRule12 } from "@oxlint/plugins";
 var noExtraExports = defineRule12({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        names: { type: "array", items: { type: "string" } },
-        patterns: { type: "array", items: { type: "string" } },
-        domainStem: { type: "string", enum: [...namingStemModes] },
-        trailingRoles: { type: "array", items: { type: "string" } },
-        roleSeparators: { type: "array", items: { type: "string" } },
-        allowTypeExports: { type: "boolean" }
-      },
-      required: ["names"]
-    }],
+    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}}."
     }
@@ -1830,28 +2041,30 @@ function compileFactoryKeys(pattern, keys, requireKeys) {
 var noExtraFactoryKeys = defineRule13({
   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 +2117,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(", ")
+                  }
                 });
               }
             }
@@ -1929,17 +2146,20 @@ import { defineRule as defineRule14 } from "@oxlint/plugins";
 var noFileLevelHelpers = defineRule14({
   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 +2167,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 +2180,7 @@ var noFileLevelHelpers = defineRule14({
           context.report({
             node: candidate.node,
             messageId: "helper",
-            data: { name: candidate.name }
+            data: { name: candidate.name, message }
           });
         }
       }
@@ -1970,7 +2191,7 @@ var noFileLevelHelpers = defineRule14({
 // src/rules/no-imported-type-alias.ts
 import { defineRule as defineRule15 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
-  if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || !imports.has(declaration.typeAnnotation.typeName.name)) {
+  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;
@@ -1983,13 +2204,29 @@ var noImportedTypeAlias = defineRule15({
     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 +2244,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 +2258,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>"
+                }
               });
             }
           }
@@ -2032,22 +2277,35 @@ import { defineRule as defineRule16 } from "@oxlint/plugins";
 var noInlineSchemaElements = defineRule16({
   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" }
+    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
       }
-    }],
-    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) {
@@ -2090,16 +2348,18 @@ function parameterAnnotation(parameter) {
 var noInlineTypes = defineRule17({
   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."
     }
@@ -2167,13 +2427,15 @@ function literalKey(node) {
 var noLiteralIn = defineRule18({
   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."
@@ -2212,23 +2474,27 @@ function formatMessage(template, data) {
 var noLocalSchemaConstruction = defineRule19({
   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" }
+    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"]
-    }],
+    ],
+    defaultOptions: [
+      {
+        packages: ["zod"],
+        namespaces: ["z"]
+      }
+    ],
     messages: {
       runtimeImport: "{{message}}",
       construction: "{{message}}"
@@ -2265,7 +2531,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 +2550,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 +2569,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
+            })
           }
         });
       },
@@ -2326,13 +2598,15 @@ var noMemberComments = defineRule20({
   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."
     }
@@ -2458,17 +2732,19 @@ function moduleMutableStateInsideAmbient(node) {
 var noModuleMutableState = defineRule21({
   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."
     }
@@ -2536,20 +2812,24 @@ function mutationBindings(node) {
 var noPromiseAllMutation = defineRule22({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        combinators: { type: "array", items: { type: "string" } },
-        methods: { type: "array", items: { type: "string" } },
-        checkAssignments: { type: "boolean" }
+    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
       }
-    }],
-    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}}()."
     }
@@ -2633,16 +2913,18 @@ import { defineRule as defineRule23 } from "@oxlint/plugins";
 var noRederiveSchema = defineRule23({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        from: { type: "array", items: { type: "string" } },
-        namespaces: { type: "array", items: { type: "string" } },
-        operators: { type: "array", items: { type: "string" } }
-      },
-      required: ["from"]
-    }],
+    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 +2937,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)) {
@@ -2694,32 +2973,34 @@ function restrictedConstructorEntries(constructors) {
 var noRestrictedConstructor = defineRule24({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        constructors: {
-          type: "array",
-          items: {
-            anyOf: [
-              { type: "string" },
-              {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                  name: { type: "string" },
-                  message: { type: "string" }
-                },
-                required: ["name"]
-              }
-            ]
-          }
+    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}}"
@@ -2768,14 +3049,16 @@ import { defineRule as defineRule25 } from "@oxlint/plugins";
 var noRestrictedFiles = defineRule25({
   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}}"
     }
@@ -2809,37 +3092,36 @@ function memberMatches(node, restriction) {
 var noRestrictedToken = defineRule26({
   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 +3140,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);
@@ -3122,19 +3406,21 @@ function isRuntimeReExport(statement, runtimeImportLocals, valueNames, isAmbient
 var noRuntimeInTypes = defineRule27({
   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}}.",
@@ -3298,22 +3584,39 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options,
 var noSingleUseScalarSchema = defineRule28({
   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" }
+    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
       }
-    }],
-    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) {
@@ -3367,14 +3670,16 @@ import { defineRule as defineRule29 } from "@oxlint/plugins";
 var noTopLevelFunctions = defineRule29({
   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}}.",
@@ -3422,73 +3727,126 @@ 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;
-}
+
+// src/constants/trivial.constants.ts
+var trivialBannedNames = [
+  "isRecord",
+  "isPlainObject",
+  "isObject",
+  "isString",
+  "isNumber",
+  "isBoolean",
+  "isArray",
+  "asRecord",
+  "asArray"
+];
+
+// src/rules/no-trivial-functions.ts
 var noTrivialFunctions = defineRule30({
   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",
@@ -3505,13 +3863,15 @@ import { defineRule as defineRule31 } from "@oxlint/plugins";
 var noTypeDeclarations = defineRule31({
   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."
     }
@@ -3549,16 +3909,19 @@ import { defineRule as defineRule32 } from "@oxlint/plugins";
 var noUnescapedLike = defineRule32({
   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 +3935,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);
@@ -3633,15 +3998,17 @@ var objectMultiline = defineRule33({
   meta: {
     type: "layout",
     fixable: "whitespace",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        minProperties: { type: "integer", minimum: 1, default: 3 },
-        scope: { type: "string", enum: ["call-args", "all"], default: "call-args" },
-        indent: { ...layoutIndentSchema, default: 2 }
+    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."
@@ -3693,15 +4060,17 @@ import { defineRule as defineRule34 } from "@oxlint/plugins";
 var onlyExportComponents = defineRule34({
   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.",
@@ -3826,15 +4195,17 @@ function collectBindings(program) {
 var onlyExportConstants = defineRule35({
   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 +4213,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") {
@@ -3961,13 +4336,16 @@ var paddingBetweenStatements = defineRule36({
   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 +4353,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 +4373,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 +4391,7 @@ var paddingBetweenStatements = defineRule36({
       before() {
         const options = optionsFirst(context, {});
         returnMinStatements = options.returnMinStatements ?? 3;
+        multilineVariables = options.multilineVariables ?? false;
         source = context.sourceCode;
         newline = layoutNewline(source.text);
       },
@@ -4052,17 +4434,19 @@ var preferNamespaceTypeImport = defineRule37({
   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 +4531,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))
           });
         }
@@ -4161,15 +4551,17 @@ import { defineRule as defineRule38 } from "@oxlint/plugins";
 var requireFileFactory = defineRule38({
   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}}'."
     }
@@ -4208,15 +4600,18 @@ import { defineRule as defineRule39 } from "@oxlint/plugins";
 var requireObjectParams = defineRule39({
   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 +4619,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)) {
@@ -4257,16 +4659,18 @@ import { defineRule as defineRule40 } from "@oxlint/plugins";
 var requireOrpcOutput = defineRule40({
   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 +4682,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;
         }
@@ -4300,30 +4708,29 @@ import { defineRule as defineRule41 } from "@oxlint/plugins";
 var requirePairedCall = defineRule41({
   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."
     }
@@ -4376,16 +4783,20 @@ import { defineRule as defineRule42 } from "@oxlint/plugins";
 var routeSurface = defineRule42({
   meta: {
     type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        exportName: { type: "string" },
-        bannedHooks: { type: "array", items: { type: "string" } },
-        banIntrinsicJsx: { type: "boolean" }
+    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 }],
+    ],
+    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.",
@@ -4458,20 +4869,24 @@ function titlePatterns(pattern, flags) {
 var testTitlePattern = defineRule43({
   meta: {
     type: "suggestion",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        callees: { type: "array", items: { type: "string" } },
-        forbid: optionsPatternSchema,
-        require: optionsPatternSchema,
-        flags: { type: "string", pattern: "^[dgimsuvy]*$" }
+    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: ""
       }
-    }],
-    defaultOptions: [{
-      callees: ["describe", "it", "test"],
-      flags: ""
-    }],
+    ],
     messages: {
       forbidden: "Test title matches forbidden pattern '{{pattern}}'.",
       required: "Test title must match required pattern '{{pattern}}'."