diff --git a/package.json b/package.json
index 5caba4d..b6b8e7e 100644
--- a/package.json
+++ b/package.json
@@ -29,8 +29,8 @@
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
     "eslint-plugin-react-hooks": "^7.0.1",
-    "oxfmt": "^0.44.0",
-    "oxlint": "^1.59.0",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
     "tsdown": "^0.21.7",
     "typescript": "^6.0.2",
     "vitest": "^4.1.4"
diff --git a/packages/react-doctor/package.json b/packages/react-doctor/package.json
index 4558c9e..ad38630 100644
--- a/packages/react-doctor/package.json
+++ b/packages/react-doctor/package.json
@@ -52,7 +52,7 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "knip": "^6.3.1",
     "ora": "^9.3.0",
-    "oxlint": "^1.59.0",
+    "oxlint": "^1.60.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
     "typescript": ">=5.0.4 <7"
diff --git a/packages/react-doctor/src/oxlint-config.ts b/packages/react-doctor/src/oxlint-config.ts
index e85d2ec..b63819c 100644
--- a/packages/react-doctor/src/oxlint-config.ts
+++ b/packages/react-doctor/src/oxlint-config.ts
@@ -33,6 +33,23 @@ const REACT_NATIVE_RULES: Record<string, string> = {
   "react-doctor/rn-no-single-element-style-array": "warn",
 };
 
