oxlint-plugin-arch 0.12.6 → 0.13.0

package/dist/index.js

@@ -37,7 +37,7 @@ function optionsPatternsTest(patterns, value) {
 function optionsGlob(pattern) {
   const negated = [];
   const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
-    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\?{}]/g, "\\$&").replaceAll("*", "[^/]*")).join("|"));
     return `\x02${negated.length - 1}\x03`;
   }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
   return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
@@ -283,16 +283,14 @@ var backendOrpcOutput = defineRule2({
         type: "object",
         additionalProperties: false,
         properties: {
-          composers: { type: "array", items: { type: "string" } },
           handler: { type: "string" },
           output: { 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."
+      invalid: "oRPC .output() must use a named schema or a plain function called with a named schema."
     }
   },
   createOnce(context) {
@@ -301,7 +299,7 @@ var backendOrpcOutput = defineRule2({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { composers, handler: handlerMethod = "handler", output: outputMethod = "output" } = optionsFirst(context);
+        const { handler: handlerMethod = "handler", output: outputMethod = "output" } = optionsFirst(context, {});
         if (astMemberName(node.callee) !== handlerMethod) {
           return;
         }
@@ -311,7 +309,7 @@ var backendOrpcOutput = defineRule2({
           return;
         }
         const schema = output.arguments.at(0);
-        const named = schema?.type === "Identifier" || schema?.type === "CallExpression" && schema.callee.type === "Identifier" && composers.includes(schema.callee.name) && schema.arguments[0]?.type === "Identifier";
+        const named = schema?.type === "Identifier" || schema?.type === "CallExpression" && schema.callee.type === "Identifier" && schema.arguments[0]?.type === "Identifier";
         if (!named) {
           context.report({ node: output, messageId: "invalid" });
         }
@@ -971,6 +969,12 @@ function boundariesResolveTarget(options, file, source) {
 }
 
 // src/rules/backend/backend-sql-like.ts
+var backendSqlLikeDefaults = {
+  methods: ["like", "ilike"],
+  sanitizers: ["escapeLikeWildcards"],
+  bindings: true,
+  operators: ["where"]
+};
 var backendSqlLike = defineRule5({
   meta: {
     type: "problem",
@@ -983,17 +987,16 @@ var backendSqlLike = defineRule5({
           sanitizers: { type: "array", items: { type: "string" } },
           bindings: { type: "boolean" },
           operators: { type: "array", items: { type: "string" } }
-        },
-        required: ["methods", "sanitizers"]
+        }
       }
     ],
     messages: { unescaped: ".{{method}}() values must use a configured sanitizer." }
   },
   createOnce(context) {
-    let options = { methods: [], sanitizers: [] };
+    let options = backendSqlLikeDefaults;
     const seen = new Set;
     function sanitizedBinding(identifier, name) {
-      const variable = options.bindings === false ? null : boundariesDeclaredVariable(context.sourceCode.getScope(identifier), name);
+      const variable = options.bindings ? boundariesDeclaredVariable(context.sourceCode.getScope(identifier), name) : null;
       const declarator = variable?.defs.length === 1 && variable.defs[0].type === "Variable" ? variable.defs[0].node : undefined;
       const statement = declarator?.parent?.parent;
       if (!variable || declarator?.type !== "VariableDeclarator" || seen.has(variable) || !(statement?.type === "Program" || statement?.type === "ExportNamedDeclaration" && statement.parent.type === "Program") || variable.references.some((reference) => reference.isWrite() && !reference.init)) {
@@ -1034,8 +1037,8 @@ var backendSqlLike = defineRule5({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        options = optionsFirst(context);
-        const { methods, operators: operatorMethods = [] } = options;
+        options = { ...backendSqlLikeDefaults, ...optionsFirst(context, {}) };
+        const { methods, operators: operatorMethods } = options;
         const method = astMemberName(node.callee);
         if (!method) {
           return;
@@ -2016,12 +2019,82 @@ var codeConstructor = defineRule13({
   }
 });
 
+// src/rules/code/code-delegate.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var codeDelegate = defineRule14({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          methods: { type: "array", items: { type: "string" } },
+          reads: { type: "array", items: { type: "string" } },
+          max: { type: "integer", minimum: 0 }
+        }
+      }
+    ],
+    messages: {
+      statement: "A handler only delegates: read services, make one call, return. Move this to an action.",
+      calls: "A handler's yielded or awaited calls are limited to {{max}}; move the rest into the action it calls.",
+      ternary: "A handler does not branch; move the condition into the action it calls.",
+      nested: "A handler holds no function; move it into the action it calls."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const { methods = ["handler", "effect"], reads = ["Effect.serviceOption"], max = 1 } = optionsFirst(context, {});
+        if (!methods.includes(astCallName(node) ?? "")) {
+          return;
+        }
+        const awaited = (value) => value?.type === "YieldExpression" || value?.type === "AwaitExpression";
+        for (const handler of node.arguments.filter(astIsInlineFunction)) {
+          let calls = 0;
+          const scan = (value) => astSome(value, (child) => {
+            if (child.type === "ConditionalExpression") {
+              context.report({ node: child, messageId: "ternary" });
+            }
+            if (child.type === "FunctionDeclaration" || astIsInlineFunction(child)) {
+              context.report({ node: child, messageId: "nested" });
+            }
+            const target = awaited(child) && "argument" in child ? child.argument : null;
+            if (target?.type === "CallExpression" && !reads.includes(astDottedName(target.callee) ?? "")) {
+              calls += 1;
+              if (calls > max) {
+                context.report({
+                  node: child,
+                  messageId: "calls",
+                  data: { max: String(max) }
+                });
+              }
+            }
+            return false;
+          }, (child) => child.type !== "FunctionDeclaration" && !astIsInlineFunction(child));
+          const { body } = handler;
+          if (body && body.type !== "BlockStatement") {
+            scan(body);
+          }
+          for (const statement of body?.type === "BlockStatement" ? body.body : []) {
+            const allowed = statement.type === "ReturnStatement" || statement.type === "VariableDeclaration" && statement.declarations.every((declarator) => awaited(declarator.init)) || statement.type === "ExpressionStatement" && awaited(statement.expression) && "argument" in statement.expression && statement.expression.argument?.type === "CallExpression";
+            if (!allowed) {
+              context.report({ node: statement, messageId: "statement" });
+            }
+            scan(statement);
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/code/code-double-negation.ts
 var codeDoubleNegation = astSelectorRule('UnaryExpression[operator="!"] > UnaryExpression[operator="!"]', "Use Boolean(value) or an explicit comparison.");
 
 // src/rules/code/code-function-nesting.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var codeFunctionNesting = defineRule14({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var codeFunctionNesting = defineRule15({
   meta: {
     type: "suggestion",
     schema: [
@@ -2062,7 +2135,7 @@ var codeFunctionNesting = defineRule14({
 });
 
 // src/rules/code/code-inline.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } from "@oxlint/plugins";
 
 // src/utils/source.utils.ts
 var sourceDirective = /^\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])/;
@@ -2147,7 +2220,7 @@ var codeInlineEffects = new Set([
 function codeInlineEffectBetween(program, start, end) {
   return astSome(program, (node) => node.range[0] >= start && node.range[1] <= end && (codeInlineEffects.has(node.type) || node.type === "UnaryExpression" && node.operator === "delete"), (node) => node.range[1] > start && node.range[0] < end && !(node.range[0] >= start && (node.type === "FunctionDeclaration" || astIsInlineFunction(node))));
 }
-var codeInline = defineRule15({
+var codeInline = defineRule16({
   meta: {
     type: "suggestion",
     schema: [
@@ -2260,8 +2333,8 @@ var codeInline = defineRule15({
 });
 
 // src/rules/code/code-justified-call.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var codeJustifiedCall = defineRule16({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var codeJustifiedCall = defineRule17({
   meta: {
     type: "problem",
     schema: [
@@ -2315,8 +2388,8 @@ var codeJustifiedCall = defineRule16({
 });
 
 // src/rules/code/code-literal-in.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var codeLiteralIn = defineRule17({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var codeLiteralIn = defineRule18({
   meta: {
     type: "suggestion",
     schema: [
@@ -2357,7 +2430,7 @@ var codeLiteralIn = defineRule17({
 });
 
 // src/rules/code/code-mutable-state.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 var functionScopes = new Set([
   "FunctionDeclaration",
   "FunctionExpression",
@@ -2374,7 +2447,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule18({
+var codeMutableState = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2432,7 +2505,7 @@ var codeMutableState = defineRule18({
 });
 
 // src/rules/code/code-object-params.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function isObjectParam(node) {
   if (node.type === "ObjectPattern") {
     return true;
@@ -2446,7 +2519,7 @@ function isObjectParam(node) {
   const annotation = node.typeAnnotation?.typeAnnotation;
   return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
 }
-var codeObjectParams = defineRule19({
+var codeObjectParams = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2495,8 +2568,8 @@ var codeObjectParams = defineRule19({
 });
 
 // src/rules/code/code-paired-call.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var codePairedCall = defineRule20({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var codePairedCall = defineRule21({
   meta: {
     type: "problem",
     schema: [
@@ -2563,7 +2636,7 @@ var codePairedCall = defineRule20({
 });
 
 // src/rules/code/code-promise-mutation.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2592,7 +2665,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule21({
+var codePromiseMutation = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2685,8 +2758,8 @@ var codePromiseMutation = defineRule21({
 var codeSwitch = astSelectorRule("SwitchStatement", "Avoid switch statements.");
 
 // src/rules/code/code-traced.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var codeTraced = defineRule22({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var codeTraced = defineRule23({
   meta: {
     type: "problem",
     schema: [
@@ -2773,7 +2846,7 @@ var codeTraced = defineRule22({
 });
 
 // src/rules/code/code-trivial-functions.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 var codeTrivialFunctionsBanned = [
   "isRecord",
   "isPlainObject",
@@ -2903,7 +2976,35 @@ function guardStatement(node, state) {
     return guardFallback(declaration.init);
   });
 }
-var codeTrivialFunctions = defineRule23({
+function codeTrivialFunctionsDefaults(program) {
+  const starts = [];
+  const names = new Set;
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportDefaultDeclaration" ? statement.declaration : undefined;
+    if (declaration?.type === "FunctionDeclaration" || declaration && astIsInlineFunction(declaration)) {
+      starts.push(declaration.start);
+    } else if (declaration?.type === "Identifier") {
+      names.add(declaration.name);
+    } else if (statement.type === "ExportNamedDeclaration" && !statement.source) {
+      const specifier = statement.specifiers.find((item) => astModuleName(item.exported) === "default");
+      if (specifier) {
+        names.add(astModuleName(specifier.local));
+      }
+    }
+  }
+  for (const statement of program.body) {
+    if (statement.type === "FunctionDeclaration" && statement.id && names.has(statement.id.name)) {
+      starts.push(statement.start);
+    }
+    for (const declarator of statement.type === "VariableDeclaration" ? statement.declarations : []) {
+      if (declarator.id.type === "Identifier" && names.has(declarator.id.name) && declarator.init && astIsInlineFunction(declarator.init)) {
+        starts.push(declarator.init.start);
+      }
+    }
+  }
+  return starts;
+}
+var codeTrivialFunctions = defineRule24({
   meta: {
     type: "problem",
     schema: [
@@ -2917,7 +3018,8 @@ var codeTrivialFunctions = defineRule23({
           services: { type: "boolean" },
           mode: { type: "string", enum: ["legacy", "precise"] },
           deny: { type: "array", items: { type: "string" }, uniqueItems: true },
-          guards: { type: "boolean" }
+          guards: { type: "boolean" },
+          defaults: { type: "boolean" }
         }
       }
     ],
@@ -2937,8 +3039,10 @@ var codeTrivialFunctions = defineRule23({
     let checkServiceMethods = false;
     const reported = new Set;
     const checked = new Set;
+    const defaults = new Set;
+    let checkDefaults = true;
     function checkHelper(node) {
-      if (bannedNames.size === 0 && !checkGenericGuards || checked.has(node.start)) {
+      if (bannedNames.size === 0 && !checkGenericGuards || checked.has(node.start) || defaults.has(node.start)) {
         return;
       }
       checked.add(node.start);
@@ -3003,12 +3107,20 @@ var codeTrivialFunctions = defineRule23({
         allowAsync = options.async ?? false;
         reported.clear();
         checked.clear();
+        defaults.clear();
+        checkDefaults = options.defaults ?? true;
       },
       FunctionDeclaration: checkHelper,
       FunctionExpression: checkHelper,
       ArrowFunctionExpression: checkHelper,
       Program(program) {
+        for (const start of checkDefaults ? [] : codeTrivialFunctionsDefaults(program)) {
+          defaults.add(start);
+        }
         for (const { name, node } of exportsCheckedFunctions(program, true, checkServiceMethods, allowed)) {
+          if (defaults.has(node.start)) {
+            continue;
+          }
           checkHelper(node);
           if (reported.has(node.start) || node.returnType?.typeAnnotation.type === "TSTypePredicate") {
             continue;
@@ -3034,8 +3146,8 @@ var codeTrivialFunctions = defineRule23({
 });
 
 // src/rules/code/code-yield-argument.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var codeYieldArgument = defineRule24({
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var codeYieldArgument = defineRule25({
   meta: {
     type: "suggestion",
     messages: {
@@ -3057,7 +3169,7 @@ var codeYieldArgument = defineRule24({
 });
 
 // src/rules/comments/comments-code.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 var commentsLineGap = /^[\t \r\n\u2028\u2029]*$/;
 var commentsLineTerminator = /\r\n|[\n\r\u2028\u2029]/;
 var commentsUnicodeTerminator = /[\u2028\u2029]/;
@@ -3108,7 +3220,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule25({
+var commentsCode = defineRule26({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -3274,9 +3386,9 @@ var commentsCode = defineRule25({
 });
 
 // src/rules/comments/comments-directives.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 var directive = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s;
-var commentsDirectives = defineRule26({
+var commentsDirectives = defineRule27({
   meta: {
     type: "problem",
     schema: [],
@@ -3304,9 +3416,9 @@ var commentsDirectives = defineRule26({
 });
 
 // src/rules/copy/copy-dashes.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } from "@oxlint/plugins";
 var copyDashesMessage = "Use a comma, colon, period or parentheses instead.";
-var copyDashes = defineRule27({
+var copyDashes = defineRule28({
   meta: {
     type: "suggestion",
     schema: [
@@ -3362,7 +3474,7 @@ var copyDashes = defineRule27({
 });
 
 // src/rules/effect/effect-layer-file.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 
 // src/utils/effect.utils.ts
 var effectBuilders = ["Effect.gen", "Effect.fn", "Effect.fnUntraced"];
@@ -3404,7 +3516,7 @@ var effectLayerFileDefaultConstructors = [
   "Layer.sync",
   "Layer.unwrap"
 ];
-var effectLayerFile = defineRule28({
+var effectLayerFile = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3567,7 +3679,7 @@ var effectLayerFile = defineRule28({
 });
 
 // src/rules/effect/effect-layers.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 var effectLayersDefaultMerge = ["Layer.mergeAll"];
 var effectLayersDefaultProvide = ["Effect.provide", "Layer.provide", "Layer.provideMerge"];
 var effectLayersDefaultMin = 2;
@@ -3579,7 +3691,7 @@ var effectLayersGroupSchema = {
     min: { type: "integer", minimum: 1 }
   }
 };
-var effectLayers = defineRule29({
+var effectLayers = defineRule30({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -3661,11 +3773,11 @@ var effectLayers = defineRule29({
 });
 
 // src/rules/effect/effect-merge-pipe.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule31 } from "@oxlint/plugins";
 var effectMergePipeDefaultMerge = ["Layer.mergeAll"];
 var effectMergePipeDefaultPipe = ["pipe", "Function.pipe"];
 var effectMergePipeDefaultMethods = ["pipe"];
-var effectMergePipe = defineRule30({
+var effectMergePipe = defineRule31({
   meta: {
     type: "layout",
     schema: [
@@ -3710,7 +3822,7 @@ var effectMergePipe = defineRule30({
 });
 
 // src/rules/effect/effect-schema-first.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 var effectSchemaFirstDefaultRuntime = [
   "Effect",
   "Layer",
@@ -3772,7 +3884,7 @@ function effectSchemaFirstReference(node) {
   }
   return node.type === "TSInterfaceHeritage" ? astDottedName(node.expression) : undefined;
 }
-var effectSchemaFirst = defineRule31({
+var effectSchemaFirst = defineRule32({
   meta: {
     type: "suggestion",
     schema: [
@@ -3945,7 +4057,7 @@ var effectSchemaFirst = defineRule31({
 });
 
 // src/rules/effect/effect-values-first.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
+import { defineRule as defineRule33 } from "@oxlint/plugins";
 var effectValuesFirstDefaultPinned = [
   "^Layer\\.",
   "^Context\\.",
@@ -3954,7 +4066,7 @@ var effectValuesFirstDefaultPinned = [
   "(?:^|\\.)layer[^.]*$",
   "^Schema\\.(?:asserts|decode\\w*|encode\\w*|is|isSchema|isSchemaError|resolveAnnotations)$"
 ];
-var effectValuesFirst = defineRule32({
+var effectValuesFirst = defineRule33({
   meta: {
     type: "suggestion",
     schema: [
@@ -4037,7 +4149,7 @@ var effectValuesFirst = defineRule32({
 });
 
 // src/rules/files/files-components-only.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 
 // src/utils/react.utils.ts
 function reactReturnsOutput(program, node) {
@@ -4109,7 +4221,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule33({
+var filesComponentsOnly = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -4197,7 +4309,7 @@ var filesComponentsOnly = defineRule33({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } from "@oxlint/plugins";
 function unwrap(expression) {
   if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "TSInstantiationExpression") {
     return unwrap(expression.expression);
@@ -4252,7 +4364,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule34({
+var filesConstantsOnly = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -4351,7 +4463,7 @@ var filesConstantsOnly = defineRule34({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -4369,7 +4481,7 @@ function isData(expression) {
   }
   return value.type === "NewExpression" && value.callee.type === "Identifier" && ["Map", "Set"].includes(value.callee.name) && value.arguments[0]?.type === "ArrayExpression" && value.arguments[0].elements.length > 0;
 }
-var filesDomainConstants = defineRule35({
+var filesDomainConstants = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -4434,11 +4546,12 @@ var filesDomainConstants = defineRule35({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { posix as posix2 } from "node:path";
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var filesExports = defineRule36({
+var filesExports = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4448,7 +4561,8 @@ var filesExports = defineRule36({
         properties: {
           names: { type: "array", items: { type: "string" } },
           patterns: { type: "array", items: { type: "string" } },
-          stem: { type: "string", enum: [...namingStemModes] },
+          stem: { type: "string", enum: [...namingStemModes, "folder"] },
+          singularize: { type: "string", enum: ["none", "trailing-s"] },
           roles: { type: "array", items: { type: "string" } },
           separators: { type: "array", items: { type: "string" } },
           types: { type: "boolean" },
@@ -4491,7 +4605,9 @@ var filesExports = defineRule36({
         if (options.names === undefined && options.patterns === undefined) {
           return;
         }
-        const domain = namingFileStem(basename3, options.stem, options.roles, options.separators);
+        const read = options.stem === "folder" ? namingBasename(posix2.dirname(context.filename.replaceAll("\\", "/"))) : namingFileStem(basename3, options.stem, options.roles, options.separators);
+        const last = read.split(/[-_]+/).at(-1) ?? "";
+        const domain = options.singularize === "trailing-s" && last.length > 1 && last.endsWith("s") ? read.slice(0, -1) : read;
         const pascalDomain = namingPascalCase(domain);
         const camelDomain = namingCamelCase(domain);
         const allowed = (options.names ?? []).map((template) => template.replaceAll("{Domain}", pascalDomain).replaceAll("{domain}", camelDomain));
@@ -4519,12 +4635,12 @@ var filesExports = defineRule36({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { builtinModules as builtinModules2 } from "node:module";
 import { dirname as dirname3, join as join2 } from "node:path";
 var filesExternalsConfigs = "^(?:vite|next)\\.config\\.[cm]?[jt]s$";
-var filesExternals = defineRule37({
+var filesExternals = defineRule38({
   meta: {
     type: "problem",
     schema: [
@@ -4617,7 +4733,7 @@ var filesExternals = defineRule37({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule39 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -4628,7 +4744,7 @@ function compileKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return { patterns: optionsPatternsWithEmpty(pattern), allowed: new Set(allowedList), allowedList, required: requireKeys };
 }
-var filesFactoryKeys = defineRule38({
+var filesFactoryKeys = defineRule39({
   meta: {
     type: "problem",
     schema: [
@@ -4746,8 +4862,8 @@ var filesFactoryKeys = defineRule38({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var filesHelpers = defineRule39({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var filesHelpers = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4795,8 +4911,8 @@ var filesHelpers = defineRule39({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule40({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4850,8 +4966,8 @@ var filesNoFunctions = defineRule40({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
-var filesRestricted = defineRule41({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var filesRestricted = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4883,7 +4999,7 @@ var filesRestricted = defineRule41({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule43 } from "@oxlint/plugins";
 function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
   astVisit(item.node.body, [item.node], (node) => {
     if (banIntrinsicJsx && node.type === "JSXOpeningElement" && node.name.type === "JSXIdentifier" && /^[a-z]/.test(node.name.name)) {
@@ -4903,7 +5019,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule42({
+var filesRoute = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4973,7 +5089,7 @@ var filesRoute = defineRule42({
 });
 
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
+import { defineRule as defineRule44 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -5142,7 +5258,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule43({
+var filesTypesOnly = defineRule44({
   meta: {
     type: "problem",
     schema: [
@@ -5250,8 +5366,8 @@ var filesTypesOnly = defineRule43({
 });
 
 // src/rules/layout/layout-arrow-body.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
-var layoutArrowBody = defineRule44({
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule45({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5303,12 +5419,12 @@ var layoutArrowBody = defineRule44({
 });
 
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } from "@oxlint/plugins";
 function layoutCallArgumentsHuggable(node) {
   return astIsInlineFunction(node) || node.type === "ObjectExpression" || node.type === "ArrayExpression" || astIsCall(node) && node.arguments.length === 1 && (node.callee.type !== "MemberExpression" || astIsOneLine(node.callee)) && node.arguments.every(layoutCallArgumentsHuggable);
 }
 var layoutCallArgumentsMax = { type: "integer", minimum: 1 };
-var layoutCallArguments = defineRule45({
+var layoutCallArguments = defineRule46({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5490,12 +5606,12 @@ var layoutCallArguments = defineRule45({
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
+import { defineRule as defineRule47 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule46({
+var layoutCallArray = defineRule47({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5611,7 +5727,7 @@ var layoutCallArray = defineRule46({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
+import { defineRule as defineRule48 } from "@oxlint/plugins";
 function layoutCallDepthOuter(node) {
   const parent = node.parent;
   if (!parent || parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type.endsWith("Statement")) {
@@ -5619,7 +5735,7 @@ function layoutCallDepthOuter(node) {
   }
   return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent);
 }
-var layoutCallDepth = defineRule47({
+var layoutCallDepth = defineRule48({
   meta: {
     type: "layout",
     schema: [
@@ -5658,8 +5774,8 @@ var layoutCallDepth = defineRule47({
 });
 
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
-var layoutChain = defineRule48({
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+var layoutChain = defineRule49({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5778,8 +5894,8 @@ var layoutChain = defineRule48({
 });
 
 // src/rules/layout/layout-items.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
-var layoutItems = defineRule49({
+import { defineRule as defineRule50 } from "@oxlint/plugins";
+var layoutItems = defineRule50({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5834,8 +5950,8 @@ var layoutItems = defineRule49({
 });
 
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule50({
+import { defineRule as defineRule51 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule51({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5923,8 +6039,8 @@ var layoutJsxAttributes = defineRule50({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule51({
+import { defineRule as defineRule52 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule52({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5960,7 +6076,7 @@ var layoutKeyValue = defineRule51({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
@@ -5968,7 +6084,7 @@ function layoutObjectIsFlat(property) {
   const value = property.type === "SpreadElement" ? property.argument : property.value;
   return astIsOneLine(property) && (property.type === "SpreadElement" || !property.method && property.kind === "init") && value.type !== "ObjectExpression" && value.type !== "ArrayExpression" && !astIsInlineFunction(value);
 }
-var layoutObject = defineRule52({
+var layoutObject = defineRule53({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6085,7 +6201,7 @@ var layoutObject = defineRule52({
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule54 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -6114,7 +6230,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule53({
+var layoutPadding = defineRule54({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6203,8 +6319,8 @@ var layoutPadding = defineRule53({
 });
 
 // src/rules/layout/layout-pipe.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
-var layoutPipe = defineRule54({
+import { defineRule as defineRule55 } from "@oxlint/plugins";
+var layoutPipe = defineRule55({
   meta: {
     type: "layout",
     messages: {
@@ -6235,7 +6351,7 @@ var layoutPipe = defineRule54({
 });
 
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
+import { defineRule as defineRule56 } from "@oxlint/plugins";
 function layoutTernaryLines(node) {
   return node.loc.end.line - node.loc.start.line + 1;
 }
@@ -6243,7 +6359,7 @@ function layoutTernaryBreak(between, operator, newline) {
   const at = between.indexOf(operator);
   return `${between.slice(0, at).trimEnd()}${newline}${operator} ${between.slice(at + 1).trimStart()}`;
 }
-var layoutTernary = defineRule55({
+var layoutTernary = defineRule56({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -6359,9 +6475,9 @@ var layoutTernary = defineRule55({
 });
 
 // src/rules/naming/naming-declarations.ts
-import { defineRule as defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule57 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule56({
+var namingDeclarations = defineRule57({
   meta: {
     type: "problem",
     schema: [
@@ -6438,7 +6554,7 @@ var namingDeclarations = defineRule56({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule57 } from "@oxlint/plugins";
+import { defineRule as defineRule58 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -6464,7 +6580,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule57({
+var namingExports = defineRule58({
   meta: {
     type: "problem",
     schema: {
@@ -6601,10 +6717,10 @@ var namingExports = defineRule57({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
+import { defineRule as defineRule59 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule58({
+var namingFile = defineRule59({
   meta: {
     type: "problem",
     schema: {
@@ -6674,9 +6790,9 @@ var namingFile = defineRule58({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
-import { posix as posix2 } from "node:path";
-var namingFolder = defineRule59({
+import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { posix as posix3 } from "node:path";
+var namingFolder = defineRule60({
   meta: {
     type: "problem",
     schema: [
@@ -6699,7 +6815,7 @@ var namingFolder = defineRule59({
     return {
       Program(program) {
         const { singularize = "trailing-s", separators = ["-"], after, prefixes: stripPrefixes = [] } = optionsFirst(context, {});
-        const all = posix2.dirname(context.filename.replaceAll("\\", "/")).split("/").filter((part) => part && part !== ".");
+        const all = posix3.dirname(context.filename.replaceAll("\\", "/")).split("/").filter((part) => part && part !== ".");
         const parent = [all.at(-1) ?? ""];
         let folders = after ? undefined : parent;
         const marker = (after ?? "").split("/").filter(Boolean);
@@ -6750,9 +6866,9 @@ var reactDynamicClasses = astSelectorRule(':matches(JSXAttribute[name.name="clas
 var reactEmptyEffect = astSelectorRule(':matches(CallExpression[callee.name=/^use(Layout)?Effect$/], CallExpression[callee.object.name="React"][callee.property.name=/^use(Layout)?Effect$/]) > :matches(ArrowFunctionExpression, FunctionExpression) > BlockStatement[body.length=0]', "Remove the empty effect.");
 
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { defineRule as defineRule61 } from "@oxlint/plugins";
 var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule60({
+var reactMemo = defineRule61({
   meta: {
     type: "problem",
     schema: [],
@@ -6787,7 +6903,7 @@ var reactMemo = defineRule60({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
+import { defineRule as defineRule62 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -6814,7 +6930,7 @@ function reactIsPassThrough(type) {
   const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
   return name.type === "Identifier" && name.name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
 }
-var reactProps = defineRule61({
+var reactProps = defineRule62({
   meta: {
     type: "problem",
     schema: [
@@ -6912,8 +7028,90 @@ var reactProps = defineRule61({
   }
 });
 
+// src/rules/react/react-query-props.ts
+import { defineRule as defineRule63 } from "@oxlint/plugins";
+var reactQueryProps = defineRule63({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          hooks: { type: "array", items: { type: "string" } },
+          functions: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      options: "Build the {{hook}} options here from props; ready-made options hide where the data comes from.",
+      source: "{{key}} must be a prop or call one; pass the data function in from the app."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const { hooks = ["useQuery", "useMutation", "useInfiniteQuery", "useSuspenseQuery"], functions = ["queryFn", "mutationFn"] } = optionsFirst(context, {});
+        const hook = astCallName(node);
+        let owner = node.parent;
+        while (owner && owner.type !== "FunctionDeclaration" && !astIsInlineFunction(owner)) {
+          owner = owner.parent;
+        }
+        if (!hook || !hooks.includes(hook) || !owner || owner.type !== "FunctionDeclaration" && !astIsInlineFunction(owner)) {
+          return;
+        }
+        const component = owner;
+        const first = component.params.at(0);
+        const parameter = first?.type === "AssignmentPattern" ? first.left : first;
+        const definition = (identifier) => boundariesDeclaredVariable(context.sourceCode.getScope(identifier), identifier.name)?.defs.at(0);
+        const isProps = (value) => {
+          const found = value?.type === "Identifier" ? definition(value) : undefined;
+          return found?.type === "Parameter" && found.node === component && parameter?.type === "Identifier";
+        };
+        const isProp = (value) => {
+          if (value.type === "MemberExpression") {
+            return isProps(value.object);
+          }
+          const found = value.type === "Identifier" ? definition(value) : undefined;
+          if (found?.type === "Parameter") {
+            return found.node === component && parameter?.type === "ObjectPattern";
+          }
+          return found?.type === "Variable" && found.node.type === "VariableDeclarator" && found.node.id.type === "ObjectPattern" && isProps(found.node.init);
+        };
+        const options = node.arguments.at(0);
+        if (options?.type !== "ObjectExpression" || options.properties.some((property) => property.type === "SpreadElement")) {
+          context.report({
+            node: options ?? node,
+            messageId: "options",
+            data: { hook }
+          });
+          return;
+        }
+        for (const property of options.properties) {
+          if (property.type !== "Property") {
+            continue;
+          }
+          const key = property.key.type === "Identifier" && !property.computed ? property.key.name : astStaticString(property.key);
+          if (key === undefined || !functions.includes(key)) {
+            continue;
+          }
+          const { value } = property;
+          const calls = astIsInlineFunction(value) && astSome(value.body, (child) => child.type === "CallExpression" && isProp(child.callee));
+          if (!isProp(value) && !calls) {
+            context.report({
+              node: value,
+              messageId: "source",
+              data: { key }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
+import { defineRule as defineRule64 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -6949,7 +7147,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule62({
+var schemasInline = defineRule64({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -6998,11 +7196,11 @@ var schemasInline = defineRule62({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
-var schemasLocal = defineRule63({
+var schemasLocal = defineRule65({
   meta: {
     type: "problem",
     schema: [
@@ -7151,8 +7349,8 @@ var schemasLocal = defineRule63({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
-var schemasRederive = defineRule64({
+import { defineRule as defineRule66 } from "@oxlint/plugins";
+var schemasRederive = defineRule66({
   meta: {
     type: "problem",
     schema: [
@@ -7198,7 +7396,7 @@ var schemasRederive = defineRule64({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
+import { defineRule as defineRule67 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -7212,7 +7410,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule65({
+var schemasSingleUse = defineRule67({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -7288,7 +7486,7 @@ var schemasSingleUse = defineRule65({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
+import { defineRule as defineRule68 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -7478,7 +7676,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule66({
+var testsAssertions = defineRule68({
   meta: {
     type: "problem",
     schema: [
@@ -7604,8 +7802,8 @@ var testsAssertions = defineRule66({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule67({
+import { defineRule as defineRule69 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule69({
   meta: {
     type: "problem",
     schema: [
@@ -7661,7 +7859,7 @@ var testsConcurrentDb = defineRule67({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
+import { defineRule as defineRule70 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
 var testsModifiersBanned = ["only", "skip", "todo"];
@@ -7680,7 +7878,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule68({
+var testsModifiers = defineRule70({
   meta: {
     type: "problem",
     schema: [
@@ -7734,9 +7932,9 @@ var testsModifiers = defineRule68({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
+import { defineRule as defineRule71 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule69({
+var testsTitles = defineRule71({
   meta: {
     type: "suggestion",
     schema: [
@@ -7814,11 +8012,11 @@ var testsTitles = defineRule69({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
+import { defineRule as defineRule72 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule70({
+var typesDeclarations = defineRule72({
   meta: {
     type: "problem",
     schema: [
@@ -7826,7 +8024,8 @@ var typesDeclarations = defineRule70({
         type: "object",
         additionalProperties: false,
         properties: {
-          allow: optionsPatternSchema
+          allow: optionsPatternSchema,
+          modules: { type: "boolean" }
         }
       }
     ],
@@ -7837,8 +8036,14 @@ var typesDeclarations = defineRule70({
   createOnce(context) {
     let allowedNames = [];
     let allowedValues = [];
+    let allowModules = false;
     function check(node) {
-      if (optionsPatternsTest(allowedNames, node.id.name) || node.type === "TSTypeAliasDeclaration" && allowedValues.length > 0 && optionsPatternsTest(allowedValues, `= ${context.sourceCode.getText(node.typeAnnotation)}`)) {
+      let ancestor = node.parent;
+      while (allowModules && ancestor && ancestor.type !== "TSModuleDeclaration") {
+        ancestor = ancestor.parent;
+      }
+      const ambient = ancestor?.type === "TSModuleDeclaration" && (ancestor.kind === "global" || ancestor.id.type === "Literal");
+      if (allowModules && ambient || optionsPatternsTest(allowedNames, node.id.name) || node.type === "TSTypeAliasDeclaration" && allowedValues.length > 0 && optionsPatternsTest(allowedValues, `= ${context.sourceCode.getText(node.typeAnnotation)}`)) {
         return;
       }
       context.report({
@@ -7849,7 +8054,8 @@ var typesDeclarations = defineRule70({
     }
     return {
       before() {
-        const { allow: allowPattern } = optionsFirst(context, {});
+        const { allow: allowPattern, modules = false } = optionsFirst(context, {});
+        allowModules = modules;
         const sources = allowPattern === undefined ? [] : [allowPattern].flat();
         allowedNames = optionsPatterns(sources.filter((source) => !isValuePattern(source)));
         allowedValues = optionsPatterns(sources.filter(isValuePattern));
@@ -7861,8 +8067,8 @@ var typesDeclarations = defineRule70({
 });
 
 // src/rules/types/types-duplicate.ts
-import { defineRule as defineRule71 } from "@oxlint/plugins";
-var typesDuplicate = defineRule71({
+import { defineRule as defineRule73 } from "@oxlint/plugins";
+var typesDuplicate = defineRule73({
   meta: {
     type: "suggestion",
     schema: [
@@ -7926,7 +8132,7 @@ var typesDuplicate = defineRule71({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule72 } from "@oxlint/plugins";
+import { defineRule as defineRule74 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -7938,7 +8144,7 @@ function importedAliasTarget(declaration, imports) {
   const { name } = type.typeName;
   return imports.has(name) && !declaration.typeParameters?.params.some((parameter) => parameter.name.name === name) ? name : undefined;
 }
-var typesImportedAlias = defineRule72({
+var typesImportedAlias = defineRule74({
   meta: {
     type: "problem",
     schema: [],
@@ -8000,7 +8206,7 @@ var typesImportedAlias = defineRule72({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule73 } from "@oxlint/plugins";
+import { defineRule as defineRule75 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -8010,7 +8216,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule73({
+var typesInline = defineRule75({
   meta: {
     type: "problem",
     schema: [
@@ -8021,6 +8227,9 @@ var typesInline = defineRule73({
           parameters: { type: "boolean" },
           returns: { type: "boolean" },
           functions: { type: "boolean" },
+          variables: { type: "boolean" },
+          assertions: { type: "boolean" },
+          arguments: { type: "boolean" },
           min: { type: "integer", minimum: 1 }
         }
       }
@@ -8033,6 +8242,9 @@ var typesInline = defineRule73({
     let checkParameters = true;
     let checkReturns = true;
     let checkFunctionTypes = true;
+    let checkVariables = false;
+    let checkAssertions = false;
+    let checkArguments = false;
     let minMembers = 1;
     function isInline(node) {
       if (node.type === "TSTypeLiteral") {
@@ -8068,11 +8280,44 @@ var typesInline = defineRule73({
         checkParameters = options.parameters ?? true;
         checkReturns = options.returns ?? true;
         checkFunctionTypes = options.functions ?? true;
+        checkVariables = options.variables ?? false;
+        checkAssertions = options.assertions ?? false;
+        checkArguments = options.arguments ?? false;
         minMembers = options.min ?? 1;
-        if (!checkParameters && !checkReturns) {
+        if (!checkParameters && !checkReturns && !checkVariables && !checkAssertions && !checkArguments) {
           return false;
         }
       },
+      VariableDeclarator(node) {
+        if (checkVariables) {
+          check(parameterAnnotation(node.id), "variable");
+        }
+      },
+      PropertyDefinition(node) {
+        if (checkVariables) {
+          check(node.typeAnnotation, "variable");
+        }
+      },
+      TSAsExpression(node) {
+        if (checkAssertions) {
+          check(node.typeAnnotation, "assertion");
+        }
+      },
+      TSSatisfiesExpression(node) {
+        if (checkAssertions) {
+          check(node.typeAnnotation, "assertion");
+        }
+      },
+      CallExpression(node) {
+        if (checkArguments) {
+          check(node.typeArguments, "type argument");
+        }
+      },
+      NewExpression(node) {
+        if (checkArguments) {
+          check(node.typeArguments, "type argument");
+        }
+      },
       FunctionDeclaration: checkFunction,
       FunctionExpression: checkFunction,
       ArrowFunctionExpression: checkFunction,
@@ -8086,8 +8331,8 @@ var typesInline = defineRule73({
 var typesLocalAlias = astSelectorRule("TSTypeAliasDeclaration", "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface.");
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule74 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule74({
+import { defineRule as defineRule76 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule76({
   meta: {
     type: "suggestion",
     schema: [
@@ -8129,8 +8374,8 @@ var typesNamespaceImport = defineRule74({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule75 } from "@oxlint/plugins";
-var typesService = defineRule75({
+import { defineRule as defineRule77 } from "@oxlint/plugins";
+var typesService = defineRule77({
   meta: {
     type: "problem",
     schema: [
@@ -8180,12 +8425,12 @@ var typesService = defineRule75({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule76 } from "@oxlint/plugins";
+import { defineRule as defineRule78 } from "@oxlint/plugins";
 function isCatchName(node) {
   const key = "key" in node && !(("computed" in node) && node.computed) ? node.key : undefined;
   return key?.type === "Identifier" && key.name === "catch";
 }
-var typesUnknown = defineRule76({
+var typesUnknown = defineRule78({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -8224,6 +8469,7 @@ var src_default = eslintCompatPlugin({
     "boundaries-token-owner": boundariesTokenOwner,
     "code-branch-once": codeBranchOnce,
     "code-constructor": codeConstructor,
+    "code-delegate": codeDelegate,
     "code-double-negation": codeDoubleNegation,
     "code-function-nesting": codeFunctionNesting,
     "code-inline": codeInline,
@@ -8277,6 +8523,7 @@ var src_default = eslintCompatPlugin({
     "react-empty-effect": reactEmptyEffect,
     "react-memo": reactMemo,
     "react-props": reactProps,
+    "react-query-props": reactQueryProps,
     "schemas-inline": schemasInline,
     "schemas-local": schemasLocal,
     "schemas-rederive": schemasRederive,