oxlint-plugin-arch 0.3.4 → 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);
       },
@@ -4023,20 +4405,163 @@ var paddingBetweenStatements = defineRule36({
   }
 });
 
-// src/rules/require-file-factory.ts
+// src/rules/prefer-namespace-type-import.ts
 import { defineRule as defineRule37 } from "@oxlint/plugins";
-var requireFileFactory = defineRule37({
+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) {
+  if (Object.hasOwn(names, source)) {
+    return names[source];
+  }
+  const stem = namingFileBasename(source).replace(/(?:\.d)?\.[cm]?[jt]sx?$/i, "");
+  const name = namingPascalCase(stem.replace(/[^A-Za-z0-9_$.-]/g, "-")) || "Module";
+  const prefixed = /^\d/.test(name) ? `Module${name}` : name;
+  return prefixed.endsWith("Types") ? prefixed : `${prefixed}Types`;
+}
+function isTypeOnlyNamedImport(node) {
+  return node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && (node.importKind === "type" || specifier.importKind === "type"));
+}
+function safeReference(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent?.type === "TSQualifiedName" && parent.left === current || parent?.type === "MemberExpression" && !parent.computed && parent.object === current) {
+    current = parent;
+    parent = current.parent;
+  }
+  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({
   meta: {
-    type: "problem",
-    schema: [{
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        factory: { type: "string" },
-        allDeclarations: { type: "boolean" }
+    type: "suggestion",
+    fixable: "code",
+    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 `import type * as {{name}} from '{{source}}'` for {{count}} type imports (max {{max}}); keep exported domain names.{{reason}}"
+    }
+  },
+  createOnce(context) {
+    const imports = [];
+    return {
+      before() {
+        imports.length = 0;
       },
-      required: ["factory"]
-    }],
+      ImportDeclaration(node) {
+        imports.push(node);
+      },
+      "Program:exit"() {
+        const { max, names } = optionsFirst(context);
+        const candidates = imports.filter((node) => isTypeOnlyNamedImport(node) && node.specifiers.length > max);
+        if (candidates.length === 0) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const occupied = new Set;
+        for (const scope of sourceCode.scopeManager.scopes) {
+          for (const variable of scope.variables) {
+            occupied.add(variable.name);
+          }
+          for (const reference of scope.references) {
+            occupied.add(reference.identifier.name);
+          }
+        }
+        const proposed = candidates.map((node) => namespaceName(node.source.value, names));
+        const comments = sourceCode.getAllComments();
+        const reports = [];
+        const edits = [];
+        for (const [index, node] of candidates.entries()) {
+          const name = proposed[index];
+          let reason = "";
+          const replacements = new Map;
+          if (!bindingName.test(name) || reservedNames.has(name)) {
+            reason = "invalid namespace binding";
+          } else if (imports.some((other) => other.source.value === node.source.value && other.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier"))) {
+            reason = "existing namespace import from this module";
+          } else if (occupied.has(name) || proposed.some((other, otherIndex) => otherIndex !== index && other === name)) {
+            reason = "namespace name collides with a binding, reference, or another proposed namespace";
+          } else if (comments.some((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1])) {
+            reason = "comment inside import";
+          } else {
+            const variables = sourceCode.getDeclaredVariables(node);
+            for (const specifier of node.specifiers) {
+              if (specifier.type !== "ImportSpecifier") {
+                continue;
+              }
+              const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+              const variable = variables.find((binding) => binding.identifiers.some((id) => id.range[0] === specifier.local.range[0]));
+              if (!bindingName.test(imported) || !variable || variable.defs.length !== 1) {
+                reason = "unsupported imported name or binding";
+                break;
+              }
+              for (const reference of variable.references) {
+                const identifier = reference.identifier;
+                if (identifier.parent.type === "ExportSpecifier") {
+                  reason = "local re-export";
+                  break;
+                }
+                if (!safeReference(identifier)) {
+                  reason = "unsupported reference syntax";
+                  break;
+                }
+                replacements.set(identifier, `${name}.${imported}`);
+              }
+              if (reason) {
+                break;
+              }
+            }
+          }
+          reports.push({ node, name, reason });
+          if (!reason) {
+            edits.push({ range: [node.range[0], node.source.range[0]], text: `import type * as ${name} from ` });
+            for (const [identifier, text] of replacements) {
+              edits.push({ range: identifier.range, text });
+            }
+          }
+        }
+        for (const { node, name, reason } of reports) {
+          context.report({
+            node,
+            messageId: "namespace",
+            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))
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-file-factory.ts
+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"]
+      }
+    ],
     messages: {
       factory: "Function '{{actual}}' must be named '{{expected}}'."
     }
@@ -4071,19 +4596,22 @@ var requireFileFactory = defineRule37({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
-var requireObjectParams = defineRule38({
+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}}."
     }
@@ -4091,10 +4619,17 @@ var requireObjectParams = defineRule38({
   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)) {
@@ -4120,20 +4655,22 @@ var requireObjectParams = defineRule38({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule39({
+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."
@@ -4145,7 +4682,11 @@ var requireOrpcOutput = defineRule39({
         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;
         }
@@ -4163,34 +4704,33 @@ var requireOrpcOutput = defineRule39({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var requirePairedCall = defineRule40({
+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."
     }
@@ -4239,20 +4779,24 @@ var requirePairedCall = defineRule40({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var routeSurface = defineRule41({
+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.",
@@ -4282,7 +4826,7 @@ var routeSurface = defineRule41({
 });
 
 // src/rules/test-title-pattern.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule43 } from "@oxlint/plugins";
 var TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "todo", "each"]);
 function isConfiguredName(name, callees) {
   if (!name) {
@@ -4322,23 +4866,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 = defineRule42({
+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}}'."
@@ -4433,6 +4981,7 @@ var src_default = eslintCompatPlugin({
     "only-export-components": onlyExportComponents,
     "only-export-constants": onlyExportConstants,
     "padding-between-statements": paddingBetweenStatements,
+    "prefer-namespace-type-import": preferNamespaceTypeImport,
     "require-file-factory": requireFileFactory,
     "require-object-params": requireObjectParams,
     "require-orpc-output": requireOrpcOutput,