+const TANSTACK_START_RULES: Record<string, string> = {
+  "react-doctor/tanstack-start-route-property-order": "error",
+  "react-doctor/tanstack-start-no-direct-fetch-in-loader": "warn",
+  "react-doctor/tanstack-start-server-fn-validate-input": "warn",
+  "react-doctor/tanstack-start-no-useeffect-fetch": "warn",
+  "react-doctor/tanstack-start-missing-head-content": "warn",
+  "react-doctor/tanstack-start-no-anchor-element": "warn",
+  "react-doctor/tanstack-start-server-fn-method-order": "error",
+  "react-doctor/tanstack-start-no-navigate-in-render": "warn",
+  "react-doctor/tanstack-start-no-dynamic-server-fn-import": "error",
+  "react-doctor/tanstack-start-no-use-server-in-handler": "error",
+  "react-doctor/tanstack-start-no-secrets-in-loader": "error",
+  "react-doctor/tanstack-start-get-mutation": "warn",
+  "react-doctor/tanstack-start-redirect-in-try-catch": "warn",
+  "react-doctor/tanstack-start-loader-parallel-fetch": "warn",
+};
+
 const REACT_COMPILER_RULES: Record<string, string> = {
   "react-hooks-js/set-state-in-render": "error",
   "react-hooks-js/immutability": "error",
@@ -138,6 +155,7 @@ export const createOxlintConfig = ({
     "react-doctor/rendering-animate-svg-wrapper": "warn",
     "react-doctor/no-inline-prop-on-memo-component": "warn",
     "react-doctor/rendering-hydration-no-flicker": "warn",
+    "react-doctor/rendering-script-defer-async": "warn",
 
     "react-doctor/no-transition-all": "warn",
     "react-doctor/no-global-css-variable-animation": "error",
@@ -147,6 +165,8 @@ export const createOxlintConfig = ({
 
     "react-doctor/no-secrets-in-client-code": "error",
 
+    "react-doctor/js-flatmap-filter": "warn",
+
     "react-doctor/no-barrel-import": "warn",
     "react-doctor/no-full-lodash-import": "warn",
     "react-doctor/no-moment": "warn",
@@ -163,8 +183,16 @@ export const createOxlintConfig = ({
 
     "react-doctor/client-passive-event-listeners": "warn",
 
+    "react-doctor/query-stable-query-client": "error",
+    "react-doctor/query-no-rest-destructuring": "warn",
+    "react-doctor/query-no-void-query-fn": "warn",
+    "react-doctor/query-no-query-in-effect": "warn",
+    "react-doctor/query-mutation-missing-invalidation": "warn",
+    "react-doctor/query-no-usequery-for-mutation": "warn",
+
     "react-doctor/async-parallel": "warn",
     ...(framework === "nextjs" ? NEXTJS_RULES : {}),
     ...(framework === "expo" || framework === "react-native" ? REACT_NATIVE_RULES : {}),
+    ...(framework === "tanstack-start" ? TANSTACK_START_RULES : {}),
   },
 });
diff --git a/packages/react-doctor/src/plugin/constants.ts b/packages/react-doctor/src/plugin/constants.ts
index e4b954c..7214c5f 100644
--- a/packages/react-doctor/src/plugin/constants.ts
+++ b/packages/react-doctor/src/plugin/constants.ts
@@ -172,6 +172,65 @@ export const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 
 export const LOADING_STATE_PATTERN = /^(?:isLoading|isPending)$/;
 
+export const TANSTACK_ROUTE_FILE_PATTERN = /\/routes\//;
+export const TANSTACK_ROOT_ROUTE_FILE_PATTERN = /__root\.(tsx?|jsx?)$/;
+
+export const TANSTACK_ROUTE_PROPERTY_ORDER = [
+  "params",
+  "validateSearch",
+  "loaderDeps",
+  "search.middlewares",
+  "ssr",
+  "context",
+  "beforeLoad",
+  "loader",
+  "onEnter",
+  "onStay",
+  "onLeave",
+  "head",
+  "scripts",
+  "headers",
+  "remountDeps",
+];
+
+export const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
+  "createFileRoute",
+  "createRoute",
+  "createRootRoute",
+  "createRootRouteWithContext",
+]);
+
+export const TANSTACK_SERVER_FN_NAMES = new Set(["createServerFn"]);
+
+export const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
+  "middleware",
+  "inputValidator",
+  "client",
+  "server",
+  "handler",
+];
+
+export const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
+
+export const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
+
+export const SEQUENTIAL_AWAIT_THRESHOLD_FOR_LOADER = 2;
+
+export const TANSTACK_QUERY_HOOKS = new Set([
+  "useQuery",
+  "useInfiniteQuery",
+  "useSuspenseQuery",
+  "useSuspenseInfiniteQuery",
+]);
+
+export const TANSTACK_MUTATION_HOOKS = new Set(["useMutation"]);
+
+export const TANSTACK_QUERY_CLIENT_CLASS = "QueryClient";
+
+export const STABLE_HOOK_WRAPPERS = new Set(["useState", "useMemo", "useRef"]);
+
+export const SCRIPT_LOADING_ATTRIBUTES = new Set(["defer", "async"]);
+
 export const GENERIC_EVENT_SUFFIXES = new Set(["Click", "Change", "Input", "Blur", "Focus"]);
 
 export const TRIVIAL_INITIALIZER_NAMES = new Set([
diff --git a/packages/react-doctor/src/plugin/index.ts b/packages/react-doctor/src/plugin/index.ts
index 76220bf..abd5fb5 100644
--- a/packages/react-doctor/src/plugin/index.ts
+++ b/packages/react-doctor/src/plugin/index.ts
@@ -28,6 +28,7 @@ import {
   jsMinMaxLoop,
   jsSetMapLookups,
   jsTosortedImmutable,
+  jsFlatmapFilter,
 } from "./rules/js-performance.js";
 import {
   nextjsAsyncClientComponent,
@@ -58,6 +59,7 @@ import {
   renderingAnimateSvgWrapper,
   noInlinePropOnMemoComponent,
   renderingHydrationNoFlicker,
+  renderingScriptDeferAsync,
   rerenderMemoWithDefaultValue,
 } from "./rules/performance.js";
 import {
@@ -70,8 +72,32 @@ import {
   rnPreferReanimated,
   rnNoSingleElementStyleArray,
 } from "./rules/react-native.js";
+import {
+  queryMutationMissingInvalidation,
+  queryNoQueryInEffect,
+  queryNoRestDestructuring,
+  queryNoUseQueryForMutation,
+  queryNoVoidQueryFn,
+  queryStableQueryClient,
+} from "./rules/tanstack-query.js";
 import { noEval, noSecretsInClientCode } from "./rules/security.js";
 import { serverAfterNonblocking, serverAuthActions } from "./rules/server.js";
+import {
+  tanstackStartGetMutation,
+  tanstackStartLoaderParallelFetch,
+  tanstackStartMissingHeadContent,
+  tanstackStartNoAnchorElement,
+  tanstackStartNoDirectFetchInLoader,
+  tanstackStartNoDynamicServerFnImport,
+  tanstackStartNoNavigateInRender,
+  tanstackStartNoSecretsInLoader,
+  tanstackStartNoUseEffectFetch,
+  tanstackStartNoUseServerInHandler,
+  tanstackStartRedirectInTryCatch,
+  tanstackStartRoutePropertyOrder,
+  tanstackStartServerFnMethodOrder,
+  tanstackStartServerFnValidateInput,
+} from "./rules/tanstack-start.js";
 import {
   noCascadingSetState,
   noDerivedStateEffect,
@@ -108,6 +134,7 @@ const plugin: RulePlugin = {
     "rendering-animate-svg-wrapper": renderingAnimateSvgWrapper,
     "no-inline-prop-on-memo-component": noInlinePropOnMemoComponent,
     "rendering-hydration-no-flicker": renderingHydrationNoFlicker,
+    "rendering-script-defer-async": renderingScriptDeferAsync,
 
     "no-transition-all": noTransitionAll,
     "no-global-css-variable-animation": noGlobalCssVariableAnimation,
@@ -160,6 +187,7 @@ const plugin: RulePlugin = {
     "js-index-maps": jsIndexMaps,
     "js-cache-storage": jsCacheStorage,
     "js-early-exit": jsEarlyExit,
+    "js-flatmap-filter": jsFlatmapFilter,
     "async-parallel": asyncParallel,
 
     "rn-no-raw-text": rnNoRawText,
@@ -170,6 +198,28 @@ const plugin: RulePlugin = {
     "rn-no-legacy-shadow-styles": rnNoLegacyShadowStyles,
     "rn-prefer-reanimated": rnPreferReanimated,
     "rn-no-single-element-style-array": rnNoSingleElementStyleArray,
+
+    "tanstack-start-route-property-order": tanstackStartRoutePropertyOrder,
+    "tanstack-start-no-direct-fetch-in-loader": tanstackStartNoDirectFetchInLoader,
+    "tanstack-start-server-fn-validate-input": tanstackStartServerFnValidateInput,
+    "tanstack-start-no-useeffect-fetch": tanstackStartNoUseEffectFetch,
+    "tanstack-start-missing-head-content": tanstackStartMissingHeadContent,
+    "tanstack-start-no-anchor-element": tanstackStartNoAnchorElement,
+    "tanstack-start-server-fn-method-order": tanstackStartServerFnMethodOrder,
+    "tanstack-start-no-navigate-in-render": tanstackStartNoNavigateInRender,
+    "tanstack-start-no-dynamic-server-fn-import": tanstackStartNoDynamicServerFnImport,
+    "tanstack-start-no-use-server-in-handler": tanstackStartNoUseServerInHandler,
+    "tanstack-start-no-secrets-in-loader": tanstackStartNoSecretsInLoader,
+    "tanstack-start-get-mutation": tanstackStartGetMutation,
+    "tanstack-start-redirect-in-try-catch": tanstackStartRedirectInTryCatch,
+    "tanstack-start-loader-parallel-fetch": tanstackStartLoaderParallelFetch,
+
+    "query-stable-query-client": queryStableQueryClient,
+    "query-no-rest-destructuring": queryNoRestDestructuring,
+    "query-no-void-query-fn": queryNoVoidQueryFn,
+    "query-no-query-in-effect": queryNoQueryInEffect,
+    "query-mutation-missing-invalidation": queryMutationMissingInvalidation,
+    "query-no-usequery-for-mutation": queryNoUseQueryForMutation,
   },
 };
 
diff --git a/packages/react-doctor/src/plugin/rules/js-performance.ts b/packages/react-doctor/src/plugin/rules/js-performance.ts
index 502d9e8..17bbdc0 100644
--- a/packages/react-doctor/src/plugin/rules/js-performance.ts
+++ b/packages/react-doctor/src/plugin/rules/js-performance.ts
@@ -29,6 +29,18 @@ export const jsCombineIterations: Rule = {
       const innerMethod = innerCall.callee.property.name;
       if (!CHAINABLE_ITERATION_METHODS.has(innerMethod)) return;
 
+      if (innerMethod === "map" && outerMethod === "filter") {
+        const filterArgument = node.arguments?.[0];
+        const isBooleanOrIdentityFilter =
+          (filterArgument?.type === "Identifier" && filterArgument.name === "Boolean") ||
+          (filterArgument?.type === "ArrowFunctionExpression" &&
+            filterArgument.params?.length === 1 &&
+            filterArgument.body?.type === "Identifier" &&
+            filterArgument.params[0]?.type === "Identifier" &&
+            filterArgument.body.name === filterArgument.params[0].name);
+        if (isBooleanOrIdentityFilter) return;
+      }
+
       context.report({
         node,
         message: `.${innerMethod}().${outerMethod}() iterates the array twice — combine into a single loop with .reduce() or for...of`,
@@ -279,3 +291,48 @@ const reportIfIndependent = (statements: EsTreeNode[], context: RuleContext): vo
     message: `${statements.length} sequential await statements that appear independent — use Promise.all() for parallel execution`,
   });
 };
+
+export const jsFlatmapFilter: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (node.callee?.type !== "MemberExpression" || node.callee.property?.type !== "Identifier")
+        return;
+
+      const outerMethod = node.callee.property.name;
+      if (outerMethod !== "filter") return;
+
+      const filterArgument = node.arguments?.[0];
+      if (!filterArgument) return;
+
+      const isIdentityArrow =
+        filterArgument.type === "ArrowFunctionExpression" &&
+        filterArgument.params?.length === 1 &&
+        filterArgument.body?.type === "Identifier" &&
+        filterArgument.params[0]?.type === "Identifier" &&
+        filterArgument.body.name === filterArgument.params[0].name;
+
+      const isFilterBoolean =
+        (filterArgument.type === "Identifier" && filterArgument.name === "Boolean") ||
+        isIdentityArrow;
+
+      if (!isFilterBoolean) return;
+
+      const innerCall = node.callee.object;
+      if (
+        innerCall?.type !== "CallExpression" ||
+        innerCall.callee?.type !== "MemberExpression" ||
+        innerCall.callee.property?.type !== "Identifier"
+      )
+        return;
+
+      const innerMethod = innerCall.callee.property.name;
+      if (innerMethod !== "map") return;
+
+      context.report({
+        node,
+        message:
+          ".map().filter(Boolean) iterates twice — use .flatMap() to transform and filter in a single pass",
+      });
+    },
+  }),
+};
diff --git a/packages/react-doctor/src/plugin/rules/performance.ts b/packages/react-doctor/src/plugin/rules/performance.ts
index cb4f902..9092a84 100644
--- a/packages/react-doctor/src/plugin/rules/performance.ts
+++ b/packages/react-doctor/src/plugin/rules/performance.ts
@@ -2,10 +2,12 @@ import {
   ANIMATION_CALLBACK_NAMES,
   BLUR_VALUE_PATTERN,
   EFFECT_HOOK_NAMES,
+  EXECUTABLE_SCRIPT_TYPES,
   LARGE_BLUR_THRESHOLD_PX,
   LAYOUT_PROPERTIES,
   LOADING_STATE_PATTERN,
   MOTION_ANIMATE_PROPS,
+  SCRIPT_LOADING_ATTRIBUTES,
 } from "../constants.js";
 import {
   getEffectCallback,
@@ -422,3 +424,46 @@ export const renderingHydrationNoFlicker: Rule = {
     },
   }),
 };
+
+export const renderingScriptDeferAsync: Rule = {
+  create: (context: RuleContext) => ({
+    JSXOpeningElement(node: EsTreeNode) {
+      if (node.name?.type !== "JSXIdentifier" || node.name.name !== "script") return;
+
+      const attributes = node.attributes ?? [];
+      const hasSrc = attributes.some(
+        (attr: EsTreeNode) =>
+          attr.type === "JSXAttribute" &&
+          attr.name?.type === "JSXIdentifier" &&
+          attr.name.name === "src",
+      );
+
+      if (!hasSrc) return;
+
+      const typeAttribute = attributes.find(
+        (attr: EsTreeNode) =>
+          attr.type === "JSXAttribute" &&
+          attr.name?.type === "JSXIdentifier" &&
+          attr.name.name === "type",
+      );
+      const typeValue = typeAttribute?.value?.type === "Literal" ? typeAttribute.value.value : null;
+      if (typeof typeValue === "string" && !EXECUTABLE_SCRIPT_TYPES.has(typeValue)) return;
+      if (typeValue === "module") return;
+
+      const hasLoadingStrategy = attributes.some(
+        (attr: EsTreeNode) =>
+          attr.type === "JSXAttribute" &&
+          attr.name?.type === "JSXIdentifier" &&
+          SCRIPT_LOADING_ATTRIBUTES.has(attr.name.name),
+      );
+
+      if (!hasLoadingStrategy) {
+        context.report({
+          node,
+          message:
+            "<script src> without defer or async — blocks HTML parsing and delays First Contentful Paint. Add defer for DOM-dependent scripts or async for independent ones",
+        });
+      }
+    },
+  }),
+};
diff --git a/packages/react-doctor/src/plugin/rules/tanstack-query.ts b/packages/react-doctor/src/plugin/rules/tanstack-query.ts
new file mode 100644
index 0000000..4cde4de
--- /dev/null
+++ b/packages/react-doctor/src/plugin/rules/tanstack-query.ts
@@ -0,0 +1,264 @@
+import {
+  EFFECT_HOOK_NAMES,
+  MUTATING_HTTP_METHODS,
+  STABLE_HOOK_WRAPPERS,
+  TANSTACK_MUTATION_HOOKS,
+  TANSTACK_QUERY_CLIENT_CLASS,
+  TANSTACK_QUERY_HOOKS,
+  UPPERCASE_PATTERN,
+} from "../constants.js";
+import { getEffectCallback, isHookCall, walkAst } from "../helpers.js";
+import type { EsTreeNode, Rule, RuleContext } from "../types.js";
+
+export const queryStableQueryClient: Rule = {
+  create: (context: RuleContext) => {
+    let componentDepth = 0;
+    let stableHookDepth = 0;
+
+    return {
+      FunctionDeclaration(node: EsTreeNode) {
+        if (node.id?.name && UPPERCASE_PATTERN.test(node.id.name)) {
+          componentDepth++;
+        }
+      },
+      "FunctionDeclaration:exit"(node: EsTreeNode) {
+        if (node.id?.name && UPPERCASE_PATTERN.test(node.id.name)) {
+          componentDepth--;
+        }
+      },
+      VariableDeclarator(node: EsTreeNode) {
+        if (
+          node.id?.type === "Identifier" &&
+          UPPERCASE_PATTERN.test(node.id.name) &&
+          (node.init?.type === "ArrowFunctionExpression" ||
+            node.init?.type === "FunctionExpression")
+        ) {
+          componentDepth++;
+        }
+      },
+      "VariableDeclarator:exit"(node: EsTreeNode) {
+        if (
+          node.id?.type === "Identifier" &&
+          UPPERCASE_PATTERN.test(node.id.name) &&
+          (node.init?.type === "ArrowFunctionExpression" ||
+            node.init?.type === "FunctionExpression")
+        ) {
+          componentDepth--;
+        }
+      },
+      CallExpression(node: EsTreeNode) {
+        if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) {
+          stableHookDepth++;
+        }
+      },
+      "CallExpression:exit"(node: EsTreeNode) {
+        if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) {
+          stableHookDepth--;
+        }
+      },
+      NewExpression(node: EsTreeNode) {
+        if (componentDepth <= 0) return;
+        if (stableHookDepth > 0) return;
+        if (node.callee?.type !== "Identifier" || node.callee.name !== TANSTACK_QUERY_CLIENT_CLASS)
+          return;
+
+        context.report({
+          node,
+          message:
+            "new QueryClient() inside a component — creates a new cache on every render. Move to module scope or wrap in useState(() => new QueryClient())",
+        });
+      },
+    };
+  },
+};
+
+export const queryNoRestDestructuring: Rule = {
+  create: (context: RuleContext) => ({
+    VariableDeclarator(node: EsTreeNode) {
+      if (node.id?.type !== "ObjectPattern") return;
+      if (!node.init || node.init.type !== "CallExpression") return;
+
+      const calleeName = node.init.callee?.type === "Identifier" ? node.init.callee.name : null;
+
+      if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+
+      const hasRestElement = node.id.properties?.some(
+        (property: EsTreeNode) => property.type === "RestElement",
+      );
+
+      if (hasRestElement) {
+        context.report({
+          node: node.id,
+          message: `Rest destructuring on ${calleeName}() result — subscribes to all fields and causes unnecessary re-renders. Destructure only the fields you need`,
+        });
+      }
+    },
+  }),
+};
+
+export const queryNoVoidQueryFn: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+
+      if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+
+      const optionsArgument = node.arguments?.[0];
+      if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+
+      const queryFnProperty = optionsArgument.properties?.find(
+        (property: EsTreeNode) =>
+          property.type === "Property" &&
+          property.key?.type === "Identifier" &&
+          property.key.name === "queryFn",
+      );
+
+      if (!queryFnProperty?.value) return;
+
+      const queryFnValue = queryFnProperty.value;
+
+      if (
+        queryFnValue.type === "ArrowFunctionExpression" &&
+        queryFnValue.body?.type !== "BlockStatement"
+      ) {
+        return;
+      }
+
+      if (
+        queryFnValue.type === "ArrowFunctionExpression" ||
+        queryFnValue.type === "FunctionExpression"
+      ) {
+        const body = queryFnValue.body;
+        if (body?.type !== "BlockStatement") return;
+
+        const statements = body.body ?? [];
+        if (statements.length === 0) {
+          context.report({
+            node: queryFnProperty,
+            message:
+              "Empty queryFn — query functions must return a value. Use the enabled option to conditionally disable the query instead",
+          });
+        }
+      }
+    },
+  }),
+};
+
+export const queryNoQueryInEffect: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
+
+      const callback = getEffectCallback(node);
+      if (!callback) return;
+
+      walkAst(callback, (child: EsTreeNode) => {
+        if (child.type !== "CallExpression") return;
+
+        const calleeName = child.callee?.type === "Identifier" ? child.callee.name : null;
+
+        if (calleeName === "refetch") {
+          context.report({
+            node: child,
+            message:
+              "refetch() inside useEffect — React Query manages refetching automatically. Use queryKey dependencies or the enabled option instead",
+          });
+        }
+      });
+    },
+  }),
+};
+
+export const queryMutationMissingInvalidation: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+
+      if (!calleeName || !TANSTACK_MUTATION_HOOKS.has(calleeName)) return;
+
+      const optionsArgument = node.arguments?.[0];
+      if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+
+      const hasMutationFn = optionsArgument.properties?.some(
+        (property: EsTreeNode) =>
+          property.type === "Property" &&
+          property.key?.type === "Identifier" &&
+          property.key.name === "mutationFn",
+      );
+
+      if (!hasMutationFn) return;
+
+      let hasInvalidation = false;
+      walkAst(optionsArgument, (child: EsTreeNode) => {
+        if (hasInvalidation) return;
+        if (
+          child.type === "CallExpression" &&
+          child.callee?.type === "MemberExpression" &&
+          child.callee.property?.type === "Identifier" &&
+          child.callee.property.name === "invalidateQueries"
+        ) {
+          hasInvalidation = true;
+        }
+      });
+
+      if (!hasInvalidation) {
+        context.report({
+          node,
+          message:
+            "useMutation without invalidateQueries — stale data may remain cached after the mutation. Add onSuccess with queryClient.invalidateQueries()",
+        });
+      }
+    },
+  }),
+};
+
+export const queryNoUseQueryForMutation: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+
+      if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+
+      const optionsArgument = node.arguments?.[0];
+      if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+
+      const queryFnProperty = optionsArgument.properties?.find(
+        (property: EsTreeNode) =>
+          property.type === "Property" &&
+          property.key?.type === "Identifier" &&
+          property.key.name === "queryFn",
+      );
+
+      if (!queryFnProperty?.value) return;
+
+      let hasMutatingFetch = false;
+      walkAst(queryFnProperty.value, (child: EsTreeNode) => {
+        if (hasMutatingFetch) return;
+        if (child.type !== "CallExpression") return;
+        if (child.callee?.type !== "Identifier" || child.callee.name !== "fetch") return;
+
+        const optionsArg = child.arguments?.[1];
+        if (!optionsArg || optionsArg.type !== "ObjectExpression") return;
+
+        const methodProperty = optionsArg.properties?.find(
+          (property: EsTreeNode) =>
+            property.type === "Property" &&
+            property.key?.type === "Identifier" &&
+            property.key.name === "method" &&
+            property.value?.type === "Literal" &&
+            typeof property.value.value === "string" &&
+            MUTATING_HTTP_METHODS.has(property.value.value.toUpperCase()),
+        );
+
+        if (methodProperty) hasMutatingFetch = true;
+      });
+
+      if (hasMutatingFetch) {
+        context.report({
+          node,
+          message: `${calleeName}() with a mutating fetch (POST/PUT/DELETE) — use useMutation() instead, which provides onSuccess/onError callbacks and doesn't auto-refetch`,
+        });
+      }
+    },
+  }),
+};
diff --git a/packages/react-doctor/src/plugin/rules/tanstack-start.ts b/packages/react-doctor/src/plugin/rules/tanstack-start.ts
new file mode 100644
index 0000000..adb02ad
--- /dev/null
+++ b/packages/react-doctor/src/plugin/rules/tanstack-start.ts
@@ -0,0 +1,635 @@
+import {
+  MUTATING_HTTP_METHODS,
+  SEQUENTIAL_AWAIT_THRESHOLD_FOR_LOADER,
+  TANSTACK_MIDDLEWARE_METHOD_ORDER,
+  TANSTACK_REDIRECT_FUNCTIONS,
+  TANSTACK_ROUTE_CREATION_FUNCTIONS,
+  TANSTACK_ROUTE_FILE_PATTERN,
+  TANSTACK_ROUTE_PROPERTY_ORDER,
+  TANSTACK_ROOT_ROUTE_FILE_PATTERN,
+  TANSTACK_SERVER_FN_FILE_PATTERN,
+  TANSTACK_SERVER_FN_NAMES,
+  UPPERCASE_PATTERN,
+} from "../constants.js";
+import { findSideEffect, getCalleeName, walkAst } from "../helpers.js";
+import type { EsTreeNode, Rule, RuleContext } from "../types.js";
+
+const getRouteOptionsObject = (node: EsTreeNode): EsTreeNode | null => {
+  if (node.type !== "CallExpression") return null;
+
+  const callee = node.callee;
+
+  if (callee?.type === "CallExpression" && callee.callee?.type === "Identifier") {
+    if (!TANSTACK_ROUTE_CREATION_FUNCTIONS.has(callee.callee.name)) return null;
+    const optionsArgument = node.arguments?.[0];
+    if (optionsArgument?.type === "ObjectExpression") return optionsArgument;
+    return null;
+  }
+
+  if (callee?.type === "Identifier") {
+    if (!TANSTACK_ROUTE_CREATION_FUNCTIONS.has(callee.name)) return null;
+    const optionsArgument = node.arguments?.[0];
+    if (optionsArgument?.type === "ObjectExpression") return optionsArgument;
+    return null;
+  }
+
+  return null;
+};
+
+const getPropertyKeyName = (property: EsTreeNode): string | null => {
+  if (property.type !== "Property" && property.type !== "MethodDefinition") return null;
+  if (property.key?.type === "Identifier") return property.key.name;
+  if (property.key?.type === "Literal") return String(property.key.value);
+  return null;
+};
+
+interface ServerFnChainInfo {
+  isServerFnChain: boolean;
+  specifiedMethod: string | null;
+  hasInputValidator: boolean;
+}
+
+const walkServerFnChain = (outerNode: EsTreeNode): ServerFnChainInfo => {
+  const result: ServerFnChainInfo = {
+    isServerFnChain: false,
+    specifiedMethod: null,
+    hasInputValidator: false,
+  };
+
+  let currentNode: EsTreeNode = outerNode.callee?.object;
+
+  while (currentNode?.type === "CallExpression") {
+    const calleeName = getCalleeName(currentNode);
+
+    if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) {
+      result.isServerFnChain = true;
+
+      const optionsArgument = currentNode.arguments?.[0];
+      if (optionsArgument?.type === "ObjectExpression") {
+        for (const property of optionsArgument.properties ?? []) {
+          if (
+            property.key?.type === "Identifier" &&
+            property.key.name === "method" &&
+            property.value?.type === "Literal" &&
+            typeof property.value.value === "string"
+          ) {
+            result.specifiedMethod = property.value.value;
+          }
+        }
+      }
+    }
+
+    if (calleeName === "inputValidator") {
+      result.hasInputValidator = true;
+    }
+
+    if (currentNode.callee?.type === "MemberExpression") {
+      currentNode = currentNode.callee.object;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+};
+
+export const tanstackStartRoutePropertyOrder: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const optionsObject = getRouteOptionsObject(node);
+      if (!optionsObject) return;
+
+      const properties = optionsObject.properties ?? [];
+      const orderedPropertyNames = properties
+        .map(getPropertyKeyName)
+        .filter((name): name is string => name !== null);
+
+      const sensitiveProperties = orderedPropertyNames.filter((name) =>
+        TANSTACK_ROUTE_PROPERTY_ORDER.includes(name),
+      );
+
+      let lastIndex = -1;
+      for (const propertyName of sensitiveProperties) {
+        const currentIndex = TANSTACK_ROUTE_PROPERTY_ORDER.indexOf(propertyName);
+        if (currentIndex < lastIndex) {
+          const expectedBefore = TANSTACK_ROUTE_PROPERTY_ORDER[lastIndex];
+          context.report({
+            node: optionsObject,
+            message: `Route property "${propertyName}" must come before "${expectedBefore}" — wrong order breaks TypeScript type inference`,
+          });
+          return;
+        }
+        lastIndex = currentIndex;
+      }
+    },
+  }),
+};
+
+export const tanstackStartNoDirectFetchInLoader: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const optionsObject = getRouteOptionsObject(node);
+      if (!optionsObject) return;
+
+      const properties = optionsObject.properties ?? [];
+      for (const property of properties) {
+        const keyName = getPropertyKeyName(property);
+        if (keyName !== "loader") continue;
+
+        const loaderValue = property.value ?? property;
+        walkAst(loaderValue, (child: EsTreeNode) => {
+          if (child.type !== "CallExpression") return;
+          if (child.callee?.type === "Identifier" && child.callee.name === "fetch") {
+            context.report({
+              node: child,
+              message:
+                "Direct fetch() in route loader — use createServerFn() for type-safe server logic with automatic RPC",
+            });
+          }
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartServerFnValidateInput: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (node.callee?.type !== "MemberExpression") return;
+      if (node.callee.property?.type !== "Identifier") return;
+      if (node.callee.property.name !== "handler") return;
+
+      const chainInfo = walkServerFnChain(node);
+      if (!chainInfo.isServerFnChain) return;
+
+      const handlerFunction = node.arguments?.[0];
+      if (!handlerFunction) return;
+
+      let accessesData = false;
+      walkAst(handlerFunction, (child: EsTreeNode) => {
+        if (
+          child.type === "MemberExpression" &&
+          child.property?.type === "Identifier" &&
+          child.property.name === "data"
+        ) {
+          accessesData = true;
+        }
+        if (
+          child.type === "ObjectPattern" &&
+          child.properties?.some(
+            (property: EsTreeNode) =>
+              property.key?.type === "Identifier" && property.key.name === "data",
+          )
+        ) {
+          accessesData = true;
+        }
+      });
+
+      if (accessesData && !chainInfo.hasInputValidator) {
+        context.report({
+          node,
+          message:
+            "Server function handler accesses data without inputValidator() — validate inputs crossing the network boundary",
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartNoUseEffectFetch: Rule = {
+  create: (context: RuleContext) => {
+    const filename = context.getFilename?.() ?? "";
+    if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return {};
+
+    return {
+      CallExpression(node: EsTreeNode) {
+        if (node.callee?.type !== "Identifier") return;
+        if (node.callee.name !== "useEffect" && node.callee.name !== "useLayoutEffect") return;
+
+        const callback = node.arguments?.[0];
+        if (!callback) return;
+
+        let hasFetchCall = false;
+        walkAst(callback, (child: EsTreeNode) => {
+          if (hasFetchCall) return;
+          if (
+            child.type === "CallExpression" &&
+            child.callee?.type === "Identifier" &&
+            child.callee.name === "fetch"
+          ) {
+            hasFetchCall = true;
+          }
+        });
+
+        if (hasFetchCall) {
+          context.report({
+            node,
+            message:
+              "fetch() inside useEffect in a route file — use the route loader or createServerFn() instead",
+          });
+        }
+      },
+    };
+  },
+};
+
+export const tanstackStartMissingHeadContent: Rule = {
+  create: (context: RuleContext) => {
+    const filename = context.getFilename?.() ?? "";
+    if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return {};
+
+    let hasHeadContentElement = false;
+
+    return {
+      JSXOpeningElement(node: EsTreeNode) {
+        if (node.name?.type === "JSXIdentifier" && node.name.name === "HeadContent") {
+          hasHeadContentElement = true;
+        }
+      },
+      "Program:exit"(programNode: EsTreeNode) {
+        if (!hasHeadContentElement) {
+          context.report({
+            node: programNode,
+            message:
+              "Root route (__root) without <HeadContent /> — route head() meta tags won't render",
+          });
+        }
+      },
+    };
+  },
+};
+
+export const tanstackStartNoAnchorElement: Rule = {
+  create: (context: RuleContext) => {
+    const filename = context.getFilename?.() ?? "";
+    if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return {};
+
+    return {
+      JSXOpeningElement(node: EsTreeNode) {
+        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "a") return;
+
+        const attributes = node.attributes ?? [];
+        const hrefAttribute = attributes.find(
+          (attr: EsTreeNode) =>
+            attr.type === "JSXAttribute" &&
+            attr.name?.type === "JSXIdentifier" &&
+            attr.name.name === "href",
+        );
+
+        if (!hrefAttribute?.value) return;
+
+        let hrefValue: string | null = null;
+        if (hrefAttribute.value.type === "Literal") {
+          hrefValue = hrefAttribute.value.value;
+        } else if (
+          hrefAttribute.value.type === "JSXExpressionContainer" &&
+          hrefAttribute.value.expression?.type === "Literal"
+        ) {
+          hrefValue = hrefAttribute.value.expression.value;
+        }
+
+        if (typeof hrefValue === "string" && hrefValue.startsWith("/")) {
+          context.report({
+            node,
+            message:
+              "Use <Link> from @tanstack/react-router instead of <a> for internal navigation — enables type-safe routing and preloading",
+          });
+        }
+      },
+    };
+  },
+};
+
+export const tanstackStartServerFnMethodOrder: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (node.callee?.type !== "MemberExpression") return;
+
+      const methodNames: string[] = [];
+      let currentNode: EsTreeNode = node;
+
+      while (
+        currentNode?.type === "CallExpression" &&
+        currentNode.callee?.type === "MemberExpression"
+      ) {
+        const methodName =
+          currentNode.callee.property?.type === "Identifier"
+            ? currentNode.callee.property.name
+            : null;
+        if (methodName) methodNames.unshift(methodName);
+        currentNode = currentNode.callee.object;
+      }
+
+      if (currentNode?.type === "CallExpression" && currentNode.callee?.type === "Identifier") {
+        if (!TANSTACK_SERVER_FN_NAMES.has(currentNode.callee.name)) return;
+      } else {
+        return;
+      }
+
+      const ownMethodName =
+        node.callee.property?.type === "Identifier" ? node.callee.property.name : null;
+      if (methodNames[methodNames.length - 1] !== ownMethodName) return;
+
+      const orderSensitiveMethods = methodNames.filter((name) =>
+        TANSTACK_MIDDLEWARE_METHOD_ORDER.includes(name),
+      );
+
+      let lastIndex = -1;
+      for (const methodName of orderSensitiveMethods) {
+        const currentIndex = TANSTACK_MIDDLEWARE_METHOD_ORDER.indexOf(methodName);
+        if (currentIndex < lastIndex) {
+          const expectedBefore = TANSTACK_MIDDLEWARE_METHOD_ORDER[lastIndex];
+          context.report({
+            node,
+            message: `Server function method .${methodName}() must come before .${expectedBefore}() — wrong order breaks type inference`,
+          });
+          return;
+        }
+        lastIndex = currentIndex;
+      }
+    },
+  }),
+};
+
+export const tanstackStartNoNavigateInRender: Rule = {
+  create: (context: RuleContext) => {
+    const filename = context.getFilename?.() ?? "";
+    if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return {};
+
+    let effectDepth = 0;
+    let eventHandlerDepth = 0;
+
+    return {
+      CallExpression(node: EsTreeNode) {
+        if (
+          node.callee?.type === "Identifier" &&
+          (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")
+        ) {
+          effectDepth++;
+        }
+
+        if (effectDepth > 0 || eventHandlerDepth > 0) return;
+
+        if (
+          node.callee?.type === "Identifier" &&
+          node.callee.name === "navigate" &&
+          node.arguments?.length > 0
+        ) {
+          context.report({
+            node,
+            message:
+              "navigate() called during render — use redirect() in beforeLoad/loader for route-level redirects",
+          });
+        }
+      },
+      "CallExpression:exit"(node: EsTreeNode) {
+        if (
+          node.callee?.type === "Identifier" &&
+          (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")
+        ) {
+          effectDepth--;
+        }
+      },
+      JSXAttribute(node: EsTreeNode) {
+        if (
+          node.name?.type === "JSXIdentifier" &&
+          node.name.name.startsWith("on") &&
+          UPPERCASE_PATTERN.test(node.name.name.charAt(2))
+        ) {
+          eventHandlerDepth++;
+        }
+      },
+      "JSXAttribute:exit"(node: EsTreeNode) {
+        if (
+          node.name?.type === "JSXIdentifier" &&
+          node.name.name.startsWith("on") &&
+          UPPERCASE_PATTERN.test(node.name.name.charAt(2))
+        ) {
+          eventHandlerDepth--;
+        }
+      },
+    };
+  },
+};
+
+export const tanstackStartNoDynamicServerFnImport: Rule = {
+  create: (context: RuleContext) => ({
+    ImportExpression(node: EsTreeNode) {
+      const source = node.source;
+      if (!source) return;
+
+      let importPath: string | null = null;
+      if (source.type === "Literal" && typeof source.value === "string") {
+        importPath = source.value;
+      } else if (source.type === "TemplateLiteral" && source.quasis?.length === 1) {
+        importPath = source.quasis[0].value?.raw ?? null;
+      }
+
+      if (importPath && TANSTACK_SERVER_FN_FILE_PATTERN.test(importPath)) {
+        context.report({
+          node,
+          message:
+            "Dynamic import of server functions file — use static imports so the bundler can replace server code with RPC stubs",
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartNoUseServerInHandler: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (node.callee?.type !== "MemberExpression") return;
+      if (node.callee.property?.type !== "Identifier" || node.callee.property.name !== "handler")
+        return;
+
+      const handlerFunction = node.arguments?.[0];
+      if (
+        !handlerFunction ||
+        (handlerFunction.type !== "ArrowFunctionExpression" &&
+          handlerFunction.type !== "FunctionExpression")
+      )
+        return;
+
+      const body = handlerFunction.body;
+      if (body?.type !== "BlockStatement") return;
+
+      const hasUseServerDirective = body.body?.some(
+        (statement: EsTreeNode) =>
+          statement.type === "ExpressionStatement" &&
+          (statement.directive === "use server" ||
+            (statement.expression?.type === "Literal" &&
+              statement.expression.value === "use server")),
+      );
+
+      if (hasUseServerDirective) {
+        context.report({
+          node: handlerFunction,
+          message:
+            '"use server" inside createServerFn handler — TanStack Start handles this automatically, remove the directive',
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartNoSecretsInLoader: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const optionsObject = getRouteOptionsObject(node);
+      if (!optionsObject) return;
+
+      const properties = optionsObject.properties ?? [];
+      for (const property of properties) {
+        const keyName = getPropertyKeyName(property);
+        if (keyName !== "loader" && keyName !== "beforeLoad") continue;
+
+        const loaderValue = property.value ?? property;
+        walkAst(loaderValue, (child: EsTreeNode) => {
+          if (child.type !== "MemberExpression") return;
+          if (
+            child.object?.type === "MemberExpression" &&
+            child.object.object?.type === "Identifier" &&
+            child.object.object.name === "process" &&
+            child.object.property?.type === "Identifier" &&
+            child.object.property.name === "env"
+          ) {
+            const envVarName = child.property?.type === "Identifier" ? child.property.name : null;
+            if (envVarName && !envVarName.startsWith("VITE_")) {
+              context.report({
+                node: child,
+                message: `process.env.${envVarName} in ${keyName} — loaders are isomorphic and may leak secrets to the client. Move to a createServerFn()`,
+              });
+            }
+          }
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartGetMutation: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      if (node.callee?.type !== "MemberExpression") return;
+      if (node.callee.property?.type !== "Identifier" || node.callee.property.name !== "handler")
+        return;
+
+      const chainInfo = walkServerFnChain(node);
+      if (!chainInfo.isServerFnChain) return;
+      if (
+        chainInfo.specifiedMethod &&
+        MUTATING_HTTP_METHODS.has(chainInfo.specifiedMethod.toUpperCase())
+      )
+        return;
+
+      const handlerFunction = node.arguments?.[0];
+      if (!handlerFunction) return;
+
+      const sideEffect = findSideEffect(handlerFunction);
+      if (sideEffect) {
+        context.report({
+          node,
+          message: `GET server function has side effects (${sideEffect}) — use createServerFn({ method: 'POST' }) for mutations`,
+        });
+      }
+    },
+  }),
+};
+
+export const tanstackStartRedirectInTryCatch: Rule = {
+  create: (context: RuleContext) => {
+    let tryBlockDepth = 0;
+    let catchClauseDepth = 0;
+
+    return {
+      TryStatement() {
+        tryBlockDepth++;
+      },
+      "TryStatement:exit"() {
+        tryBlockDepth--;
+      },
+      CatchClause() {
+        catchClauseDepth++;
+      },
+      "CatchClause:exit"() {
+        catchClauseDepth--;
+      },
+      ThrowStatement(node: EsTreeNode) {
+        if (tryBlockDepth === 0) return;
+        if (catchClauseDepth > 0) return;
+
+        const argument = node.argument;
+        if (argument?.type !== "CallExpression") return;
+        if (argument.callee?.type !== "Identifier") return;
+        if (!TANSTACK_REDIRECT_FUNCTIONS.has(argument.callee.name)) return;
+
+        context.report({
+          node,
+          message: `throw ${argument.callee.name}() inside try block — the router catches this internally. Move it outside the try block or re-throw in the catch`,
+        });
+      },
+    };
+  },
+};
+
+const hasTopLevelAwait = (statement: EsTreeNode): boolean => {
+  if (statement.type === "VariableDeclaration") {
+    return statement.declarations?.some(
+      (declarator: EsTreeNode) => declarator.init?.type === "AwaitExpression",
+    );
+  }
+  if (statement.type === "ExpressionStatement") {
+    return (
+      statement.expression?.type === "AwaitExpression" ||
+      (statement.expression?.type === "AssignmentExpression" &&
+        statement.expression.right?.type === "AwaitExpression")
+    );
+  }
+  if (statement.type === "ReturnStatement") {
+    return statement.argument?.type === "AwaitExpression";
+  }
+  return false;
+};
+
+export const tanstackStartLoaderParallelFetch: Rule = {
+  create: (context: RuleContext) => ({
+    CallExpression(node: EsTreeNode) {
+      const optionsObject = getRouteOptionsObject(node);
+      if (!optionsObject) return;
+
+      const properties = optionsObject.properties ?? [];
+      for (const property of properties) {
+        const keyName = getPropertyKeyName(property);
+        if (keyName !== "loader") continue;
+
+        const loaderValue = property.value;
+        if (
+          !loaderValue ||
+          (loaderValue.type !== "ArrowFunctionExpression" &&
+            loaderValue.type !== "FunctionExpression")
+        )
+          continue;
+
+        const functionBody = loaderValue.body;
+        if (!functionBody || functionBody.type !== "BlockStatement") continue;
+
+        let sequentialAwaitCount = 0;
+        for (const statement of functionBody.body ?? []) {
+          if (hasTopLevelAwait(statement)) {
+            sequentialAwaitCount++;
+          }
+
+          if (sequentialAwaitCount >= SEQUENTIAL_AWAIT_THRESHOLD_FOR_LOADER) {
+            context.report({
+              node: property,
+              message:
+                "Multiple sequential awaits in loader — use Promise.all() to fetch data in parallel and avoid waterfalls",
+            });
+            break;
+          }
+        }
+      }
+    },
+  }),
+};
diff --git a/packages/react-doctor/src/types.ts b/packages/react-doctor/src/types.ts
index 596592e..92c68a3 100644
--- a/packages/react-doctor/src/types.ts
+++ b/packages/react-doctor/src/types.ts
@@ -8,6 +8,7 @@ export type Framework =
   | "gatsby"
   | "expo"
   | "react-native"
+  | "tanstack-start"
   | "unknown";
 
 export interface ProjectInfo {
diff --git a/packages/react-doctor/src/utils/discover-project.ts b/packages/react-doctor/src/utils/discover-project.ts
index f124b87..8616c5e 100644
--- a/packages/react-doctor/src/utils/discover-project.ts
+++ b/packages/react-doctor/src/utils/discover-project.ts
@@ -53,6 +53,7 @@ const REACT_COMPILER_CONFIG_PATTERN = /react-compiler|reactCompiler/;
 
 const FRAMEWORK_PACKAGES: Record<string, Framework> = {
   next: "nextjs",
+  "@tanstack/react-start": "tanstack-start",
   vite: "vite",
   "react-scripts": "cra",
   "@remix-run/react": "remix",
@@ -63,6 +64,7 @@ const FRAMEWORK_PACKAGES: Record<string, Framework> = {
 
 const FRAMEWORK_DISPLAY_NAMES: Record<Framework, string> = {
   nextjs: "Next.js",
+  "tanstack-start": "TanStack Start",
   vite: "Vite",
   cra: "Create React App",
   remix: "Remix",
diff --git a/packages/react-doctor/src/utils/run-oxlint.ts b/packages/react-doctor/src/utils/run-oxlint.ts
index bfb7216..91e1c09 100644
--- a/packages/react-doctor/src/utils/run-oxlint.ts
+++ b/packages/react-doctor/src/utils/run-oxlint.ts
@@ -46,6 +46,7 @@ const RULE_CATEGORY_MAP: Record<string, string> = {
   "react-doctor/rendering-animate-svg-wrapper": "Performance",
   "react-doctor/rendering-usetransition-loading": "Performance",
   "react-doctor/rendering-hydration-no-flicker": "Performance",
+  "react-doctor/rendering-script-defer-async": "Performance",
 
   "react-doctor/no-transition-all": "Performance",
   "react-doctor/no-global-css-variable-animation": "Performance",
@@ -87,6 +88,15 @@ const RULE_CATEGORY_MAP: Record<string, string> = {
 
   "react-doctor/client-passive-event-listeners": "Performance",
 
+  "react-doctor/query-stable-query-client": "TanStack Query",
+  "react-doctor/query-no-rest-destructuring": "TanStack Query",
+  "react-doctor/query-no-void-query-fn": "TanStack Query",
+  "react-doctor/query-no-query-in-effect": "TanStack Query",
+  "react-doctor/query-mutation-missing-invalidation": "TanStack Query",
+  "react-doctor/query-no-usequery-for-mutation": "TanStack Query",
+
+  "react-doctor/js-flatmap-filter": "Performance",
+
   "react-doctor/async-parallel": "Performance",
 
   "react-doctor/rn-no-raw-text": "React Native",
@@ -97,6 +107,21 @@ const RULE_CATEGORY_MAP: Record<string, string> = {
   "react-doctor/rn-no-legacy-shadow-styles": "React Native",
   "react-doctor/rn-prefer-reanimated": "React Native",
   "react-doctor/rn-no-single-element-style-array": "React Native",
+
+  "react-doctor/tanstack-start-route-property-order": "TanStack Start",
+  "react-doctor/tanstack-start-no-direct-fetch-in-loader": "TanStack Start",
+  "react-doctor/tanstack-start-server-fn-validate-input": "TanStack Start",
+  "react-doctor/tanstack-start-no-useeffect-fetch": "TanStack Start",
+  "react-doctor/tanstack-start-missing-head-content": "TanStack Start",
+  "react-doctor/tanstack-start-no-anchor-element": "TanStack Start",
+  "react-doctor/tanstack-start-server-fn-method-order": "TanStack Start",
+  "react-doctor/tanstack-start-no-navigate-in-render": "TanStack Start",
+  "react-doctor/tanstack-start-no-dynamic-server-fn-import": "TanStack Start",
+  "react-doctor/tanstack-start-no-use-server-in-handler": "TanStack Start",
+  "react-doctor/tanstack-start-no-secrets-in-loader": "Security",
+  "react-doctor/tanstack-start-get-mutation": "Security",
+  "react-doctor/tanstack-start-redirect-in-try-catch": "TanStack Start",
+  "react-doctor/tanstack-start-loader-parallel-fetch": "Performance",
 };
 
 const RULE_HELP_MAP: Record<string, string> = {
@@ -140,6 +165,8 @@ const RULE_HELP_MAP: Record<string, string> = {
     "Replace with `const [isPending, startTransition] = useTransition()` — avoids a re-render for the loading state",
   "rendering-hydration-no-flicker":
     "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
+  "rendering-script-defer-async":
+    'Add `defer` for DOM-dependent scripts or `async` for independent ones (analytics). In Next.js, use `<Script strategy="afterInteractive" />` instead',
 
   "no-transition-all":
     'List specific properties: `transition: "opacity 200ms, transform 200ms"` — or in Tailwind use `transition-colors`, `transition-opacity`, or `transition-transform`',
@@ -216,6 +243,22 @@ const RULE_HELP_MAP: Record<string, string> = {
   "client-passive-event-listeners":
     "Add `{ passive: true }` as the third argument: `addEventListener('scroll', handler, { passive: true })`",
 
+  "query-stable-query-client":
+    "Move `new QueryClient()` to module scope or wrap in `useState(() => new QueryClient())` — recreating it on every render resets the entire cache",
+  "query-no-rest-destructuring":
+    "Destructure only the fields you need: `const { data, isLoading } = useQuery(...)` — rest destructuring subscribes to all fields and causes extra re-renders",
+  "query-no-void-query-fn":
+    "queryFn must return a value for the cache. Use the `enabled` option to conditionally disable the query instead of returning undefined",
+  "query-no-query-in-effect":
+    "React Query manages refetching automatically via queryKey dependencies and the `enabled` option — manual refetch() in useEffect is usually unnecessary",
+  "query-mutation-missing-invalidation":
+    "Add `onSuccess: () => queryClient.invalidateQueries({ queryKey: ['...'] })` so cached data stays in sync after the mutation",
+  "query-no-usequery-for-mutation":
+    "Use `useMutation()` for POST/PUT/DELETE — it provides onSuccess/onError callbacks, doesn't auto-refetch, and correctly models write operations",
+
+  "js-flatmap-filter":
+    "Use `.flatMap(item => condition ? [value] : [])` — transforms and filters in a single pass instead of creating an intermediate array",
+
   "async-parallel":
     "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to run independent operations concurrently",
 
@@ -235,6 +278,35 @@ const RULE_HELP_MAP: Record<string, string> = {
     "Use `import Animated from 'react-native-reanimated'` — animations run on the UI thread instead of the JS thread",
   "rn-no-single-element-style-array":
     "Use `style={value}` instead of `style={[value]}` — single-element arrays add unnecessary allocation",
+
+  "tanstack-start-route-property-order":
+    "Follow the order: params/validateSearch → loaderDeps → context → beforeLoad → loader → head. See https://tanstack.com/router/latest/docs/eslint/create-route-property-order",
+  "tanstack-start-no-direct-fetch-in-loader":
+    "Use `createServerFn()` from @tanstack/react-start — provides type-safe RPC, input validation, and proper server/client code splitting",
+  "tanstack-start-server-fn-validate-input":
+    "Add `.inputValidator(schema)` before `.handler()` — data crosses a network boundary and must be validated at runtime",
+  "tanstack-start-no-useeffect-fetch":
+    "Fetch data in the route `loader` instead — the router coordinates loading before rendering to avoid waterfalls",
+  "tanstack-start-missing-head-content":
+    "Add `<HeadContent />` inside `<head>` in your __root route — without it, route `head()` meta tags are silently dropped",
+  "tanstack-start-no-anchor-element":
+    "`import { Link } from '@tanstack/react-router'` — enables type-safe routes, preloading via `preload=\"intent\"`, and client-side navigation",
+  "tanstack-start-server-fn-method-order":
+    "Chain methods in order: .middleware() → .inputValidator() → .client() → .server() → .handler() — types depend on this sequence",
+  "tanstack-start-no-navigate-in-render":
+    "Use `throw redirect({ to: '/path' })` in `beforeLoad` or `loader` instead — navigate() during render causes hydration issues",
+  "tanstack-start-no-dynamic-server-fn-import":
+    "Use `import { myFn } from '~/utils/my.functions'` — the bundler replaces server code with RPC stubs only for static imports",
+  "tanstack-start-no-use-server-in-handler":
+    'TanStack Start handles server boundaries automatically via the Vite plugin — "use server" inside createServerFn causes compilation errors',
+  "tanstack-start-no-secrets-in-loader":
+    "Loaders are isomorphic (run on both server and client). Wrap secret access in `createServerFn()` so it stays server-only",
+  "tanstack-start-get-mutation":
+    "Use `createServerFn({ method: 'POST' })` for data modifications — GET requests can be triggered by prefetching and are vulnerable to CSRF",
+  "tanstack-start-redirect-in-try-catch":
+    "TanStack Router's `redirect()` and `notFound()` throw special errors caught by the router. Move them outside the try block or re-throw in the catch",
+  "tanstack-start-loader-parallel-fetch":
+    "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to avoid request waterfalls in route loaders",
 };
 
 const FILEPATH_WITH_LOCATION_PATTERN = /\S+\.\w+:\d+:\d+[\s\S]*$/;
diff --git a/packages/react-doctor/tests/fixtures/basic-react/src/js-performance-issues.tsx b/packages/react-doctor/tests/fixtures/basic-react/src/js-performance-issues.tsx
index ba826cf..2863c48 100644
--- a/packages/react-doctor/tests/fixtures/basic-react/src/js-performance-issues.tsx
+++ b/packages/react-doctor/tests/fixtures/basic-react/src/js-performance-issues.tsx
@@ -86,6 +86,11 @@ const SequentialAwaitComponent = () => {
   return <button onClick={loadData}>Load</button>;
 };
 
+const FlatmapFilterComponent = ({ users }: { users: { isActive: boolean; name: string }[] }) => {
+  const activeNames = users.map((user) => (user.isActive ? user.name : null)).filter(Boolean);
+  return <div>{activeNames.join(",")}</div>;
+};
+
 export {
   CombineIterationsComponent,
   SpreadSortComponent,
@@ -97,4 +102,5 @@ export {
   CacheStorageComponent,
   EarlyExitComponent,
   SequentialAwaitComponent,
+  FlatmapFilterComponent,
 };
diff --git a/packages/react-doctor/tests/fixtures/basic-react/src/performance-issues.tsx b/packages/react-doctor/tests/fixtures/basic-react/src/performance-issues.tsx
index 3df40ed..fd65aa6 100644
--- a/packages/react-doctor/tests/fixtures/basic-react/src/performance-issues.tsx
+++ b/packages/react-doctor/tests/fixtures/basic-react/src/performance-issues.tsx
@@ -55,6 +55,12 @@ const GlobalCssVarComponent = () => {
   return <div />;
 };
 
+const ScriptWithoutDeferComponent = () => (
+  <div>
+    <script src="https://cdn.example.com/analytics.js" />
+  </div>
+);
+
 export {
   MemoChild,
   ParentWithInlinePropOnMemo,
@@ -69,4 +75,5 @@ export {
   LoadingStateComponent,
   HydrationFlickerComponent,
   GlobalCssVarComponent,
+  ScriptWithoutDeferComponent,
 };
diff --git a/packages/react-doctor/tests/fixtures/basic-react/src/query-issues.tsx b/packages/react-doctor/tests/fixtures/basic-react/src/query-issues.tsx
new file mode 100644
index 0000000..88c01c2
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/basic-react/src/query-issues.tsx
@@ -0,0 +1,73 @@
+import { useEffect, useState } from "react";
+
+const useQuery = (options: any) => ({
+  data: null,
+  isLoading: false,
+  error: null,
+  refetch: () => {},
+});
+const useMutation = (options: any) => ({ mutate: () => {} });
+const QueryClient = class {
+  constructor(options?: any) {}
+};
+const QueryClientProvider = ({ client, children }: any) => children;
+const queryClient = { invalidateQueries: (_opts: any) => {} };
+
+const UnstableQueryClient = () => {
+  const client = new QueryClient({ defaultOptions: {} });
+  return <QueryClientProvider client={client}>Hello</QueryClientProvider>;
+};
+
+const RestDestructuring = () => {
+  const { data, ...rest } = useQuery({
+    queryKey: ["todos"],
+    queryFn: () => fetch("/api/todos"),
+  });
+  return <div>{JSON.stringify(rest)}</div>;
+};
+
+const VoidQueryFn = () => {
+  const result = useQuery({
+    queryKey: ["empty"],
+    queryFn: () => {},
+  });
+  return <div />;
+};
+
+const RefetchInEffect = () => {
+  const { data, refetch } = useQuery({
+    queryKey: ["items"],
+    queryFn: () => fetch("/api/items"),
+  });
+
+  useEffect(() => {
+    refetch();
+  }, []);
+
+  return <div>{JSON.stringify(data)}</div>;
+};
+
+const MutationMissingInvalidation = () => {
+  const mutation = useMutation({
+    mutationFn: (newTodo: any) =>
+      fetch("/api/todos", { method: "POST", body: JSON.stringify(newTodo) }),
+  });
+  return <button onClick={() => mutation.mutate({ title: "New" })}>Add</button>;
+};
+
+const UseQueryForMutation = () => {
+  const result = useQuery({
+    queryKey: ["create-user"],
+    queryFn: () => fetch("/api/users", { method: "POST", body: JSON.stringify({ name: "John" }) }),
+  });
+  return <div />;
+};
+
+export {
+  UnstableQueryClient,
+  RestDestructuring,
+  VoidQueryFn,
+  RefetchInEffect,
+  MutationMissingInvalidation,
+  UseQueryForMutation,
+};
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/package.json b/packages/react-doctor/tests/fixtures/tanstack-start-app/package.json
new file mode 100644
index 0000000..0bae45f
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "test-tanstack-start-app",
+  "private": true,
+  "dependencies": {
+    "@tanstack/react-router": "^1.0.0",
+    "@tanstack/react-start": "^1.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  }
+}
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/__root.tsx b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/__root.tsx
new file mode 100644
index 0000000..52f426b
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/__root.tsx
@@ -0,0 +1,15 @@
+const createRootRoute = (options: any) => options;
+const Outlet = () => <div />;
+const Scripts = () => <script />;
+
+export const Route = createRootRoute({
+  component: () => (
+    <html lang="en">
+      <head></head>
+      <body>
+        <Outlet />
+        <Scripts />
+      </body>
+    </html>
+  ),
+});
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/edge-cases.tsx b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/edge-cases.tsx
new file mode 100644
index 0000000..15c4658
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/edge-cases.tsx
@@ -0,0 +1,62 @@
+const createFileRoute = (_path: string) => (options: any) => options;
+const createRootRoute = (options: any) => options;
+const createServerFn = (options?: any) => ({
+  inputValidator: (schema: any) => ({ handler: (fn: any) => fn }),
+  handler: (fn: any) => fn,
+});
+
+export const CorrectPropertyOrder = createFileRoute("/correct")({
+  validateSearch: (search: any) => search,
+  beforeLoad: async () => ({ user: { id: "1" } }),
+  loader: async ({ context }: any) => context.user,
+  component: () => <div />,
+});
+
+export const RootRouteWithCorrectOrder = createRootRoute({
+  beforeLoad: async () => ({ session: {} }),
+  loader: async ({ context }: any) => context.session,
+  component: () => <div />,
+});
+
+export const PutMethodServerFn = createServerFn({ method: "PUT" }).handler(async () => {
+  const db = { users: { update: (_data: any) => {} } };
+  await db.users.update({ id: "1", name: "updated" });
+  return { success: true };
+});
+
+export const DeleteMethodServerFn = createServerFn({ method: "DELETE" }).handler(async () => {
+  const db = { users: { delete: (_id: string) => {} } };
+  await db.users.delete("123");
+  return { success: true };
+});
+
+export const ValidatedServerFn = createServerFn({ method: "POST" })
+  .inputValidator((data: any) => data)
+  .handler(async ({ data }: any) => {
+    return { id: "1", ...data };
+  });
+
+export const CorrectLoaderWithServerFn = createFileRoute("/correct-loader")({
+  loader: async () => {
+    return { data: "from server fn" };
+  },
+  component: () => <div />,
+});
+
+export const JsonLdScript = () => (
+  <div>
+    <script type="application/ld+json" src="/structured-data.json" />
+  </div>
+);
+
+export const DeferredScript = () => (
+  <div>
+    <script src="https://analytics.example.com/track.js" defer />
+  </div>
+);
+
+export const AsyncScript = () => (
+  <div>
+    <script src="https://analytics.example.com/track.js" async />
+  </div>
+);
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/route-issues.tsx b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/route-issues.tsx
new file mode 100644
index 0000000..75b6a29
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/route-issues.tsx
@@ -0,0 +1,95 @@
+import { useEffect } from "react";
+
+const createFileRoute = (_path: string) => (options: any) => options;
+const createRootRoute = (options: any) => options;
+const redirect = (_opts: any) => {
+  throw new Error("redirect");
+};
+const notFound = () => {
+  throw new Error("notFound");
+};
+const navigate = (_opts: any) => {};
+
+export const RootPropertyOrderRoute = createRootRoute({
+  loader: async ({ context }: any) => {
+    return context.user;
+  },
+  beforeLoad: async () => {
+    return { user: { id: "1" } };
+  },
+  component: () => <div />,
+});
+
+export const PropertyOrderRoute = createFileRoute("/property-order")({
+  loader: async ({ context }: any) => {
+    return context.user;
+  },
+  beforeLoad: async () => {
+    return { user: { id: "1" } };
+  },
+  component: () => <div />,
+});
+
+export const DirectFetchRoute = createFileRoute("/direct-fetch")({
+  loader: async () => {
+    const response = await fetch("/api/posts");
+    return response.json();
+  },
+  component: () => <div />,
+});
+
+export const UseEffectFetchRoute = createFileRoute("/effect-fetch")({
+  component: () => {
+    useEffect(() => {
+      fetch("/api/data");
+    }, []);
+    return <div />;
+  },
+});
+
+export const AnchorRoute = createFileRoute("/anchor")({
+  component: () => (
+    <div>
+      <a href="/about">About</a>
+    </div>
+  ),
+});
+
+const NavigateInRenderComponent = () => {
+  const user = null;
+  if (!user) navigate({ to: "/login" });
+  return <div />;
+};
+
+export const NavigateRoute = createFileRoute("/navigate")({
+  component: NavigateInRenderComponent,
+});
+
+export const SecretsRoute = createFileRoute("/secrets")({
+  loader: async () => {
+    const secret = process.env.DATABASE_URL;
+    return { secret };
+  },
+  component: () => <div />,
+});
+
+export const RedirectInTryCatchRoute = createFileRoute("/redirect-try")({
+  loader: async () => {
+    try {
+      const post = await Promise.resolve(null);
+      if (!post) throw notFound();
+    } catch {
+      return null;
+    }
+  },
+  component: () => <div />,
+});
+
+export const ParallelFetchRoute = createFileRoute("/parallel")({
+  loader: async () => {
+    const users = await fetch("/api/users").then((r) => r.json());
+    const posts = await fetch("/api/posts").then((r) => r.json());
+    return { users, posts };
+  },
+  component: () => <div />,
+});
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/server-fn-issues.tsx b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/server-fn-issues.tsx
new file mode 100644
index 0000000..46189a9
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/src/routes/server-fn-issues.tsx
@@ -0,0 +1,34 @@
+const chainable: any = new Proxy(
+  {},
+  {
+    get:
+      (_target, _prop) =>
+      (..._args: any[]) =>
+        chainable,
+  },
+);
+const createServerFn = (_options?: any) => chainable;
+
+export const noValidationFn = createServerFn({ method: "POST" }).handler(async ({ data }: any) => {
+  return { id: "1", ...data };
+});
+
+export const wrongMethodOrder = createServerFn({ method: "POST" })
+  .handler(async ({ data }: any) => data)
+  .inputValidator((data: any) => data);
+
+export const useServerInHandler = createServerFn().handler(async () => {
+  "use server";
+  return { ok: true };
+});
+
+export const getMutationFn = createServerFn().handler(async () => {
+  const db = { users: { delete: (_id: string) => {} } };
+  await db.users.delete("123");
+  return { success: true };
+});
+
+export const dynamicImportFn = async () => {
+  const mod = await import("~/utils/users.functions");
+  return mod;
+};
diff --git a/packages/react-doctor/tests/fixtures/tanstack-start-app/tsconfig.json b/packages/react-doctor/tests/fixtures/tanstack-start-app/tsconfig.json
new file mode 100644
index 0000000..d701bd5
--- /dev/null
+++ b/packages/react-doctor/tests/fixtures/tanstack-start-app/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "paths": {
+      "~/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}
diff --git a/packages/react-doctor/tests/run-oxlint.test.ts b/packages/react-doctor/tests/run-oxlint.test.ts
index 994d7b7..3a369df 100644
--- a/packages/react-doctor/tests/run-oxlint.test.ts
+++ b/packages/react-doctor/tests/run-oxlint.test.ts
@@ -6,6 +6,7 @@ import { runOxlint } from "../src/utils/run-oxlint.js";
 const FIXTURES_DIRECTORY = path.resolve(import.meta.dirname, "fixtures");
 const BASIC_REACT_DIRECTORY = path.join(FIXTURES_DIRECTORY, "basic-react");
 const NEXTJS_APP_DIRECTORY = path.join(FIXTURES_DIRECTORY, "nextjs-app");
+const TANSTACK_START_APP_DIRECTORY = path.join(FIXTURES_DIRECTORY, "tanstack-start-app");
 
 const findDiagnosticsByRule = (diagnostics: Diagnostic[], rule: string): Diagnostic[] =>
   diagnostics.filter((diagnostic) => diagnostic.rule === rule);
@@ -36,6 +37,7 @@ const describeRules = (
 
 let basicReactDiagnostics: Diagnostic[];
 let nextjsDiagnostics: Diagnostic[];
+let tanstackStartDiagnostics: Diagnostic[];
 
 describe("runOxlint", () => {
   it("loads basic-react diagnostics", async () => {
@@ -48,6 +50,16 @@ describe("runOxlint", () => {
     expect(nextjsDiagnostics.length).toBeGreaterThan(0);
   });
 
+  it("loads tanstack-start diagnostics", async () => {
+    tanstackStartDiagnostics = await runOxlint(
+      TANSTACK_START_APP_DIRECTORY,
+      true,
+      "tanstack-start",
+      false,
+    );
+    expect(tanstackStartDiagnostics.length).toBeGreaterThan(0);
+  });
+
   it("returns diagnostics with required fields", () => {
     for (const diagnostic of basicReactDiagnostics) {
       expect(diagnostic).toHaveProperty("filePath");
@@ -196,6 +208,11 @@ describe("runOxlint", () => {
         fixture: "client-issues.tsx",
         ruleSource: "rules/client.ts",
       },
+      "rendering-script-defer-async": {
+        fixture: "performance-issues.tsx",
+        ruleSource: "rules/performance.ts",
+        category: "Performance",
+      },
     },
     () => basicReactDiagnostics,
   );
@@ -207,6 +224,11 @@ describe("runOxlint", () => {
         fixture: "js-performance-issues.tsx",
         ruleSource: "rules/js-performance.ts",
       },
+      "js-flatmap-filter": {
+        fixture: "js-performance-issues.tsx",
+        ruleSource: "rules/js-performance.ts",
+        category: "Performance",
+      },
     },
     () => basicReactDiagnostics,
   );
@@ -357,6 +379,164 @@ describe("runOxlint", () => {
     () => nextjsDiagnostics,
   );
 
+  describeRules(
+    "tanstack-query rules",
+    {
+      "query-stable-query-client": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        severity: "error",
+        category: "TanStack Query",
+      },
+      "query-no-rest-destructuring": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        category: "TanStack Query",
+      },
+      "query-no-void-query-fn": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        category: "TanStack Query",
+      },
+      "query-no-query-in-effect": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        category: "TanStack Query",
+      },
+      "query-mutation-missing-invalidation": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        category: "TanStack Query",
+      },
+      "query-no-usequery-for-mutation": {
+        fixture: "src/query-issues.tsx",
+        ruleSource: "rules/tanstack-query.ts",
+        category: "TanStack Query",
+      },
+    },
+    () => basicReactDiagnostics,
+  );
+
+  describeRules(
+    "tanstack-start rules",
+    {
+      "tanstack-start-route-property-order": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        severity: "error",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-direct-fetch-in-loader": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-useeffect-fetch": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-anchor-element": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-navigate-in-render": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-secrets-in-loader": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        severity: "error",
+        category: "Security",
+      },
+      "tanstack-start-redirect-in-try-catch": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-loader-parallel-fetch": {
+        fixture: "src/routes/route-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "Performance",
+      },
+      "tanstack-start-missing-head-content": {
+        fixture: "src/routes/__root.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-server-fn-method-order": {
+        fixture: "src/routes/server-fn-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        severity: "error",
+        category: "TanStack Start",
+      },
+      "tanstack-start-server-fn-validate-input": {
+        fixture: "src/routes/server-fn-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "TanStack Start",
+      },
+      "tanstack-start-no-use-server-in-handler": {
+        fixture: "src/routes/server-fn-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        severity: "error",
+        category: "TanStack Start",
+      },
+      "tanstack-start-get-mutation": {
+        fixture: "src/routes/server-fn-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        category: "Security",
+      },
+      "tanstack-start-no-dynamic-server-fn-import": {
+        fixture: "src/routes/server-fn-issues.tsx",
+        ruleSource: "rules/tanstack-start.ts",
+        severity: "error",
+        category: "TanStack Start",
+      },
+    },
+    () => tanstackStartDiagnostics,
+  );
+
+  describe("tanstack-start edge cases (false positive freedom)", () => {
+    it("does not flag correct property order in createFileRoute", () => {
+      const propertyOrderIssues = tanstackStartDiagnostics.filter(
+        (diagnostic) =>
+          diagnostic.rule === "tanstack-start-route-property-order" &&
+          diagnostic.filePath.includes("edge-cases"),
+      );
+      expect(propertyOrderIssues).toHaveLength(0);
+    });
+
+    it("does not flag createServerFn with PUT or DELETE method as get-mutation", () => {
+      const getMutationIssues = tanstackStartDiagnostics.filter(
+        (diagnostic) =>
+          diagnostic.rule === "tanstack-start-get-mutation" &&
+          diagnostic.filePath.includes("edge-cases"),
+      );
+      expect(getMutationIssues).toHaveLength(0);
+    });
+
+    it("does not flag server function with inputValidator as missing validation", () => {
+      const validationIssues = tanstackStartDiagnostics.filter(
+        (diagnostic) =>
+          diagnostic.rule === "tanstack-start-server-fn-validate-input" &&
+          diagnostic.filePath.includes("edge-cases"),
+      );
+      expect(validationIssues).toHaveLength(0);
+    });
+
+    it("does not flag script with type=application/ld+json", () => {
+      const scriptIssues = tanstackStartDiagnostics.filter(
+        (diagnostic) =>
+          diagnostic.rule === "rendering-script-defer-async" &&
+          diagnostic.filePath.includes("edge-cases"),
+      );
+      expect(scriptIssues).toHaveLength(0);
+    });
+  });
+
   describe("customRulesOnly mode", () => {
     it("excludes builtin react/ and jsx-a11y/ rules when customRulesOnly is true", async () => {
       const customOnlyDiagnostics = await runOxlint(
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b56c40f..0a7bd09 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -25,11 +25,11 @@ importers:
         specifier: ^7.0.1
         version: 7.0.1(eslint@9.39.2(jiti@2.6.1))
       oxfmt:
-        specifier: ^0.44.0
-        version: 0.44.0
+        specifier: ^0.45.0
+        version: 0.45.0
       oxlint:
-        specifier: ^1.59.0
-        version: 1.59.0
+        specifier: ^1.60.0
+        version: 1.60.0
       tsdown:
         specifier: ^0.21.7
         version: 0.21.7(oxc-resolver@11.19.1)(typescript@6.0.2)
@@ -55,8 +55,8 @@ importers:
         specifier: ^9.3.0
         version: 9.3.0
       oxlint:
-        specifier: ^1.59.0
-        version: 1.59.0
+        specifier: ^1.60.0
+        version: 1.60.0
       picocolors:
         specifier: ^1.1.1
         version: 1.1.1
@@ -981,246 +981,246 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@oxfmt/binding-android-arm-eabi@0.44.0':
-    resolution: {integrity: sha512-5UvghMd9SA/yvKTWCAxMAPXS1d2i054UeOf4iFjZjfayTwCINcC3oaSXjtbZfCaEpxgJod7XiOjTtby5yEv/BQ==}
+  '@oxfmt/binding-android-arm-eabi@0.45.0':
+    resolution: {integrity: sha512-A/UMxFob1fefCuMeGxQBulGfFE38g2Gm23ynr3u6b+b7fY7/ajGbNsa3ikMIkGMLJW/TRoQaMoP1kME7S+815w==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [android]
 
-  '@oxfmt/binding-android-arm64@0.44.0':
-    resolution: {integrity: sha512-IVudM1BWfvrYO++Khtzr8q9n5Rxu7msUvoFMqzGJVdX7HfUXUDHwaH2zHZNB58svx2J56pmCUzophyaPFkcG/A==}
+  '@oxfmt/binding-android-arm64@0.45.0':
+    resolution: {integrity: sha512-L63z4uZmHjgvvqvMJD7mwff8aSBkM0+X4uFr6l6U5t6+Qc9DCLVZWIunJ7Gm4fn4zHPdSq6FFQnhu9yqqobxIg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
-  '@oxfmt/binding-darwin-arm64@0.44.0':
-    resolution: {integrity: sha512-eWCLAIKAHfx88EqEP1Ga2yz7qVcqDU5lemn4xck+07bH182hDdprOHjbogyk0In1Djys3T0/pO2JepFnRJ41Mg==}
+  '@oxfmt/binding-darwin-arm64@0.45.0':
+    resolution: {integrity: sha512-UV34dd623FzqT+outIGndsCA/RBB+qgB3XVQhgmmJ9PJwa37NzPC9qzgKeOhPKxVk2HW+JKldQrVL54zs4Noww==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
-  '@oxfmt/binding-darwin-x64@0.44.0':
-    resolution: {integrity: sha512-eHTBznHLM49++dwz07MblQ2cOXyIgeedmE3Wgy4ptUESj38/qYZyRi1MPwC9olQJWssMeY6WI3UZ7YmU5ggvyQ==}
+  '@oxfmt/binding-darwin-x64@0.45.0':
+    resolution: {integrity: sha512-pMNJv0CMa1pDefVPeNbuQxibh8ITpWDFEhMC/IBB9Zlu76EbgzYwrzI4Cb11mqX2+rIYN70UTrh3z06TM59ptQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
-  '@oxfmt/binding-freebsd-x64@0.44.0':
-    resolution: {integrity: sha512-jLMmbj0u0Ft43QpkUVr/0v1ZfQCGWAvU+WznEHcN3wZC/q6ox7XeSJtk9P36CCpiDSUf3sGnzbIuG1KdEMEDJQ==}
+  '@oxfmt/binding-freebsd-x64@0.45.0':
+    resolution: {integrity: sha512-xTcRoxbbo61sW2+ZRPeH+vp/o9G8gkdhiVumFU+TpneiPm14c79l6GFlxPXlCE9bNWikigbsrvJw46zCVAQFfg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
-  '@oxfmt/binding-linux-arm-gnueabihf@0.44.0':
-    resolution: {integrity: sha512-n+A/u/ByK1qV8FVGOwyaSpw5NPNl0qlZfgTBqHeGIqr8Qzq1tyWZ4lAaxPoe5mZqE3w88vn3+jZtMxriHPE7tg==}
+  '@oxfmt/binding-linux-arm-gnueabihf@0.45.0':
+    resolution: {integrity: sha512-hWL8Hdni+3U1mPFx1UtWeGp3tNb6EhBAUHRMbKUxVkOp3WwoJbpVO2bfUVbS4PfpledviXXNHSTl1veTa6FhkQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@oxfmt/binding-linux-arm-musleabihf@0.44.0':
-    resolution: {integrity: sha512-5eax+FkxyCqAi3Rw0mrZFr7+KTt/XweFsbALR+B5ljWBLBl8nHe4ADrUnb1gLEfQCJLl+Ca5FIVD4xEt95AwIw==}
+  '@oxfmt/binding-linux-arm-musleabihf@0.45.0':
+    resolution: {integrity: sha512-6Blt/0OBT7vvfQpqYuYbpbFLPqSiaYpEJzUUWhinPEuADypDbtV1+LdjM0vYBNGPvnj85ex7lTerEX6JGcPt9w==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@oxfmt/binding-linux-arm64-gnu@0.44.0':
-    resolution: {integrity: sha512-58l8JaHxSGOmOMOG2CIrNsnkRJAj0YcHQCmvNACniOa/vd1iRHhlPajczegzS5jwMENlqgreyiTR9iNlke8qCw==}
+  '@oxfmt/binding-linux-arm64-gnu@0.45.0':
+    resolution: {integrity: sha512-jLjoLfe+hGfjhA8hNBSdw85yCA8ePKq7ME4T+g6P9caQXvmt6IhE2X7iVjnVdkmYUWEzZrxlh4p6RkDmAMJY/A==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
-  '@oxfmt/binding-linux-arm64-musl@0.44.0':
-    resolution: {integrity: sha512-AlObQIXyVRZ96LbtVljtFq0JqH5B92NU+BQeDFrXWBUWlCKAM0wF5GLfIhCLT5kQ3Sl+U0YjRJ7Alqj5hGQaCg==}
+  '@oxfmt/binding-linux-arm64-musl@0.45.0':
+    resolution: {integrity: sha512-XQKXZIKYJC3GQJ8FnD3iMntpw69Wd9kDDK/Xt79p6xnFYlGGxSNv2vIBvRTDg5CKByWFWWZLCRDOXoP/m6YN4g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
-  '@oxfmt/binding-linux-ppc64-gnu@0.44.0':
-    resolution: {integrity: sha512-YcFE8/q/BbrCiIiM5piwbkA6GwJc5QqhMQp2yDrqQ2fuVkZ7CInb1aIijZ/k8EXc72qXMSwKpVlBv1w/MsGO/A==}
+  '@oxfmt/binding-linux-ppc64-gnu@0.45.0':
+    resolution: {integrity: sha512-+g5RiG+xOkdrCWkKodv407nTvMq4vYM18Uox2MhZBm/YoqFxxJpWKsloskFFG5NU13HGPw1wzYjjOVcyd9moCA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
     libc: [glibc]
 
-  '@oxfmt/binding-linux-riscv64-gnu@0.44.0':
-    resolution: {integrity: sha512-eOdzs6RqkRzuqNHUX5C8ISN5xfGh4xDww8OEd9YAmc3OWN8oAe5bmlIqQ+rrHLpv58/0BuU48bxkhnIGjA/ATQ==}
+  '@oxfmt/binding-linux-riscv64-gnu@0.45.0':
+    resolution: {integrity: sha512-V7dXKoSyEbWAkkSF4JJNtF+NJZDmJoSarSoP30WCsB3X636Rehd3CvxBj49FIJxEBFWhvcUjGSHVeU8Erck1bQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
     libc: [glibc]
 
-  '@oxfmt/binding-linux-riscv64-musl@0.44.0':
-    resolution: {integrity: sha512-YBgNTxntD/QvlFUfgvh8bEdwOhXiquX8gaofZJAwYa/Xp1S1DQrFVZEeck7GFktr24DztsSp8N8WtWCBwxs0Hw==}
+  '@oxfmt/binding-linux-riscv64-musl@0.45.0':
+    resolution: {integrity: sha512-Vdelft1sAEYojVGgcODEFXSWYQYlIvoyIGWebKCuUibd1tvS1TjTx413xG2ZLuHpYj45CkN/ztMLMX6jrgqpgg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
     libc: [musl]
 
-  '@oxfmt/binding-linux-s390x-gnu@0.44.0':
-    resolution: {integrity: sha512-GLIh1R6WHWshl/i4QQDNgj0WtT25aRO4HNUWEoitxiywyRdhTFmFEYT2rXlcl9U6/26vhmOqG5cRlMLG3ocaIA==}
+  '@oxfmt/binding-linux-s390x-gnu@0.45.0':
+    resolution: {integrity: sha512-RR7xKgNpqwENnK0aYCGYg0JycY2n93J0reNjHyes+I9Gq52dH95x+CBlnlAQHCPfz6FGnKA9HirgUl14WO6o7w==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
     libc: [glibc]
 
-  '@oxfmt/binding-linux-x64-gnu@0.44.0':
-    resolution: {integrity: sha512-gZOpgTlOsLcLfAF9qgpTr7FIIFSKnQN3hDf/0JvQ4CIwMY7h+eilNjxq/CorqvYcEOu+LRt1W4ZS7KccEHLOdA==}
+  '@oxfmt/binding-linux-x64-gnu@0.45.0':
+    resolution: {integrity: sha512-U/QQ0+BQNSHxjuXR/utvXnQ50Vu5kUuqEomZvQ1/3mhgbBiMc2WU9q5kZ5WwLp3gnFIx9ibkveoRSe2EZubkqg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
-  '@oxfmt/binding-linux-x64-musl@0.44.0':
-    resolution: {integrity: sha512-1CyS9JTB+pCUFYFI6pkQGGZaT/AY5gnhHVrQQLhFba6idP9AzVYm1xbdWfywoldTYvjxQJV6x4SuduCIfP3W+A==}
+  '@oxfmt/binding-linux-x64-musl@0.45.0':
+    resolution: {integrity: sha512-o5TLOUCF0RWQjsIS06yVC+kFgp092/yLe6qBGSUvtnmTVw9gxjpdQSXc3VN5Cnive4K11HNstEZF8ROKHfDFSw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
-  '@oxfmt/binding-openharmony-arm64@0.44.0':
-    resolution: {integrity: sha512-bmEv70Ak6jLr1xotCbF5TxIKjsmQaiX+jFRtnGtfA03tJPf6VG3cKh96S21boAt3JZc+Vjx8PYcDuLj39vM2Pw==}
+  '@oxfmt/binding-openharmony-arm64@0.45.0':
+    resolution: {integrity: sha512-RnGcV3HgPuOjsGx/k9oyRNKmOp+NBLGzZTdPDYbc19r7NGeYPplnUU/BfU35bX2Y/O4ejvHxcfkvW2WoYL/gsg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
-  '@oxfmt/binding-win32-arm64-msvc@0.44.0':
-    resolution: {integrity: sha512-yWzB+oCpSnP/dmw85eFLAT5o35Ve5pkGS2uF/UCISpIwDqf1xa7OpmtomiqY/Vzg8VyvMbuf6vroF2khF/+1Vg==}
+  '@oxfmt/binding-win32-arm64-msvc@0.45.0':
+    resolution: {integrity: sha512-v3Vj7iKKsUFwt9w5hsqIIoErKVoENC6LoqfDlteOQ5QMDCXihlqLoxpmviUhXnNncg4zV6U9BPwlBbwa+qm4wg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
-  '@oxfmt/binding-win32-ia32-msvc@0.44.0':
-    resolution: {integrity: sha512-TcWpo18xEIE3AmIG2kpr3kz5IEhQgnx0lazl2+8L+3eTopOAUevQcmlr4nhguImNWz0OMeOZrYZOhJNCf16nlQ==}
+  '@oxfmt/binding-win32-ia32-msvc@0.45.0':
+    resolution: {integrity: sha512-N8yotPBX6ph0H3toF4AEpdCeVPrdcSetj+8eGiZGsrLsng3bs/Q5HPu4bbSxip5GBPx5hGbGHrZwH4+rcrjhHA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ia32]
     os: [win32]
 
-  '@oxfmt/binding-win32-x64-msvc@0.44.0':
-    resolution: {integrity: sha512-oj8aLkPJZppIM4CMQNsyir9ybM1Xw/CfGPTSsTnzpVGyljgfbdP0EVUlURiGM0BDrmw5psQ6ArmGCcUY/yABaQ==}
+  '@oxfmt/binding-win32-x64-msvc@0.45.0':
+    resolution: {integrity: sha512-w5MMTRCK1dpQeRA+HHqXQXyN33DlG/N2LOYxJmaT4fJjcmZrbNnqw7SmIk7I2/a2493PPLZ+2E/Ar6t2iKVMug==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
 
-  '@oxlint/binding-android-arm-eabi@1.59.0':
-    resolution: {integrity: sha512-etYDw/UaEv936AQUd/CRMBVd+e+XuuU6wC+VzOv1STvsTyZenLChepLWqLtnyTTp4YMlM22ypzogDDwqYxv5cg==}
+  '@oxlint/binding-android-arm-eabi@1.60.0':
+    resolution: {integrity: sha512-YdeJKaZckDQL1qa62a1aKq/goyq48aX3yOxaaWqWb4sau4Ee4IiLbamftNLU3zbePky6QsDj6thnSSzHRBjDfA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [android]
 
-  '@oxlint/binding-android-arm64@1.59.0':
-    resolution: {integrity: sha512-TgLc7XVLKH2a4h8j3vn1MDjfK33i9MY60f/bKhRGWyVzbk5LCZ4X01VZG7iHrMmi5vYbAp8//Ponigx03CLsdw==}
+  '@oxlint/binding-android-arm64@1.60.0':
+    resolution: {integrity: sha512-7ANS7PpXCfq84xZQ8E5WPs14gwcuPcl+/8TFNXfpSu0CQBXz3cUo2fDpHT8v8HJN+Ut02eacvMAzTnc9s6X4tw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
-  '@oxlint/binding-darwin-arm64@1.59.0':
-    resolution: {integrity: sha512-DXyFPf5ZKldMLloRHx/B9fsxsiTQomaw7cmEW3YIJko2HgCh+GUhp9gGYwHrqlLJPsEe3dYj9JebjX92D3j3AA==}
+  '@oxlint/binding-darwin-arm64@1.60.0':
+    resolution: {integrity: sha512-pJsgd9AfplLGBm1fIr25V6V14vMrayhx4uIQvlfH7jWs2SZwSrvi3TfgfJySB8T+hvyEH8K2zXljQiUnkgUnfQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
-  '@oxlint/binding-darwin-x64@1.59.0':
-    resolution: {integrity: sha512-LgvrsdgVLX1qWqIEmNsSmMXJhpAWdtUQ0M+oR0CySwi+9IHWyOGuIL8w8+u/kbZNMyZr4WUyYB5i0+D+AKgkLg==}
+  '@oxlint/binding-darwin-x64@1.60.0':
+    resolution: {integrity: sha512-Ue1aXHX49ivwflKqGJc7zcd/LeLgbhaTcDCQStgx5x06AXgjEAZmvrlMuIkWd4AL4FHQe6QJ9f33z04Cg448VQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
-  '@oxlint/binding-freebsd-x64@1.59.0':
-    resolution: {integrity: sha512-bOJhqX/ny4hrFuTPlyk8foSRx/vLRpxJh0jOOKN2NWW6FScXHPAA5rQbrwdQPcgGB5V8Ua51RS03fke8ssBcug==}
+  '@oxlint/binding-freebsd-x64@1.60.0':
+    resolution: {integrity: sha512-YCyQzsQtusQw+gNRW9rRTifSO+Dt/+dtCl2NHoDMZqJlRTEZ/Oht9YnuporI9yiTx7+cB+eqzX3MtHHVHGIWhg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
-  '@oxlint/binding-linux-arm-gnueabihf@1.59.0':
-    resolution: {integrity: sha512-vVUXxYMF9trXCsz4m9H6U0IjehosVHxBzVgJUxly1uz4W1PdDyicaBnpC0KRXsHYretLVe+uS9pJy8iM57Kujw==}
+  '@oxlint/binding-linux-arm-gnueabihf@1.60.0':
+    resolution: {integrity: sha512-c7dxM2Zksa45Qw16i2iGY3Fti2NirJ38FrsBsKw+qcJ0OtqTsBgKJLF0xV+yLG56UH01Z8WRPgsw31e0MoRoGQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@oxlint/binding-linux-arm-musleabihf@1.59.0':
-    resolution: {integrity: sha512-TULQW8YBPGRWg5yZpFPL54HLOnJ3/HiX6VenDPi6YfxB/jlItwSMFh3/hCeSNbh+DAMaE1Py0j5MOaivHkI/9Q==}
+  '@oxlint/binding-linux-arm-musleabihf@1.60.0':
+    resolution: {integrity: sha512-ZWALoA42UYqBEP1Tbw9OWURgFGS1nWj2AAvLdY6ZcGx/Gj93qVCBKjcvwXMupZibYwFbi9s/rzqkZseb/6gVtQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
-  '@oxlint/binding-linux-arm64-gnu@1.59.0':
-    resolution: {integrity: sha512-Gt54Y4eqSgYJ90xipm24xeyaPV854706o/kiT8oZvUt3VDY7qqxdqyGqchMaujd87ib+/MXvnl9WkK8Cc1BExg==}
+  '@oxlint/binding-linux-arm64-gnu@1.60.0':
+    resolution: {integrity: sha512-tpy+1w4p9hN5CicMCxqNy6ymfRtV5ayE573vFNjp1k1TN/qhLFgflveZoE/0++RlkHikBz2vY545NWm/hp7big==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
-  '@oxlint/binding-linux-arm64-musl@1.59.0':
-    resolution: {integrity: sha512-3CtsKp7NFB3OfqQzbuAecrY7GIZeiv7AD+xutU4tefVQzlfmTI7/ygWLrvkzsDEjTlMq41rYHxgsn6Yh8tybmA==}
+  '@oxlint/binding-linux-arm64-musl@1.60.0':
+    resolution: {integrity: sha512-eDYDXZGhQAXyn6GwtwiX/qcLS0HlOLPJ/+iiIY8RYr+3P8oKBmgKxADLlniL6FtWfE7pPk7IGN9/xvDEvDvFeg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
-  '@oxlint/binding-linux-ppc64-gnu@1.59.0':
-    resolution: {integrity: sha512-K0diOpT3ncDmOfl9I1HuvpEsAuTxkts0VYwIv/w6Xiy9CdwyPBVX88Ga9l8VlGgMrwBMnSY4xIvVlVY/fkQk7Q==}
+  '@oxlint/binding-linux-ppc64-gnu@1.60.0':
+    resolution: {integrity: sha512-nxehly5XYBHUWI9VJX1bqCf9j/B43DaK/aS/T1fcxCpX3PA4Rm9BB54nPD1CKayT8xg6REN1ao+01hSRNgy8OA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
     libc: [glibc]
 
-  '@oxlint/binding-linux-riscv64-gnu@1.59.0':
-    resolution: {integrity: sha512-xAU7+QDU6kTJJ7mJLOGgo7oOjtAtkKyFZ0Yjdb5cEo3DiCCPFLvyr08rWiQh6evZ7RiUTf+o65NY/bqttzJiQQ==}
+  '@oxlint/binding-linux-riscv64-gnu@1.60.0':
+    resolution: {integrity: sha512-j1qf/NaUfOWQutjeoooNG1Q0zsK0XGmSu1uDLq3cctquRF3j7t9Hxqf/76ehCc5GEUAanth2W4Fa+XT1RFg/nw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
     libc: [glibc]
 
-  '@oxlint/binding-linux-riscv64-musl@1.59.0':
-    resolution: {integrity: sha512-KUmZmKlTTyauOnvUNVxK7G40sSSx0+w5l1UhaGsC6KPpOYHenx2oqJTnabmpLJicok7IC+3Y6fXAUOMyexaeJQ==}
+  '@oxlint/binding-linux-riscv64-musl@1.60.0':
+    resolution: {integrity: sha512-YELKPRefQ/q/h3RUmeRfPCUhh2wBvgV1RyZ/F9M9u8cDyXsQW2ojv1DeWQTt466yczDITjZnIOg/s05pk7Ve2A==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
     libc: [musl]
 
-  '@oxlint/binding-linux-s390x-gnu@1.59.0':
-    resolution: {integrity: sha512-4usRxC8gS0PGdkHnRmwJt/4zrQNZyk6vL0trCxwZSsAKM+OxhB8nKiR+mhjdBbl8lbMh2gc3bZpNN/ik8c4c2A==}
+  '@oxlint/binding-linux-s390x-gnu@1.60.0':
+    resolution: {integrity: sha512-JkO3C6Gki7Y6h/MiIkFKvHFOz98/YWvQ4WYbK9DLXACMP2rjULzkeGyAzorJE5S1dzLQGFgeqvN779kSFwoV1g==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
     libc: [glibc]
 
-  '@oxlint/binding-linux-x64-gnu@1.59.0':
-    resolution: {integrity: sha512-s/rNE2gDmbwAOOP493xk2X7M8LZfI1LJFSSW1+yanz3vuQCFPiHkx4GY+O1HuLUDtkzGlhtMrIcxxzyYLv308w==}
+  '@oxlint/binding-linux-x64-gnu@1.60.0':
+    resolution: {integrity: sha512-XjKHdFVCpZZZSWBCKyyqCq65s2AKXykMXkjLoKYODrD+f5toLhlwsMESscu8FbgnJQ4Y/dpR/zdazsahmgBJIA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
-  '@oxlint/binding-linux-x64-musl@1.59.0':
-    resolution: {integrity: sha512-+yYj1udJa2UvvIUmEm0IcKgc0UlPMgz0nsSTvkPL2y6n0uU5LgIHSwVu4AHhrve6j9BpVSoRksnz8c9QcvITJA==}
+  '@oxlint/binding-linux-x64-musl@1.60.0':
+    resolution: {integrity: sha512-js29ZWIuPhNWzY8NC7KoffEMEeWG105vbmm+8EOJsC+T/jHBiKIJEUF78+F/IrgEWMMP9N0kRND4Pp75+xAhKg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
-  '@oxlint/binding-openharmony-arm64@1.59.0':
-    resolution: {integrity: sha512-bUplUb48LYsB3hHlQXP2ZMOenpieWoOyppLAnnAhuPag3MGPnt+7caxE3w/Vl9wpQsTA3gzLntQi9rxWrs7Xqg==}
+  '@oxlint/binding-openharmony-arm64@1.60.0':
+    resolution: {integrity: sha512-H+PUITKHk04stFpWj3x3Kg08Afp/bcXSBi0EhasR5a0Vw7StXHTzdl655PUI0fB4qdh2Wsu6Dsi+3ACxPoyQnA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
-  '@oxlint/binding-win32-arm64-msvc@1.59.0':
-    resolution: {integrity: sha512-/HLsLuz42rWl7h7ePdmMTpHm2HIDmPtcEMYgm5BBEHiEiuNOrzMaUpd2z7UnNni5LGN9obJy2YoAYBLXQwazrA==}
+  '@oxlint/binding-win32-arm64-msvc@1.60.0':
+    resolution: {integrity: sha512-WA/yc7f7ZfCefBXVzNHn1Ztulb1EFwNBb4jMZ6pjML0zz6pHujlF3Q3jySluz3XHl/GNeMTntG1seUBWVMlMag==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
-  '@oxlint/binding-win32-ia32-msvc@1.59.0':
-    resolution: {integrity: sha512-rUPy+JnanpPwV/aJCPnxAD1fW50+XPI0VkWr7f0vEbqcdsS8NpB24Rw6RsS7SdpFv8Dw+8ugCwao5nCFbqOUSg==}
+  '@oxlint/binding-win32-ia32-msvc@1.60.0':
+    resolution: {integrity: sha512-33YxL1sqwYNZXtn3MD/4dno6s0xeedXOJlT1WohkVD565WvohClZUr7vwKdAk954n4xiEWJkewiCr+zLeq7AeA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ia32]
     os: [win32]
 
-  '@oxlint/binding-win32-x64-msvc@1.59.0':
-    resolution: {integrity: sha512-xkE7puteDS/vUyRngLXW0t8WgdWoS/tfxXjhP/P7SMqPDx+hs44SpssO3h3qmTqECYEuXBUPzcAw5257Ka+ofA==}
+  '@oxlint/binding-win32-x64-msvc@1.60.0':
+    resolution: {integrity: sha512-JOro4ZcfBLamJCyfURQmOQByoorgOdx3ZjAkSqnb/CyG/i+lN3KoV5LAgk5ZAW6DPq7/Cx7n23f8DuTWXTWgyQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
@@ -2331,13 +2331,13 @@ packages:
   oxc-resolver@11.19.1:
     resolution: {integrity: sha512-qE/CIg/spwrTBFt5aKmwe3ifeDdLfA2NESN30E42X/lII5ClF8V7Wt6WIJhcGZjp0/Q+nQ+9vgxGk//xZNX2hg==}
 
-  oxfmt@0.44.0:
-    resolution: {integrity: sha512-lnncqvHewyRvaqdrnntVIrZV2tEddz8lbvPsQzG/zlkfvgZkwy0HP1p/2u1aCDToeg1jb9zBpbJdfkV73Itw+w==}
+  oxfmt@0.45.0:
+    resolution: {integrity: sha512-0o/COoN9fY50bjVeM7PQsNgbhndKurBIeTIcspW033OumksjJJmIVDKjAk5HMwU/GHTxSOdGDdhJ6BRzGPmsHg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
-  oxlint@1.59.0:
-    resolution: {integrity: sha512-0xBLeGGjP4vD9pygRo8iuOkOzEU1MqOnfiOl7KYezL/QvWL8NUg6n03zXc7ZVqltiOpUxBk2zgHI3PnRIEdAvw==}
+  oxlint@1.60.0:
+    resolution: {integrity: sha512-tnRzTWiWJ9pg3ftRWnD0+Oqh78L6ZSwcEudvCZaER0PIqiAnNyXj5N1dPwjmNpDalkKS9m/WMLN1CTPUBPmsgw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
@@ -3615,118 +3615,118 @@ snapshots:
   '@oxc-resolver/binding-win32-x64-msvc@11.19.1':
     optional: true
 
-  '@oxfmt/binding-android-arm-eabi@0.44.0':
+  '@oxfmt/binding-android-arm-eabi@0.45.0':
     optional: true
 
-  '@oxfmt/binding-android-arm64@0.44.0':
+  '@oxfmt/binding-android-arm64@0.45.0':
     optional: true
 
-  '@oxfmt/binding-darwin-arm64@0.44.0':
+  '@oxfmt/binding-darwin-arm64@0.45.0':
     optional: true
 
-  '@oxfmt/binding-darwin-x64@0.44.0':
+  '@oxfmt/binding-darwin-x64@0.45.0':
     optional: true
 
-  '@oxfmt/binding-freebsd-x64@0.44.0':
+  '@oxfmt/binding-freebsd-x64@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-arm-gnueabihf@0.44.0':
+  '@oxfmt/binding-linux-arm-gnueabihf@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-arm-musleabihf@0.44.0':
+  '@oxfmt/binding-linux-arm-musleabihf@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-arm64-gnu@0.44.0':
+  '@oxfmt/binding-linux-arm64-gnu@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-arm64-musl@0.44.0':
+  '@oxfmt/binding-linux-arm64-musl@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-ppc64-gnu@0.44.0':
+  '@oxfmt/binding-linux-ppc64-gnu@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-riscv64-gnu@0.44.0':
+  '@oxfmt/binding-linux-riscv64-gnu@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-riscv64-musl@0.44.0':
+  '@oxfmt/binding-linux-riscv64-musl@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-s390x-gnu@0.44.0':
+  '@oxfmt/binding-linux-s390x-gnu@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-x64-gnu@0.44.0':
+  '@oxfmt/binding-linux-x64-gnu@0.45.0':
     optional: true
 
-  '@oxfmt/binding-linux-x64-musl@0.44.0':
+  '@oxfmt/binding-linux-x64-musl@0.45.0':
     optional: true
 
-  '@oxfmt/binding-openharmony-arm64@0.44.0':
+  '@oxfmt/binding-openharmony-arm64@0.45.0':
     optional: true
 
-  '@oxfmt/binding-win32-arm64-msvc@0.44.0':
+  '@oxfmt/binding-win32-arm64-msvc@0.45.0':
     optional: true
 
-  '@oxfmt/binding-win32-ia32-msvc@0.44.0':
+  '@oxfmt/binding-win32-ia32-msvc@0.45.0':
     optional: true
 
-  '@oxfmt/binding-win32-x64-msvc@0.44.0':
+  '@oxfmt/binding-win32-x64-msvc@0.45.0':
     optional: true
 
-  '@oxlint/binding-android-arm-eabi@1.59.0':
+  '@oxlint/binding-android-arm-eabi@1.60.0':
     optional: true
 
-  '@oxlint/binding-android-arm64@1.59.0':
+  '@oxlint/binding-android-arm64@1.60.0':
     optional: true
 
-  '@oxlint/binding-darwin-arm64@1.59.0':
+  '@oxlint/binding-darwin-arm64@1.60.0':
     optional: true
 
-  '@oxlint/binding-darwin-x64@1.59.0':
+  '@oxlint/binding-darwin-x64@1.60.0':
     optional: true
 
-  '@oxlint/binding-freebsd-x64@1.59.0':
+  '@oxlint/binding-freebsd-x64@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-arm-gnueabihf@1.59.0':
+  '@oxlint/binding-linux-arm-gnueabihf@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-arm-musleabihf@1.59.0':
+  '@oxlint/binding-linux-arm-musleabihf@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-arm64-gnu@1.59.0':
+  '@oxlint/binding-linux-arm64-gnu@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-arm64-musl@1.59.0':
+  '@oxlint/binding-linux-arm64-musl@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-ppc64-gnu@1.59.0':
+  '@oxlint/binding-linux-ppc64-gnu@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-riscv64-gnu@1.59.0':
+  '@oxlint/binding-linux-riscv64-gnu@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-riscv64-musl@1.59.0':
+  '@oxlint/binding-linux-riscv64-musl@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-s390x-gnu@1.59.0':
+  '@oxlint/binding-linux-s390x-gnu@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-x64-gnu@1.59.0':
+  '@oxlint/binding-linux-x64-gnu@1.60.0':
     optional: true
 
-  '@oxlint/binding-linux-x64-musl@1.59.0':
+  '@oxlint/binding-linux-x64-musl@1.60.0':
     optional: true
 
-  '@oxlint/binding-openharmony-arm64@1.59.0':
+  '@oxlint/binding-openharmony-arm64@1.60.0':
     optional: true
 
-  '@oxlint/binding-win32-arm64-msvc@1.59.0':
+  '@oxlint/binding-win32-arm64-msvc@1.60.0':
     optional: true
 
-  '@oxlint/binding-win32-ia32-msvc@1.59.0':
+  '@oxlint/binding-win32-ia32-msvc@1.60.0':
     optional: true
 
-  '@oxlint/binding-win32-x64-msvc@1.59.0':
+  '@oxlint/binding-win32-x64-msvc@1.60.0':
     optional: true
 
   '@quansync/fs@1.0.0':
@@ -4314,10 +4314,6 @@ snapshots:
     dependencies:
       walk-up-path: 4.0.0
 
-  fdir@6.5.0(picomatch@4.0.3):
-    optionalDependencies:
-      picomatch: 4.0.3
-
   fdir@6.5.0(picomatch@4.0.4):
     optionalDependencies:
       picomatch: 4.0.4
@@ -4701,51 +4697,51 @@ snapshots:
       '@oxc-resolver/binding-win32-ia32-msvc': 11.19.1
       '@oxc-resolver/binding-win32-x64-msvc': 11.19.1
 
-  oxfmt@0.44.0:
+  oxfmt@0.45.0:
     dependencies:
       tinypool: 2.1.0
     optionalDependencies:
-      '@oxfmt/binding-android-arm-eabi': 0.44.0
-      '@oxfmt/binding-android-arm64': 0.44.0
-      '@oxfmt/binding-darwin-arm64': 0.44.0
-      '@oxfmt/binding-darwin-x64': 0.44.0
-      '@oxfmt/binding-freebsd-x64': 0.44.0
-      '@oxfmt/binding-linux-arm-gnueabihf': 0.44.0
-      '@oxfmt/binding-linux-arm-musleabihf': 0.44.0
-      '@oxfmt/binding-linux-arm64-gnu': 0.44.0
-      '@oxfmt/binding-linux-arm64-musl': 0.44.0
-      '@oxfmt/binding-linux-ppc64-gnu': 0.44.0
-      '@oxfmt/binding-linux-riscv64-gnu': 0.44.0
-      '@oxfmt/binding-linux-riscv64-musl': 0.44.0
-      '@oxfmt/binding-linux-s390x-gnu': 0.44.0
-      '@oxfmt/binding-linux-x64-gnu': 0.44.0
-      '@oxfmt/binding-linux-x64-musl': 0.44.0
-      '@oxfmt/binding-openharmony-arm64': 0.44.0
-      '@oxfmt/binding-win32-arm64-msvc': 0.44.0
-      '@oxfmt/binding-win32-ia32-msvc': 0.44.0
-      '@oxfmt/binding-win32-x64-msvc': 0.44.0
-
-  oxlint@1.59.0:
+      '@oxfmt/binding-android-arm-eabi': 0.45.0
+      '@oxfmt/binding-android-arm64': 0.45.0
+      '@oxfmt/binding-darwin-arm64': 0.45.0
+      '@oxfmt/binding-darwin-x64': 0.45.0
+      '@oxfmt/binding-freebsd-x64': 0.45.0
+      '@oxfmt/binding-linux-arm-gnueabihf': 0.45.0
+      '@oxfmt/binding-linux-arm-musleabihf': 0.45.0
+      '@oxfmt/binding-linux-arm64-gnu': 0.45.0
+      '@oxfmt/binding-linux-arm64-musl': 0.45.0
+      '@oxfmt/binding-linux-ppc64-gnu': 0.45.0
+      '@oxfmt/binding-linux-riscv64-gnu': 0.45.0
+      '@oxfmt/binding-linux-riscv64-musl': 0.45.0
+      '@oxfmt/binding-linux-s390x-gnu': 0.45.0
+      '@oxfmt/binding-linux-x64-gnu': 0.45.0
+      '@oxfmt/binding-linux-x64-musl': 0.45.0
+      '@oxfmt/binding-openharmony-arm64': 0.45.0
+      '@oxfmt/binding-win32-arm64-msvc': 0.45.0
+      '@oxfmt/binding-win32-ia32-msvc': 0.45.0
+      '@oxfmt/binding-win32-x64-msvc': 0.45.0
+
+  oxlint@1.60.0:
     optionalDependencies:
-      '@oxlint/binding-android-arm-eabi': 1.59.0
-      '@oxlint/binding-android-arm64': 1.59.0
-      '@oxlint/binding-darwin-arm64': 1.59.0
-      '@oxlint/binding-darwin-x64': 1.59.0
-      '@oxlint/binding-freebsd-x64': 1.59.0
-      '@oxlint/binding-linux-arm-gnueabihf': 1.59.0
-      '@oxlint/binding-linux-arm-musleabihf': 1.59.0
-      '@oxlint/binding-linux-arm64-gnu': 1.59.0
-      '@oxlint/binding-linux-arm64-musl': 1.59.0
-      '@oxlint/binding-linux-ppc64-gnu': 1.59.0
-      '@oxlint/binding-linux-riscv64-gnu': 1.59.0
-      '@oxlint/binding-linux-riscv64-musl': 1.59.0
-      '@oxlint/binding-linux-s390x-gnu': 1.59.0
-      '@oxlint/binding-linux-x64-gnu': 1.59.0
-      '@oxlint/binding-linux-x64-musl': 1.59.0
-      '@oxlint/binding-openharmony-arm64': 1.59.0
-      '@oxlint/binding-win32-arm64-msvc': 1.59.0
-      '@oxlint/binding-win32-ia32-msvc': 1.59.0
-      '@oxlint/binding-win32-x64-msvc': 1.59.0
+      '@oxlint/binding-android-arm-eabi': 1.60.0
+      '@oxlint/binding-android-arm64': 1.60.0
+      '@oxlint/binding-darwin-arm64': 1.60.0
+      '@oxlint/binding-darwin-x64': 1.60.0
+      '@oxlint/binding-freebsd-x64': 1.60.0
+      '@oxlint/binding-linux-arm-gnueabihf': 1.60.0
+      '@oxlint/binding-linux-arm-musleabihf': 1.60.0
+      '@oxlint/binding-linux-arm64-gnu': 1.60.0
+      '@oxlint/binding-linux-arm64-musl': 1.60.0
+      '@oxlint/binding-linux-ppc64-gnu': 1.60.0
+      '@oxlint/binding-linux-riscv64-gnu': 1.60.0
+      '@oxlint/binding-linux-riscv64-musl': 1.60.0
+      '@oxlint/binding-linux-s390x-gnu': 1.60.0
+      '@oxlint/binding-linux-x64-gnu': 1.60.0
+      '@oxlint/binding-linux-x64-musl': 1.60.0
+      '@oxlint/binding-openharmony-arm64': 1.60.0
+      '@oxlint/binding-win32-arm64-msvc': 1.60.0
+      '@oxlint/binding-win32-ia32-msvc': 1.60.0
+      '@oxlint/binding-win32-x64-msvc': 1.60.0
 
   p-filter@2.1.0:
     dependencies:
@@ -5180,8 +5176,8 @@ snapshots:
   vite@7.3.1(@types/node@20.19.33)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.3):
     dependencies:
       esbuild: 0.27.3
-      fdir: 6.5.0(picomatch@4.0.3)
-      picomatch: 4.0.3
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
       postcss: 8.5.6
       rollup: 4.57.1
       tinyglobby: 0.2.15