diff --git a/.changeset/add-span-conversion-helper-in-subpath.md b/.changeset/add-span-conversion-helper-in-subpath.md
new file mode 100644
index 000000000000..6c8461e5a782
--- /dev/null
+++ b/.changeset/add-span-conversion-helper-in-subpath.md
@@ -0,0 +1,18 @@
+---
+"@biomejs/js-api": minor
+---
+
+Added `spanInBytesToSpanInCodeUnits` helper function in subpath exports of `@biomejs/js-api`.
+
+```js
+import { spanInBytesToSpanInCodeUnits } from "@biomejs/js-api/nodejs";
+// Or:
+// import { spanInBytesToSpanInCodeUnits } from "@biomejs/js-api/bundler";
+// import { spanInBytesToSpanInCodeUnits } from "@biomejs/js-api/web";
+
+const [start, end] = spanInBytesToSpanInCodeUnits(
+    diagnostic.location.span,
+    content
+);
+const text = content.slice(start, end); // Correctly extracts the text
+```
diff --git a/.changeset/chatty-meals-train.md b/.changeset/chatty-meals-train.md
new file mode 100644
index 000000000000..6af34c86b4e8
--- /dev/null
+++ b/.changeset/chatty-meals-train.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": minor
+---
+
+`biome rage` now shows the resolved `files.includes` and `files.ignoreUnknown` configuration.
diff --git a/.changeset/cold-snakes-smile.md b/.changeset/cold-snakes-smile.md
new file mode 100644
index 000000000000..dfd084eed8fc
--- /dev/null
+++ b/.changeset/cold-snakes-smile.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": minor
+---
+
+Added support for [`useSortedClasses`](https://biomejs.dev/linter/rules/use-sorted-classes/) rule in HTML-ish files.
diff --git a/.changeset/eight-lamps-follow.md b/.changeset/eight-lamps-follow.md
new file mode 100644
index 000000000000..4511b97a8475
--- /dev/null
+++ b/.changeset/eight-lamps-follow.md
@@ -0,0 +1,19 @@
+---
+"@biomejs/biome": minor
+---
+
+Adds a new `resolutionKind` option for object-syntax plugin entries.
+
+This allows shared Biome configs in monorepos to load local Grit plugins from the package that declares them instead of resolving plugin paths from the consuming project.
+
+```json
+{
+  "plugins": [
+    { "path": "./grit/no-debugger.grit", "resolutionKind": "config" },
+    { "path": "local-plugin.grit", "resolutionKind": "project" },
+    { "path": "local-plugin.grit" }
+  ]
+}
+```
+
+Use `resolutionKind: "config"` to resolve the plugin from the configuration file that declares it. Use `resolutionKind: "project"` to resolve the plugin from the consuming project. When omitted, `resolutionKind` defaults to `project`. This only affects plugin resolution; `includes` still apply to end-user project files as usual.
diff --git a/.changeset/fix-css-commented-function-arguments.md b/.changeset/fix-css-commented-function-arguments.md
new file mode 100644
index 000000000000..2c6fb51f346c
--- /dev/null
+++ b/.changeset/fix-css-commented-function-arguments.md
@@ -0,0 +1,21 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed CSS formatting for multiline function arguments preceded by comments:
+
+```diff
+ .example {
+   value: outer(
+     1,
+     /* comment */
+     nested(
+-      first,
+-      second
+-    )
++        first,
++        second
++      )
+   );
+ }
+```
diff --git a/.changeset/fix-nested-destructured-arrow-ternary.md b/.changeset/fix-nested-destructured-arrow-ternary.md
new file mode 100644
index 000000000000..56e6f0087469
--- /dev/null
+++ b/.changeset/fix-nested-destructured-arrow-ternary.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#10131](https://github.com/biomejs/biome/issues/10131): Biome now correctly parses curried arrow functions in ternary consequents when the inner arrow's parameters use a destructuring pattern, e.g. `cond ? (x) => ({ a, b }) => body : alt`.
diff --git a/.changeset/fix-reindent-verbatim-regions.md b/.changeset/fix-reindent-verbatim-regions.md
new file mode 100644
index 000000000000..e07f25c52463
--- /dev/null
+++ b/.changeset/fix-reindent-verbatim-regions.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#10515](https://github.com/biomejs/biome/issues/10515): `biome check --write` was not idempotent on Svelte files — multi-line template literals in `<script>` blocks and block comments in `<style>` blocks gained an extra indent level on every run.
diff --git a/.changeset/gentle-rocks-teach.md b/.changeset/gentle-rocks-teach.md
new file mode 100644
index 000000000000..2c0c70097b57
--- /dev/null
+++ b/.changeset/gentle-rocks-teach.md
@@ -0,0 +1,39 @@
+---
+"@biomejs/biome": minor
+---
+
+Added the new CLI option `--profile-type-inference` to the commands `lint` and `check`.
+
+The profiler is designed to track the execution time of internal queries and operations, group them by file, and sort them from the most expensive to the least expensive.
+
+```shell
+biome lint --profile-type-inference
+```
+
+```text
+profiler ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Type inference profile (Biome <version>)
+
+  src/index.ts
+
+    Requests (top 5 of 12 groups; 28 source records; 46 executions)
+      1. Promise classification <- nursery/noFloatingPromises
+      ...
+
+    Queries (top 8 of 25 groups; 61 source records; 94 executions)
+      1. Promises / infer_expression_is_promise
+      ...
+
+    Whole-module inference (top 1 of 1 group; 1 source record; 1 execution)
+      1. Import depth limit
+      ...
+
+  68 files omitted.
+
+  ℹ To show all the information, use the --verbose option. The output might be very verbose, so it's advised to analyze a single file.
+
+  $ biome lint --profile-type-inference --verbose ./path/to/file.ts
+```
+
+Use `--verbose` to include detailed timings, attribution, breadth, and implementation references for the top source records in each file.
diff --git a/.changeset/light-carrots-throw.md b/.changeset/light-carrots-throw.md
new file mode 100644
index 000000000000..c35d4731a705
--- /dev/null
+++ b/.changeset/light-carrots-throw.md
@@ -0,0 +1,15 @@
+---
+"@biomejs/biome": patch
+---
+
+Improved the accuracy of type-aware lint rules by resolving more inferred types. For example, [`noFloatingPromises`](https://biomejs.dev/linter/rules/no-floating-promises/) now detects floating Promises returned by aliased callbacks and arrays of Promises created by async mapping callbacks.
+
+The following statements are now reported:
+
+```ts
+type AsyncCallback = () => Promise<void>;
+declare const callback: AsyncCallback;
+callback();
+
+[1, 2, 3].map(async value => value);
+```
diff --git a/.changeset/parse-mixed-case-html-doctype.md b/.changeset/parse-mixed-case-html-doctype.md
new file mode 100644
index 000000000000..ae62ab7b7a59
--- /dev/null
+++ b/.changeset/parse-mixed-case-html-doctype.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+The HTML parser now accepts mixed-case `doctype` declarations.
diff --git a/.changeset/rotten-bars-shout.md b/.changeset/rotten-bars-shout.md
new file mode 100644
index 000000000000..d2156507934e
--- /dev/null
+++ b/.changeset/rotten-bars-shout.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed a performance regression in type-aware JavaScript lint rules by inferring only requested types and memoizing export resolution.
diff --git a/.changeset/sharp-emus-raise.md b/.changeset/sharp-emus-raise.md
new file mode 100644
index 000000000000..4ae4138b0fda
--- /dev/null
+++ b/.changeset/sharp-emus-raise.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Added support for Svelte declaration tags using `let` and `const`. Biome can now parse, format, and lint bindings declared in these tags.
diff --git a/.changeset/support-htm-files.md b/.changeset/support-htm-files.md
new file mode 100644
index 000000000000..984bac3e0b83
--- /dev/null
+++ b/.changeset/support-htm-files.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": minor
+---
+
+Biome now recognizes files with the `.htm` extension as HTML.
diff --git a/.changeset/swift-suns-smell.md b/.changeset/swift-suns-smell.md
new file mode 100644
index 000000000000..451a709afaaa
--- /dev/null
+++ b/.changeset/swift-suns-smell.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Improved the performance of Biome formatter up to ~7% across the board.
diff --git a/.changeset/thick-coins-hide.md b/.changeset/thick-coins-hide.md
new file mode 100644
index 000000000000..6a03e7807e99
--- /dev/null
+++ b/.changeset/thick-coins-hide.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Added the nursery rule [`noJsRestrictedProperties`](https://biomejs.dev/linter/rules/no-js-restricted-properties/), which ports ESLint's `no-restricted-properties` rule. Biome now flags restricted member access and object destructuring, and `biome migrate eslint` preserves the rule's options.
diff --git a/.changeset/use-sorted-attributes-sort-first.md b/.changeset/use-sorted-attributes-sort-first.md
new file mode 100644
index 000000000000..d79ba1a91f38
--- /dev/null
+++ b/.changeset/use-sorted-attributes-sort-first.md
@@ -0,0 +1,32 @@
+---
+"@biomejs/biome": minor
+---
+
+Added the `sortFirst` option to the [useSortedAttributes](https://biomejs.dev/assist/actions/use-sorted-attributes/) action (JSX and HTML). It takes a list of attribute names that are sorted before all other attributes, in the order given, while the remaining attributes keep their usual sort. This is useful to keep attributes such as `key` first.
+
+With the following configuration:
+
+```json
+{
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedAttributes": {
+          "level": "on",
+          "options": { "sortFirst": ["key"] }
+        }
+      }
+    }
+  }
+}
+```
+
+The attributes are reordered so that `key` comes first:
+
+```jsx
+// Before
+<div className={styles.investment} key={investment.id} />;
+
+// After
+<div key={investment.id} className={styles.investment} />;
+```
diff --git a/.changeset/use-sorted-interface-members-partition-by-new-line.md b/.changeset/use-sorted-interface-members-partition-by-new-line.md
new file mode 100644
index 000000000000..4c1b51c71bc0
--- /dev/null
+++ b/.changeset/use-sorted-interface-members-partition-by-new-line.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": minor
+---
+
+Added the `partitionByNewLine` option to the `useSortedInterfaceMembers` assist. When enabled, members separated by a blank line are kept in their own section and sorted only within that section, preserving the logical groupings the author intentionally introduced with empty lines.
diff --git a/Cargo.lock b/Cargo.lock
index d1af253b24b0..a60cf0cbf3c3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -127,6 +127,7 @@ dependencies = [
  "biome_string_case",
  "biome_suppression",
  "biome_text_edit",
+ "bitvec",
  "camino",
  "either",
  "enumflags2",
@@ -271,6 +272,7 @@ dependencies = [
  "biome_resolver",
  "biome_rowan",
  "biome_rule_options",
+ "biome_string_case",
  "biome_yaml_syntax",
  "bpaf",
  "camino",
@@ -1034,7 +1036,6 @@ dependencies = [
  "biome_tailwind_syntax",
  "biome_test_utils",
  "biome_unicode_table",
- "bitvec",
  "camino",
  "codspeed-criterion-compat",
  "either",
@@ -2451,9 +2452,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.4.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9066c49992464636f92905fa096ec58baaa4d57ec19a5c096c68d3e25ef3d136"
+checksum = "5add81bb678e6cb321aff7fa0dc7689ad82b112dbc032cea19f91d6b8e3582b9"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -3169,9 +3170,9 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.10"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b73573e6edcd2af0cdf47bd6cb58f0b3839491263c314eaad1ccf24430e1de"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "fixedbitset"
@@ -4284,12 +4285,11 @@ dependencies = [
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.44"
+version = "0.1.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
+checksum = "2d1eacfa31c33ec25e873c136ba5669f00f9866d0688bea7be4d3f7e43067df6"
 dependencies = [
  "cc",
- "libc",
 ]
 
 [[package]]
diff --git a/crates/biome_analyze/Cargo.toml b/crates/biome_analyze/Cargo.toml
index d76c74200c6f..fea64b25855b 100644
--- a/crates/biome_analyze/Cargo.toml
+++ b/crates/biome_analyze/Cargo.toml
@@ -25,6 +25,7 @@ biome_rowan              = { workspace = true }
 biome_string_case        = { workspace = true }
 biome_suppression        = { workspace = true }
 biome_text_edit          = { workspace = true }
+bitvec                   = "1.0.1"
 camino                   = { workspace = true }
 either                   = { workspace = true }
 enumflags2               = { workspace = true }
diff --git a/crates/biome_analyze/src/options.rs b/crates/biome_analyze/src/options.rs
index 4869d3b97178..552d4209286d 100644
--- a/crates/biome_analyze/src/options.rs
+++ b/crates/biome_analyze/src/options.rs
@@ -83,6 +83,9 @@ pub struct AnalyzerConfiguration {
     /// The JSX fragment factory function identifier (e.g., "Fragment")
     /// Only applies when jsx_runtime is ReactClassic.
     jsx_fragment_factory: Option<Box<str>>,
+
+    /// Configures which attributes and functions contain Tailwind classes.
+    tailwind: TailwindOptions,
 }
 
 impl AnalyzerConfiguration {
@@ -130,6 +133,11 @@ impl AnalyzerConfiguration {
         self.preferred_indentation = preferred_indentation;
         self
     }
+
+    pub fn with_tailwind(mut self, tailwind: TailwindOptions) -> Self {
+        self.tailwind = tailwind;
+        self
+    }
 }
 
 /// A set of information useful to the analyzer infrastructure
@@ -231,6 +239,43 @@ impl AnalyzerOptions {
     pub fn preferred_indentation(&self) -> PreferredIndentation {
         self.configuration.preferred_indentation
     }
+
+    pub fn tailwind(&self) -> &TailwindOptions {
+        &self.configuration.tailwind
+    }
+}
+
+/// User-provided names that Tailwind-aware analyzer queries use to identify class strings.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct TailwindOptions {
+    attributes: Option<Arc<[Box<str>]>>,
+    functions: Option<Arc<[Box<str>]>>,
+}
+
+impl TailwindOptions {
+    /// Creates analyzer options from optional replacement lists.
+    pub fn new(attributes: Option<Box<[Box<str>]>>, functions: Option<Box<[Box<str>]>>) -> Self {
+        Self {
+            attributes: attributes.map(Arc::from),
+            functions: functions.map(Arc::from),
+        }
+    }
+
+    /// Returns the configured attribute replacement list, or `None` when language defaults apply.
+    pub fn attributes(&self) -> Option<&[Box<str>]> {
+        self.attributes.as_deref()
+    }
+
+    /// Returns the configured function replacement list, or `None` when defaults apply.
+    pub fn functions(&self) -> Option<&[Box<str>]> {
+        self.functions.as_deref()
+    }
+}
+
+impl Default for TailwindOptions {
+    fn default() -> Self {
+        Self::new(None, None)
+    }
 }
 
 #[derive(Clone, Copy, Debug, Default)]
diff --git a/crates/biome_analyze/src/shared/mod.rs b/crates/biome_analyze/src/shared/mod.rs
index cf28c81f1cd3..0f5af282a846 100644
--- a/crates/biome_analyze/src/shared/mod.rs
+++ b/crates/biome_analyze/src/shared/mod.rs
@@ -1,2 +1,3 @@
 pub mod class_dedup;
 pub mod sort_attributes;
+pub mod sorted_classes;
diff --git a/crates/biome_analyze/src/shared/sort_attributes.rs b/crates/biome_analyze/src/shared/sort_attributes.rs
index 461b298a18e3..90ec95f033e7 100644
--- a/crates/biome_analyze/src/shared/sort_attributes.rs
+++ b/crates/biome_analyze/src/shared/sort_attributes.rs
@@ -38,6 +38,31 @@ pub trait SortableAttribute {
             (None, None) => Ordering::Equal,
         }
     }
+
+    fn sort_first_index(&self, sort_first: &[Box<str>]) -> usize {
+        self.name()
+            .and_then(|name| {
+                sort_first
+                    .iter()
+                    .position(|listed| listed.as_ref() == name.text_trimmed())
+            })
+            .unwrap_or(sort_first.len())
+    }
+
+    fn cmp_sort_first(
+        &self,
+        other: &Self,
+        sort_first: &[Box<str>],
+        base: impl Fn(&Self, &Self) -> Ordering,
+    ) -> Ordering {
+        if sort_first.is_empty() {
+            return base(self, other);
+        }
+
+        self.sort_first_index(sort_first)
+            .cmp(&other.sort_first_index(sort_first))
+            .then_with(|| base(self, other))
+    }
 }
 
 #[derive(Clone)]
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_info.rs b/crates/biome_analyze/src/shared/sorted_classes/class_info.rs
similarity index 98%
rename from crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_info.rs
rename to crates/biome_analyze/src/shared/sorted_classes/class_info.rs
index 5817025229ba..ef3941c9a0aa 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_info.rs
+++ b/crates/biome_analyze/src/shared/sorted_classes/class_info.rs
@@ -17,9 +17,8 @@ use bitvec::{order::Lsb0, vec::BitVec};
 
 use super::{
     class_lexer::{ClassSegmentStructure, tokenize_class},
-    sort_config::{SortConfig, VariantsConfig, build_variant_weight},
+    sort_config::{SortConfig, UtilityLayer, VariantsConfig, build_variant_weight},
 };
-use crate::lint::nursery::use_sorted_classes::sort_config::UtilityLayer;
 
 // utilities
 // ---------
@@ -232,7 +231,7 @@ fn get_utility_info(
 #[cfg(test)]
 mod get_utility_info_tests {
     use super::*;
-    use crate::lint::nursery::use_sorted_classes::sort_config::UtilityLayer;
+    use crate::shared::sorted_classes::sort_config::UtilityLayer;
 
     #[test]
     fn test_exact_match() {
@@ -412,7 +411,7 @@ impl From<(&str, &str)> for VariantMatch {
 
 #[cfg(test)]
 mod variant_match_tests {
-    use crate::lint::nursery::use_sorted_classes::class_info::VariantMatch;
+    use super::VariantMatch;
 
     #[test]
     fn test_exact_match() {
@@ -597,9 +596,7 @@ mod get_class_info_tests {
     use bitvec::bitvec;
 
     use super::*;
-    use crate::lint::nursery::use_sorted_classes::{
-        presets::ConfigPreset, sort_config::UtilityLayer,
-    };
+    use crate::shared::sorted_classes::{presets::ConfigPreset, sort_config::UtilityLayer};
 
     #[test]
     fn test_get_class_info() {
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_lexer.rs b/crates/biome_analyze/src/shared/sorted_classes/class_lexer.rs
similarity index 99%
rename from crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_lexer.rs
rename to crates/biome_analyze/src/shared/sorted_classes/class_lexer.rs
index aa5c1a70c9bc..9c04431d2060 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/class_lexer.rs
+++ b/crates/biome_analyze/src/shared/sorted_classes/class_lexer.rs
@@ -159,10 +159,9 @@ pub fn tokenize_class(class_name: &str) -> Option<ClassStructure> {
                     return None;
                 }
             }
-            b':'
-                if arbitrary_block_depth == 0 => {
-                    delimiter_indexes.push(index);
-                }
+            b':' if arbitrary_block_depth == 0 => {
+                delimiter_indexes.push(index);
+            }
             _ => {}
         };
         if at_arbitrary_block_start && !is_start_of_arbitrary_block {
diff --git a/crates/biome_analyze/src/shared/sorted_classes/mod.rs b/crates/biome_analyze/src/shared/sorted_classes/mod.rs
new file mode 100644
index 000000000000..18d894281ec6
--- /dev/null
+++ b/crates/biome_analyze/src/shared/sorted_classes/mod.rs
@@ -0,0 +1,8 @@
+mod class_info;
+mod class_lexer;
+mod presets;
+pub mod sort;
+pub mod sort_config;
+mod tailwind_preset;
+
+pub use class_lexer::tokenize_class;
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/presets.rs b/crates/biome_analyze/src/shared/sorted_classes/presets.rs
similarity index 78%
rename from crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/presets.rs
rename to crates/biome_analyze/src/shared/sorted_classes/presets.rs
index 9582778df3b8..60daa5d2a9df 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/presets.rs
+++ b/crates/biome_analyze/src/shared/sorted_classes/presets.rs
@@ -8,8 +8,6 @@ use super::{
 
 #[derive(Default)]
 pub enum UseSortedClassesPreset {
-    #[expect(unused)]
-    None,
     #[default]
     TailwindCSS,
 }
@@ -21,18 +19,10 @@ pub struct ConfigPreset {
 
 pub fn get_config_preset(preset: &UseSortedClassesPreset) -> ConfigPreset {
     match preset {
-        UseSortedClassesPreset::None => get_empty_preset(),
         UseSortedClassesPreset::TailwindCSS => get_tailwind_css_preset(),
     }
 }
 
-pub fn get_empty_preset() -> ConfigPreset {
-    ConfigPreset {
-        utilities: [].as_slice(),
-        variants: [].as_slice(),
-    }
-}
-
 pub fn get_tailwind_css_preset() -> ConfigPreset {
     ConfigPreset {
         utilities: TAILWIND_LAYERS.as_slice(),
diff --git a/crates/biome_analyze/src/shared/sorted_classes/sort.rs b/crates/biome_analyze/src/shared/sorted_classes/sort.rs
new file mode 100644
index 000000000000..c73c09d07c6c
--- /dev/null
+++ b/crates/biome_analyze/src/shared/sorted_classes/sort.rs
@@ -0,0 +1,145 @@
+use biome_rowan::TokenText;
+use std::cmp::Ordering;
+
+use super::{
+    class_info::{ClassInfo, get_class_info},
+    sort_config::SortConfig,
+};
+
+impl ClassInfo {
+    /// Compare based on the existence of variants. Classes with variants go last.
+    /// Returns `None` if both or none of the classes has variants.
+    fn cmp_variants_weight_existence(&self, other: &Self) -> Option<Ordering> {
+        match (&self.variant_weight, &other.variant_weight) {
+            (Some(_), Some(_)) => None,
+            (Some(_), _) => Some(Ordering::Greater),
+            (_, Some(_)) => Some(Ordering::Less),
+            (None, None) => None,
+        }
+    }
+
+    /// Compare based on layer indexes. Classes with lower indexes go first.
+    /// Returns `None` if the indexes are equal.
+    fn cmp_layers(&self, other: &Self) -> Option<Ordering> {
+        let result = self.layer_index.cmp(&other.layer_index);
+        if result != Ordering::Equal {
+            return Some(result);
+        }
+        None
+    }
+
+    /// Compare based on variants weight. Classes with lower weight go first.
+    /// First compare variants weight length. Only if their equal compare their actual weight.
+    /// Returns `None` if they have the same weight.
+    fn cmp_variants_weight(&self, other: &Self) -> Option<Ordering> {
+        let current_weight = self.variant_weight.as_ref()?;
+        let other_weight = other.variant_weight.as_ref()?;
+
+        let mut result = current_weight.len().cmp(&other_weight.len());
+        if result == Ordering::Equal {
+            result = current_weight.cmp(other_weight);
+        }
+
+        if result != Ordering::Equal {
+            return Some(result);
+        }
+        None
+    }
+
+    /// Compare based on the existence of arbitrary variants. Classes with arbitrary variants go last.
+    /// Returns `None` if both or none of the classes has arbitrary variants.
+    fn cmp_arbitrary_variants_existence(&self, other: &Self) -> Option<Ordering> {
+        match (&self.arbitrary_variants, &other.arbitrary_variants) {
+            (Some(_), Some(_)) => None,
+            (Some(_), _) => Some(Ordering::Greater),
+            (_, Some(_)) => Some(Ordering::Less),
+            (None, None) => None,
+        }
+    }
+
+    /// Compare arbitrary variants based on their length and then lexicographically
+    fn cmp_arbitrary_variants(&self, other: &Self) -> Option<Ordering> {
+        let a = self.arbitrary_variants.as_ref()?;
+        let b = other.arbitrary_variants.as_ref()?;
+
+        let mut result = a.len().cmp(&b.len());
+        if result == Ordering::Equal {
+            result = a.cmp(b);
+        }
+
+        if result != Ordering::Equal {
+            return Some(result);
+        }
+        None
+    }
+
+    /// Compare based on utility index. Classes with lower indexes go first.
+    /// Returns `None` if the indexes are equal.
+    fn cmp_utilities(&self, other: &Self) -> Option<Ordering> {
+        let result = self.utility_index.cmp(&other.utility_index);
+        if result != Ordering::Equal {
+            return Some(result);
+        }
+        None
+    }
+}
+
+fn compare_classes(a: &ClassInfo, b: &ClassInfo) -> Ordering {
+    if let Some(has_arbitrary_variants) = a.cmp_arbitrary_variants_existence(b) {
+        return has_arbitrary_variants;
+    }
+
+    if let Some(arbitrary_variants_order) = a.cmp_arbitrary_variants(b) {
+        return arbitrary_variants_order;
+    }
+
+    if let Some(has_variants_order) = a.cmp_variants_weight_existence(b) {
+        return has_variants_order;
+    }
+
+    if let Some(layers_order) = a.cmp_layers(b) {
+        return layers_order;
+    }
+
+    if let Some(variants_weight_order) = a.cmp_variants_weight(b) {
+        return variants_weight_order;
+    }
+
+    if let Some(utilities_order) = a.cmp_utilities(b) {
+        return utilities_order;
+    }
+
+    Ordering::Equal
+}
+
+/// Sort a slice of class strings according to the given sort config.
+pub fn sort_class_name_from_slice(classes: &[&str], sort_config: &SortConfig) -> String {
+    let mut sorted_classes = Vec::new();
+    let mut classes_info = Vec::new();
+    for class in classes {
+        match get_class_info(class, sort_config) {
+            Some(class_info) => {
+                classes_info.push(class_info);
+            }
+            None => {
+                sorted_classes.push(*class);
+            }
+        }
+    }
+
+    classes_info.sort_unstable_by(|a, b| compare_classes(a, b).then_with(|| a.text.cmp(&b.text)));
+
+    sorted_classes.extend(
+        classes_info
+            .iter()
+            .map(|class_info| class_info.text.as_ref()),
+    );
+
+    sorted_classes.join(" ")
+}
+
+/// Sort the given class string according to the given sort config.
+pub fn sort_class_name(class_name: &TokenText, sort_config: &SortConfig) -> String {
+    let classes: Vec<&str> = class_name.split_whitespace().collect();
+    sort_class_name_from_slice(&classes, sort_config)
+}
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort_config.rs b/crates/biome_analyze/src/shared/sorted_classes/sort_config.rs
similarity index 83%
rename from crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort_config.rs
rename to crates/biome_analyze/src/shared/sorted_classes/sort_config.rs
index 8c92ede308e0..78e142960ef6 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort_config.rs
+++ b/crates/biome_analyze/src/shared/sorted_classes/sort_config.rs
@@ -6,10 +6,11 @@
 //! - Other options, such as prefix and separator.
 
 use std::collections::HashMap;
+use std::sync::LazyLock;
 
 use bitvec::{order::Lsb0, vec::BitVec};
 
-use super::presets::ConfigPreset;
+use super::presets::{ConfigPreset, UseSortedClassesPreset, get_config_preset};
 
 /// A utility layer, containing its name and an ordered list of classes.
 pub struct UtilityLayer {
@@ -40,7 +41,7 @@ pub struct SortConfig {
 
 impl SortConfig {
     /// Creates a new sort config.
-    pub fn new(preset: &ConfigPreset) -> Self {
+    pub(crate) fn new(preset: &ConfigPreset) -> Self {
         // Compute the layer index map.
         let mut layer_index_map: HashMap<&'static str, usize> = HashMap::new();
         let mut index = 0;
@@ -57,3 +58,7 @@ impl SortConfig {
         }
     }
 }
+
+/// The default sort config, using the Tailwind CSS preset.
+pub static DEFAULT_SORT_CONFIG: LazyLock<SortConfig> =
+    LazyLock::new(|| SortConfig::new(&get_config_preset(&UseSortedClassesPreset::default())));
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/tailwind_preset.rs b/crates/biome_analyze/src/shared/sorted_classes/tailwind_preset.rs
similarity index 99%
rename from crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/tailwind_preset.rs
rename to crates/biome_analyze/src/shared/sorted_classes/tailwind_preset.rs
index 61fc9d808a04..9c9626c99bf2 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/tailwind_preset.rs
+++ b/crates/biome_analyze/src/shared/sorted_classes/tailwind_preset.rs
@@ -1,5 +1,5 @@
 //! DO NOT EDIT MANUALLY - this file is autogenerated from the default Tailwind CSS config.
-//! To update, run `pnpm gen:tailwind-preset` from `packages/@biomejs/tailwindcss-config-analyzer`.
+//! To update, run `just gen-tw` from the repository root.
 
 use super::sort_config::UtilityLayer;
 
diff --git a/crates/biome_cli/src/commands/mod.rs b/crates/biome_cli/src/commands/mod.rs
index d6efa027a446..47a5c5e91f83 100644
--- a/crates/biome_cli/src/commands/mod.rs
+++ b/crates/biome_cli/src/commands/mod.rs
@@ -166,8 +166,8 @@ pub enum BiomeCommand {
         #[bpaf(long("profile-rules"), switch)]
         profile_rules: bool,
 
-        /// Enables type inference profiling output.
-        #[bpaf(long("profile-type-inference"), switch, hide, hide_usage)]
+        /// Enables type-inference profiling output, grouped and ranked by source file.
+        #[bpaf(long("profile-type-inference"), switch, hide_usage)]
         profile_type_inference: bool,
 
         /// Reads code from standard input and writes the processed code to standard output.
@@ -341,8 +341,8 @@ pub enum BiomeCommand {
         #[bpaf(long("profile-rules"), switch)]
         profile_rules: bool,
 
-        /// Capture type-inference request and query timings.
-        #[bpaf(long("profile-type-inference"), switch, hide, hide_usage)]
+        /// Enables type-inference profiling output, grouped and ranked by source file.
+        #[bpaf(long("profile-type-inference"), switch, hide_usage)]
         profile_type_inference: bool,
 
         /// After the initial run, watches the selected paths and reprocesses files modified afterward.
@@ -1055,26 +1055,6 @@ mod tests {
         );
     }
 
-    /// Tests that all CLI options adhere to the invariants expected by `bpaf`.
-    #[test]
-    fn type_inference_profile_forces_in_process_validation() {
-        use bpaf::Args;
-
-        for command_name in ["lint", "check"] {
-            let command = biome_command()
-                .run_inner(Args::from(
-                    [command_name, "--profile-type-inference", "--use-server"].as_slice(),
-                ))
-                .expect("profile options must parse");
-            assert!(!command.should_use_server());
-            assert!(
-                command
-                    .cli_options()
-                    .is_some_and(|options| options.use_server)
-            );
-        }
-    }
-
     #[test]
     fn check_options() {
         biome_command().check_invariants(false);
diff --git a/crates/biome_cli/src/commands/rage.rs b/crates/biome_cli/src/commands/rage.rs
index 7b43fbcba2a6..8692c345f910 100644
--- a/crates/biome_cli/src/commands/rage.rs
+++ b/crates/biome_cli/src/commands/rage.rs
@@ -391,6 +391,19 @@ impl Display for RageConfiguration<'_> {
                             {RageConfigurationLintRules("Enabled rules", enabled_rules)}
                         ).fmt(fmt)?;
                     }
+
+                    let files_configuration = configuration.get_files_configuration();
+                    let includes = files_configuration.includes.as_ref().map(|list| {
+                        list.iter()
+                            .map(|glob| glob.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    });
+                    markup! (
+                            {Section("Files")}
+                            {KeyValuePair::new("Ignore Unknown", markup!({DisplayOption(files_configuration.ignore_unknown)}))}
+                            {KeyValuePair::new("Includes", markup!({DisplayOption(includes)}))}
+                        ).fmt(fmt)?;
                 }
             }
             Err(err) => markup! (
diff --git a/crates/biome_cli/src/reporter/profilers.rs b/crates/biome_cli/src/reporter/profilers.rs
index b1b9583995a0..aad095a70686 100644
--- a/crates/biome_cli/src/reporter/profilers.rs
+++ b/crates/biome_cli/src/reporter/profilers.rs
@@ -6,8 +6,9 @@
 use std::io;
 
 use biome_analyze::profiling::DisplayProfiles;
-use biome_console::markup;
-use biome_module_graph::type_inference::profiling::DisplayTypeInferenceProfile;
+use biome_console::{HARD_LINE, markup};
+use biome_diagnostics::PrintDiagnostic;
+use biome_module_graph::type_inference::profiling::TypeInferenceProfileDiagnostic;
 use camino::{Utf8Path, Utf8PathBuf};
 
 use crate::VERSION;
@@ -73,13 +74,13 @@ impl ReporterVisitor for ProfilersReporterVisitor {
         if self.type_profiler
             && let Some(profile) = execution.take_type_inference_profile()
         {
-            let display = DisplayTypeInferenceProfile::new(
+            let diagnostic = TypeInferenceProfileDiagnostic::new(
                 &profile,
                 self.working_directory.as_deref(),
                 VERSION,
             )
             .with_verbose(verbose);
-            writer.log(markup! {{ display }});
+            writer.log(markup! {{ HARD_LINE }{ PrintDiagnostic::simple(&diagnostic) }});
         }
 
         Ok(())
diff --git a/crates/biome_cli/tests/cases/config_extends.rs b/crates/biome_cli/tests/cases/config_extends.rs
index 26d053b1f56b..6bd719bf7471 100644
--- a/crates/biome_cli/tests/cases/config_extends.rs
+++ b/crates/biome_cli/tests/cases/config_extends.rs
@@ -228,6 +228,54 @@ fn extends_config_ok_from_npm_package_with_condition_names() {
     ));
 }
 
+#[test]
+fn extends_config_with_object_syntax_plugin_from_npm_package() {
+    let mut fs = TemporaryFs::new("extends_config_with_object_syntax_plugin_from_npm_package");
+
+    fs.create_file("biome.json", r#"{ "extends": ["@shared/config/biome"] }"#);
+
+    fs.create_file(
+        "node_modules/@shared/config/biome.jsonc",
+        r#"{ "root": false, "plugins": [{ "path": "./grit/no-object-assign.grit", "resolutionKind": "config" }], "linter": { "enabled": true } }"#,
+    );
+    fs.create_file(
+        "node_modules/@shared/config/package.json",
+        r#"{
+    "name": "@shared/config",
+    "exports": {
+        "./biome": "./biome.jsonc"
+    }
+}"#,
+    );
+    fs.create_file(
+        "node_modules/@shared/config/grit/no-object-assign.grit",
+        r#"`$fn($args)` where {
+    $fn <: `Object.assign`,
+    register_diagnostic(
+        span = $fn,
+        message = "Prefer object spread instead of Object.assign()",
+        severity = "warn"
+    )
+}"#,
+    );
+    fs.create_file("test.js", "const merged = Object.assign({}, a, b);\n");
+
+    let mut console = BufferConsole::default();
+    let result = run_cli_with_dyn_fs(
+        Box::new(fs.create_os()),
+        &mut console,
+        Args::from(["lint", &format!("{}/test.js", fs.cli_path())].as_slice()),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "extends_config_with_object_syntax_plugin_from_npm_package",
+        fs.create_mem(),
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn extends_config_ok_linter_not_formatter() {
     let fs = MemoryFileSystem::default();
diff --git a/crates/biome_cli/tests/cases/html.rs b/crates/biome_cli/tests/cases/html.rs
index 353a87c1ce89..a719db2e67ac 100644
--- a/crates/biome_cli/tests/cases/html.rs
+++ b/crates/biome_cli/tests/cases/html.rs
@@ -568,6 +568,51 @@ fn should_lint_a_html_file() {
     ));
 }
 
+#[test]
+fn should_handle_htm_file() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let htm_file = Utf8Path::new("index.htm");
+    fs.insert(
+        htm_file.into(),
+        r#"<div scope = "col"></div>
+"#
+        .as_bytes(),
+    );
+
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "formatter": {
+            "enabled": true
+        },
+        "linter": {
+            "enabled": true
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["check", htm_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_handle_htm_file",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 fn should_handle_svg_file() {
     let fs = MemoryFileSystem::default();
diff --git a/crates/biome_cli/tests/cases/mod.rs b/crates/biome_cli/tests/cases/mod.rs
index 8179f9d31433..c475016683e1 100644
--- a/crates/biome_cli/tests/cases/mod.rs
+++ b/crates/biome_cli/tests/cases/mod.rs
@@ -48,7 +48,6 @@ mod reporter_terminal;
 mod rules_via_dependencies;
 mod suppressions;
 mod tailwind_directives;
-mod type_inference_profile;
 mod unknown_files;
 mod vcs_ignored_files;
 mod vue_cross_language_rules;
diff --git a/crates/biome_cli/tests/cases/monorepo.rs b/crates/biome_cli/tests/cases/monorepo.rs
index ee69277d66d1..f580a21075f4 100644
--- a/crates/biome_cli/tests/cases/monorepo.rs
+++ b/crates/biome_cli/tests/cases/monorepo.rs
@@ -815,3 +815,95 @@ fn plugins_from_root_config_work_in_child_config_extends_root() {
         result,
     ));
 }
+
+#[test]
+fn object_syntax_plugins_in_extended_config_work_from_declaring_config() {
+    let mut fs =
+        TemporaryFs::new("object_syntax_plugins_in_extended_config_work_from_declaring_config");
+
+    fs.create_file("biome.json", r#"{ "root": true }"#);
+
+    fs.create_file(
+        "packages/tools/biome.shared.jsonc",
+        r#"{ "plugins": [{ "path": "./biome-plugins/no-object-assign.grit", "resolutionKind": "config" }], "linter": { "enabled": true } }"#,
+    );
+
+    fs.create_file(
+        "packages/tools/biome-plugins/no-object-assign.grit",
+        r#"`$fn($args)` where {
+    $fn <: `Object.assign`,
+    register_diagnostic(
+        span = $fn,
+        message = "Prefer object spread instead of Object.assign()",
+        severity = "warn"
+    )
+}"#,
+    );
+
+    fs.create_file(
+        "packages/mobile/biome.json",
+        r#"{ "root": false, "extends": ["../tools/biome.shared.jsonc"] }"#,
+    );
+    fs.create_file("packages/mobile/src/file.js", "Object.assign({}, a, b);\n");
+
+    let mut console = BufferConsole::default();
+    let result = run_cli_with_dyn_fs(
+        Box::new(fs.create_os()),
+        &mut console,
+        Args::from(
+            [
+                "lint",
+                &format!("{}/packages/mobile/src/file.js", fs.cli_path()),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "object_syntax_plugins_in_extended_config_work_from_declaring_config",
+        fs.create_mem(),
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn object_syntax_plugins_in_extended_config_missing_plugin_reports_error() {
+    let mut fs =
+        TemporaryFs::new("object_syntax_plugins_in_extended_config_missing_plugin_reports_error");
+
+    fs.create_file("biome.json", r#"{ "root": true }"#);
+
+    fs.create_file(
+        "packages/tools/biome.shared.jsonc",
+        r#"{ "plugins": [{ "path": "./biome-plugins/no-object-assign.grit", "resolutionKind": "config" }], "linter": { "enabled": true } }"#,
+    );
+
+    fs.create_file(
+        "packages/mobile/biome.json",
+        r#"{ "root": false, "extends": ["../tools/biome.shared.jsonc"] }"#,
+    );
+    fs.create_file("packages/mobile/src/file.js", "Object.assign({}, a, b);\n");
+
+    let mut console = BufferConsole::default();
+    let result = run_cli_with_dyn_fs(
+        Box::new(fs.create_os()),
+        &mut console,
+        Args::from(
+            [
+                "lint",
+                &format!("{}/packages/mobile/src/file.js", fs.cli_path()),
+            ]
+            .as_slice(),
+        ),
+    );
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "object_syntax_plugins_in_extended_config_missing_plugin_reports_error",
+        fs.create_mem(),
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/cases/type_inference_profile.rs b/crates/biome_cli/tests/cases/type_inference_profile.rs
deleted file mode 100644
index 1a46b0d16427..000000000000
--- a/crates/biome_cli/tests/cases/type_inference_profile.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use crate::run_cli_with_server_workspace;
-use crate::snap_test::markup_to_string;
-use biome_console::{BufferConsole, markup};
-use biome_fs::MemoryFileSystem;
-use bpaf::Args;
-use serial_test::serial;
-
-fn run_lint(extra_arguments: &[&str]) -> String {
-    let fs = MemoryFileSystem::default();
-    let mut console = BufferConsole::default();
-    let file_path = "file.ts";
-    fs.insert(
-        file_path.into(),
-        "async function returnsPromise() {}\nreturnsPromise();\n",
-    );
-    let mut arguments = vec!["lint", "--only=nursery/noFloatingPromises"];
-    arguments.extend_from_slice(extra_arguments);
-    arguments.push(file_path);
-
-    let (_fs, _result) =
-        run_cli_with_server_workspace(fs, &mut console, Args::from(arguments.as_slice()));
-
-    console
-        .out_buffer
-        .iter()
-        .map(|message| markup_to_string(markup! {{ message.content }}))
-        .collect()
-}
-
-fn run_profile(extra_arguments: &[&str]) -> String {
-    let mut arguments = vec!["--profile-type-inference"];
-    arguments.extend_from_slice(extra_arguments);
-    run_lint(&arguments)
-}
-
-#[test]
-#[serial]
-fn reports_compact_profile_with_relative_text_ranges() {
-    let output = run_profile(&[]);
-
-    assert!(output.contains("Type inference profile"), "{output}");
-    assert!(output.contains("Showing ranked aggregates"), "{output}");
-    assert!(output.contains("Requests by consumer"), "{output}");
-    assert!(output.contains("Query bodies"), "{output}");
-    assert!(output.contains("file.ts:"), "{output}");
-    assert!(!output.contains("Hot inference queries"), "{output}");
-    assert!(!output.contains("Code references"), "{output}");
-}
-
-#[test]
-#[serial]
-fn verbose_profile_reports_every_source_record() {
-    for arguments in [&["--verbose"][..], &["--reporter=summary", "--verbose"][..]] {
-        let output = run_profile(arguments);
-
-        assert!(output.contains("Hot request origins"), "{output}");
-        assert!(output.contains("Hot inference queries"), "{output}");
-        assert!(output.contains("Interpretation"), "{output}");
-        assert!(output.contains("Code references"), "{output}");
-        assert!(!output.contains("Showing ranked aggregates"), "{output}");
-    }
-}
-
-#[test]
-#[serial]
-fn rule_profiler_is_scoped_to_requested_run() {
-    biome_analyze::profiling::disable();
-    biome_analyze::profiling::reset();
-
-    let profiled_output = run_lint(&["--profile-rules"]);
-    assert!(
-        profiled_output.contains("Rule execution time"),
-        "{profiled_output}"
-    );
-
-    let regular_output = run_lint(&[]);
-    assert!(
-        !regular_output.contains("Rule execution time"),
-        "{regular_output}"
-    );
-    assert!(!biome_analyze::profiling::is_enabled());
-}
-
-#[test]
-#[serial]
-fn reports_profile_to_console_with_a_file_reporter() {
-    let output = run_profile(&["--reporter=json", "--reporter-file=report.json"]);
-
-    assert!(output.contains("Type inference profile"), "{output}");
-}
-
-#[test]
-#[serial]
-fn reports_profile_once_with_multiple_reporters() {
-    let output = run_profile(&["--reporter=summary", "--reporter=concise"]);
-
-    assert_eq!(
-        output.matches("Type inference profile").count(),
-        1,
-        "{output}"
-    );
-}
-
-#[test]
-#[serial]
-fn rejects_unsupported_execution_modes() {
-    for arguments in [
-        vec![
-            "lint",
-            "--profile-type-inference",
-            "--use-server",
-            "file.ts",
-        ],
-        vec![
-            "lint",
-            "--profile-type-inference",
-            "--stdin-file-path=file.ts",
-        ],
-    ] {
-        let fs = MemoryFileSystem::default();
-        fs.insert("file.ts".into(), "const value = 1;\n");
-        let mut console = BufferConsole::default();
-        let (_fs, result) =
-            run_cli_with_server_workspace(fs, &mut console, Args::from(arguments.as_slice()));
-        assert!(
-            matches!(
-                result,
-                Err(biome_cli::CliDiagnostic::IncompatibleArguments(_))
-            ),
-            "unsupported mode must report incompatible arguments: {arguments:?}"
-        );
-    }
-}
diff --git a/crates/biome_cli/tests/commands/rage.rs b/crates/biome_cli/tests/commands/rage.rs
index 91f6946e1807..0e5b218211ab 100644
--- a/crates/biome_cli/tests/commands/rage.rs
+++ b/crates/biome_cli/tests/commands/rage.rs
@@ -186,6 +186,38 @@ fn with_malformed_configuration() {
     ));
 }
 
+#[test]
+#[serial]
+fn with_files_configuration() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+    fs.insert(
+        Utf8Path::new("biome.json").to_path_buf(),
+        r#"{
+  "files": {
+    "ignoreUnknown": true,
+    "includes": [
+      "**/*.js",
+      "**/*.ts",
+      "!**/generated/**"
+    ]
+  }
+}"#,
+    );
+
+    let (fs, result) = run_rage(fs, &mut console, Args::from(["rage"].as_slice()));
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_rage_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "with_files_configuration",
+        fs,
+        console,
+        result,
+    ));
+}
+
 #[test]
 #[serial]
 fn with_formatter_configuration() {
diff --git a/crates/biome_cli/tests/snapshots/main_cases_config_extends/extends_config_with_object_syntax_plugin_from_npm_package.snap b/crates/biome_cli/tests/snapshots/main_cases_config_extends/extends_config_with_object_syntax_plugin_from_npm_package.snap
new file mode 100644
index 000000000000..88c2b0d21261
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_config_extends/extends_config_with_object_syntax_plugin_from_npm_package.snap
@@ -0,0 +1,91 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{ "extends": ["@shared/config/biome"] }
+```
+
+## `node_modules/@shared/config/biome.jsonc`
+
+```json
+{
+  "root": false,
+  "plugins": [
+    { "path": "./grit/no-object-assign.grit", "resolutionKind": "config" }
+  ],
+  "linter": { "enabled": true }
+}
+```
+
+## `node_modules/@shared/config/grit/no-object-assign.grit`
+
+```grit
+`$fn($args)` where {
+    $fn <: `Object.assign`,
+    register_diagnostic(
+        span = $fn,
+        message = "Prefer object spread instead of Object.assign()",
+        severity = "warn"
+    )
+}
+```
+
+## `node_modules/@shared/config/package.json`
+
+```json
+{
+    "name": "@shared/config",
+    "exports": {
+        "./biome": "./biome.jsonc"
+    }
+}
+```
+
+## `test.js`
+
+```js
+const merged = Object.assign({}, a, b);
+
+```
+
+# Emitted Messages
+
+```block
+test.js:1:16 plugin ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Prefer object spread instead of Object.assign()
+  
+  > 1 │ const merged = Object.assign({}, a, b);
+      │                ^^^^^^^^^^^^^
+    2 │ 
+  
+
+```
+
+```block
+test.js:1:7 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! This variable merged is unused.
+  
+  > 1 │ const merged = Object.assign({}, a, b);
+      │       ^^^^^^
+    2 │ 
+  
+  i Unused variables are often the result of typos, incomplete refactors, or other sources of bugs.
+  
+  i Unsafe fix: If this is intentional, prepend merged with an underscore.
+  
+    1   │ - const·merged·=·Object.assign({},·a,·b);
+      1 │ + const·_merged·=·Object.assign({},·a,·b);
+    2 2 │   
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 2 warnings.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_help/check_help.snap b/crates/biome_cli/tests/snapshots/main_cases_help/check_help.snap
index 38a7a994be42..04d86213fe5f 100644
--- a/crates/biome_cli/tests/snapshots/main_cases_help/check_help.snap
+++ b/crates/biome_cli/tests/snapshots/main_cases_help/check_help.snap
@@ -317,6 +317,8 @@ Available options:
                               set to `true`. Defaults to `false`.
         --profile-rules       Reports how long each rule takes to run. It excludes the time spent
                               preparing the analysis, such as building the semantic model.
+        --profile-type-inference  Enables type-inference profiling output, grouped and ranked by
+                              source file.
         --stdin-file-path=PATH  Reads code from standard input and writes the processed code to
                               standard output.
                               Biome uses `PATH` to select settings and determine the input type from
diff --git a/crates/biome_cli/tests/snapshots/main_cases_help/lint_help.snap b/crates/biome_cli/tests/snapshots/main_cases_help/lint_help.snap
index fb0f3d709c42..1b1cd84ddf52 100644
--- a/crates/biome_cli/tests/snapshots/main_cases_help/lint_help.snap
+++ b/crates/biome_cli/tests/snapshots/main_cases_help/lint_help.snap
@@ -142,6 +142,8 @@ Available options:
                               `vcs.defaultBranch`. Requires `--changed`.
         --profile-rules       Reports how long each rule takes to run. It excludes the time spent
                               preparing the analysis, such as building the semantic model.
+        --profile-type-inference  Enables type-inference profiling output, grouped and ranked by
+                              source file.
         --watch               After the initial run, watches the selected paths and reprocesses
                               files modified afterward.
     -h, --help                Prints help information
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_handle_htm_file.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_handle_htm_file.snap
new file mode 100644
index 000000000000..3bc688a594bb
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_handle_htm_file.snap
@@ -0,0 +1,77 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+assertion_line: 577
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "formatter": {
+      "enabled": true
+    },
+    "linter": {
+      "enabled": true
+    }
+  }
+}
+```
+
+## `index.htm`
+
+```htm
+<div scope = "col"></div>
+
+```
+
+# Termination Message
+
+```block
+check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+index.htm:1:6 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+  > 1 │ <div scope = "col"></div>
+      │      ^^^^^^^^^^^^^
+    2 │ 
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    1 │ <div·scope·=·"col"></div>
+      │      -------------       
+
+```
+
+```block
+index.htm format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Formatter would have printed the following content:
+  
+    1 │ <div·scope·=·"col"></div>
+      │           - -            
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 2 errors.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_missing_plugin_reports_error.snap b/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_missing_plugin_reports_error.snap
new file mode 100644
index 000000000000..88c94229bfbe
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_missing_plugin_reports_error.snap
@@ -0,0 +1,50 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{ "root": true }
+```
+
+## `packages/mobile/biome.json`
+
+```json
+{ "root": false, "extends": ["../tools/biome.shared.jsonc"] }
+```
+
+## `packages/mobile/src/file.js`
+
+```js
+Object.assign({}, a, b);
+
+```
+
+## `packages/tools/biome.shared.jsonc`
+
+```jsonc
+{ "plugins": [{ "path": "./biome-plugins/no-object-assign.grit", "resolutionKind": "config" }], "linter": { "enabled": true } }
+```
+
+# Termination Message
+
+```block
+configuration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Biome exited because the configuration resulted in errors. Please fix them.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+plugin ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Error(s) during loading of plugins:
+    Failed to read plugin file <TEMP_DIR>/object_syntax_plugins_in_extended_config_missing_plugin_reports_error/packages/tools/biome-plugins/no-object-assign.grit
+  
+
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_work_from_declaring_config.snap b/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_work_from_declaring_config.snap
new file mode 100644
index 000000000000..2741fdb9adac
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_monorepo/object_syntax_plugins_in_extended_config_work_from_declaring_config.snap
@@ -0,0 +1,60 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{ "root": true }
+```
+
+## `packages/mobile/biome.json`
+
+```json
+{ "root": false, "extends": ["../tools/biome.shared.jsonc"] }
+```
+
+## `packages/mobile/src/file.js`
+
+```js
+Object.assign({}, a, b);
+
+```
+
+## `packages/tools/biome-plugins/no-object-assign.grit`
+
+```grit
+`$fn($args)` where {
+    $fn <: `Object.assign`,
+    register_diagnostic(
+        span = $fn,
+        message = "Prefer object spread instead of Object.assign()",
+        severity = "warn"
+    )
+}
+```
+
+## `packages/tools/biome.shared.jsonc`
+
+```jsonc
+{ "plugins": [{ "path": "./biome-plugins/no-object-assign.grit", "resolutionKind": "config" }], "linter": { "enabled": true } }
+```
+
+# Emitted Messages
+
+```block
+packages/mobile/src/file.js:1:1 plugin ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Prefer object spread instead of Object.assign()
+  
+  > 1 │ Object.assign({}, a, b);
+      │ ^^^^^^^^^^^^^
+    2 │ 
+  
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 warning.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
index bc36115a079a..a64fe08b890f 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_configuration.snap
@@ -51,6 +51,10 @@ Biome Configuration:
   VCS enabled:                  false
   HTML full support enabled:    unset
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_custom_config_path.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_custom_config_path.snap
index 36d41ae0b407..069efa3eb165 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_custom_config_path.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_custom_config_path.snap
@@ -51,6 +51,10 @@ Biome Configuration:
   VCS enabled:                  false
   HTML full support enabled:    unset
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_files_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_files_configuration.snap
new file mode 100644
index 000000000000..81964d1d5414
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_files_configuration.snap
@@ -0,0 +1,67 @@
+---
+source: crates/biome_cli/tests/commands/rage.rs
+expression: content
+---
+## `biome.json`
+
+```json
+{
+  "files": {
+    "ignoreUnknown": true,
+    "includes": ["**/*.js", "**/*.ts", "!**/generated/**"]
+  }
+}
+```
+
+# Emitted Messages
+
+```block
+CLI:
+  Version:                      0.0.0
+  Color support:                **PLACEHOLDER**
+
+Platform:
+  CPU Architecture:             **PLACEHOLDER**
+  OS:                           **PLACEHOLDER**
+
+Environment:
+  BIOME_DISTRIBUTION:                unset
+  BIOME_LOG_FILE:                    unset
+  BIOME_LOG_PATH:                    **PLACEHOLDER**
+  BIOME_LOG_PREFIX_NAME:             unset
+  BIOME_LOG_LEVEL:                   unset
+  BIOME_LOG_KIND:                    unset
+  BIOME_CONFIG_PATH:                 unset
+  BIOME_THREADS:                     unset
+  BIOME_WATCHER_KIND:                unset
+  BIOME_WATCHER_POLLING_INTERVAL:    unset
+  BIOME_BINARY:                      unset
+  RUST_BACKTRACE:                    **PLACEHOLDER**
+  NO_COLOR:                     **PLACEHOLDER**
+  TERM:                         **PLACEHOLDER**
+  JS_RUNTIME_VERSION:           unset
+  JS_RUNTIME_NAME:              unset
+  NODE_PACKAGE_MANAGER:         unset
+
+Biome Configuration:
+  Status:                       Loaded successfully.
+  Path:                         biome.json
+  Formatter enabled:            true
+  Linter enabled:               true
+  Assist enabled:               true
+  VCS enabled:                  false
+  HTML full support enabled:    unset
+
+Files:
+  Ignore Unknown:               true
+  Includes:                     **/*.js, **/*.ts, !**/generated/**
+
+Server:
+  Version:                      0.0.0
+  Name:                         biome_lsp
+  CPU Architecture:             **PLACEHOLDER**
+  OS:                           **PLACEHOLDER**
+
+Workspace:
+  Open Documents:               0
+```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_formatter_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_formatter_configuration.snap
index de8410bb6973..2f265779ecc7 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_formatter_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_formatter_configuration.snap
@@ -140,6 +140,10 @@ GraphQL Formatter:
   Bracket spacing:              unset
   Quote style:                  unset
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_jsonc_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_jsonc_configuration.snap
index 5d78c1bc1949..d0f9bfb6e752 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_jsonc_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_jsonc_configuration.snap
@@ -52,6 +52,10 @@ Biome Configuration:
   VCS enabled:                  false
   HTML full support enabled:    unset
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_configuration.snap
index 42653b21978b..c17d7b10274e 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_configuration.snap
@@ -113,6 +113,10 @@ Linter:
     complexity/useSimpleNumberKeys
     suspicious/noCommentText
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_domain_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_domain_configuration.snap
index e2721ac48673..ab28f9feb2b7 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_domain_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_linter_domain_configuration.snap
@@ -73,6 +73,10 @@ Linter:
     correctness/useQwikValidLexicalScope
     suspicious/noReactSpecificProps
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap b/crates/biome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
index b0e33f769c72..c39ae1f20071 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_rage/with_malformed_configuration.snap
@@ -52,6 +52,10 @@ Biome Configuration:
   VCS enabled:                  false
   HTML full support enabled:    unset
 
+Files:
+  Ignore Unknown:               unset
+  Includes:                     unset
+
 Server:
   Version:                      0.0.0
   Name:                         biome_lsp
diff --git a/crates/biome_configuration/Cargo.toml b/crates/biome_configuration/Cargo.toml
index 8394838660bb..fa5379bdecff 100644
--- a/crates/biome_configuration/Cargo.toml
+++ b/crates/biome_configuration/Cargo.toml
@@ -40,6 +40,7 @@ biome_plugin_loader        = { workspace = true, optional = true }
 biome_resolver             = { workspace = true }
 biome_rowan                = { workspace = true, features = ["serde"] }
 biome_rule_options         = { workspace = true }
+biome_string_case          = { workspace = true }
 biome_yaml_syntax          = { workspace = true, optional = true }
 bpaf                       = { workspace = true, optional = true }
 camino                     = { workspace = true }
diff --git a/crates/biome_configuration/src/analyzer/mod.rs b/crates/biome_configuration/src/analyzer/mod.rs
index e7e7096f672d..434079799a42 100644
--- a/crates/biome_configuration/src/analyzer/mod.rs
+++ b/crates/biome_configuration/src/analyzer/mod.rs
@@ -7,11 +7,13 @@ pub use crate::analyzer::linter::*;
 use crate::analyzer::presets::PresetConfig;
 use biome_analyze::options::RuleOptions;
 use biome_analyze::{FixKind, PLUGIN_GROUP, Rule, RuleCategory, RuleDomain, RuleFilter};
+use biome_console::markup;
 use biome_deserialize::{
     Deserializable, DeserializableType, DeserializableValue, DeserializationContext, Merge,
 };
 use biome_deserialize_macros::{Deserializable, Merge};
 use biome_diagnostics::Severity;
+use biome_string_case::Case;
 use rustc_hash::FxHashSet;
 #[cfg(feature = "schema")]
 use schemars::JsonSchema;
@@ -703,6 +705,44 @@ impl Display for RuleSelector {
     }
 }
 
+impl biome_console::fmt::Display for AnalyzerSelector {
+    fn fmt(&self, f: &mut biome_console::fmt::Formatter) -> std::io::Result<()> {
+        match self {
+            Self::Rule(rule) => f.write_markup(markup! {{rule}}),
+            Self::Domain(domain) => f.write_markup(markup! {{domain}}),
+            Self::Plugin => f.write_str("plugin/plugin"),
+        }
+    }
+}
+
+impl biome_console::fmt::Display for RuleSelector {
+    fn fmt(&self, f: &mut biome_console::fmt::Formatter) -> std::io::Result<()> {
+        match self {
+            Self::Group(group) => {
+                let link = format!("https://biomejs.dev/linter/#{}", group);
+                f.write_markup(markup! {
+                    <Hyperlink href={link}>{group}</Hyperlink>
+                })
+            }
+            Self::Rule(group, rule) => {
+                let rule = Case::Kebab.convert(rule);
+                f.write_markup(markup! {
+                    <Hyperlink href={format!("https://biomejs.dev/linter/rules/{}/", rule)}>{group}"/"{rule}</Hyperlink>
+                })
+            }
+        }
+    }
+}
+
+impl biome_console::fmt::Display for DomainSelector {
+    fn fmt(&self, f: &mut biome_console::fmt::Formatter) -> std::io::Result<()> {
+        let link = format!("https://biomejs.dev/linter/domains/#{}", self.0);
+        f.write_markup(markup! {
+            <Hyperlink href={link}>{Case::Upper.convert(self.0)}</Hyperlink>
+        })
+    }
+}
+
 impl RuleSelector {
     /// It retrieves a [RuleSelector] from an LSP filter.
     ///
diff --git a/crates/biome_configuration/src/lib.rs b/crates/biome_configuration/src/lib.rs
index ba165888fb24..564a3b937944 100644
--- a/crates/biome_configuration/src/lib.rs
+++ b/crates/biome_configuration/src/lib.rs
@@ -27,6 +27,7 @@ pub mod json;
 pub mod markdown;
 pub mod max_size;
 mod overrides;
+pub mod tailwind;
 pub mod vcs;
 #[cfg(feature = "lang_yaml")]
 pub mod yaml;
@@ -57,6 +58,7 @@ pub use crate::markdown::MarkdownConfiguration;
 #[cfg(all(feature = "cli", feature = "lang_md"))]
 pub use crate::markdown::markdown_configuration;
 use crate::max_size::MaxSize;
+pub use crate::tailwind::TailwindConfiguration;
 use crate::vcs::VcsConfiguration;
 #[cfg(feature = "cli")]
 use crate::vcs::vcs_configuration;
@@ -186,6 +188,11 @@ pub struct Configuration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub linter: Option<LinterConfiguration>,
 
+    /// Configures how Biome recognizes Tailwind class strings.
+    #[cfg_attr(feature = "cli", bpaf(hide, pure(Default::default())))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tailwind: Option<TailwindConfiguration>,
+
     /// Configuration specific to JavaScript.
     #[cfg(feature = "lang_js")]
     #[cfg_attr(feature = "cli", bpaf(external(js_configuration), optional))]
@@ -368,6 +375,10 @@ impl Configuration {
         self.extends.as_ref().is_some_and(Extends::extends_root)
     }
 
+    pub fn get_files_configuration(&self) -> FilesConfiguration {
+        self.files.clone().unwrap_or_default()
+    }
+
     pub fn get_formatter_configuration(&self) -> FormatterConfiguration {
         self.formatter.clone().unwrap_or_default()
     }
diff --git a/crates/biome_configuration/src/tailwind.rs b/crates/biome_configuration/src/tailwind.rs
new file mode 100644
index 000000000000..f6a55fb68405
--- /dev/null
+++ b/crates/biome_configuration/src/tailwind.rs
@@ -0,0 +1,28 @@
+use biome_analyze::options::TailwindOptions;
+use biome_deserialize_macros::{Deserializable, Merge};
+use serde::{Deserialize, Serialize};
+
+/// Configures how Biome recognizes Tailwind class strings.
+#[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", deny_unknown_fields, default)]
+pub struct TailwindConfiguration {
+    /// Attribute names whose values contain Tailwind classes.
+    ///
+    /// Defaults to `class` for HTML and to `class` and `className` for JSX.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attributes: Option<Box<[Box<str>]>>,
+
+    /// Function and tagged-template names whose arguments contain Tailwind classes.
+    ///
+    /// Defaults to `clsx`, `tw`, `twMerge`, `twJoin`, `cva`, `tv`, `cn`, `cc`,
+    /// `cnb`, and `ctl`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub functions: Option<Box<[Box<str>]>>,
+}
+
+impl From<TailwindConfiguration> for TailwindOptions {
+    fn from(configuration: TailwindConfiguration) -> Self {
+        Self::new(configuration.attributes, configuration.functions)
+    }
+}
diff --git a/crates/biome_diagnostics_categories/src/categories.rs b/crates/biome_diagnostics_categories/src/categories.rs
index 6afbabd5709c..aded92c718ff 100644
--- a/crates/biome_diagnostics_categories/src/categories.rs
+++ b/crates/biome_diagnostics_categories/src/categories.rs
@@ -600,6 +600,7 @@ define_categories! {
     "reporter/parse",
     "reporter/format",
     "reporter/violations",
+    "reporter/profiler",
     // parse categories
     "parse",
 
diff --git a/crates/biome_html_analyze/src/assist/source/use_sorted_attributes.rs b/crates/biome_html_analyze/src/assist/source/use_sorted_attributes.rs
index 48ddd4c2771f..47edcf29002b 100644
--- a/crates/biome_html_analyze/src/assist/source/use_sorted_attributes.rs
+++ b/crates/biome_html_analyze/src/assist/source/use_sorted_attributes.rs
@@ -117,6 +117,22 @@ declare_source_rule! {
     /// <textarea id="mytextarea" name="textarea" rows="5" cols="20" data-1="" data-2="" data-11="" data-12="">Hello, world!</textarea>
     /// ```
     ///
+    /// ### `sortFirst`
+    /// A list of attribute names that should be sorted before all other attributes,
+    /// in the order they appear in this list. The remaining attributes are sorted
+    /// after the listed ones. Listed attributes take precedence over the category-based ordering.
+    ///
+    /// ```json,options
+    /// {
+    ///     "options": {
+    ///         "sortFirst": ["type"]
+    ///     }
+    /// }
+    /// ```
+    /// ```html,use_options,expect_diagnostic
+    /// <input id="name" name="name" type="text" />
+    /// ```
+    ///
     pub UseSortedAttributes {
         version: "2.5.0",
         name: "useSortedAttributes",
@@ -151,8 +167,12 @@ impl Rule for UseSortedAttributes {
         let mut current_attr_group = AttributeGroup::default();
         let mut attr_groups = Vec::new();
         let sort_by = options.sort_order.unwrap_or_default();
+        let sort_first = options.sort_first.as_deref().unwrap_or_default();
 
-        let comparator = get_comparator(sort_by);
+        let base = get_comparator(sort_by);
+        let comparator = |a: &SortableHtmlAttribute, b: &SortableHtmlAttribute| {
+            a.cmp_sort_first(b, sort_first, base)
+        };
 
         // Convert to boolean-based comparator for is_sorted_by
         let boolean_comparator = |a: &SortableHtmlAttribute, b: &SortableHtmlAttribute| {
@@ -213,8 +233,12 @@ impl Rule for UseSortedAttributes {
         let mut mutation = ctx.root().begin();
         let options = ctx.options();
         let sort_by = options.sort_order.unwrap_or_default();
+        let sort_first = options.sort_first.as_deref().unwrap_or_default();
 
-        let comparator = get_comparator(sort_by);
+        let base = get_comparator(sort_by);
+        let comparator = |a: &SortableHtmlAttribute, b: &SortableHtmlAttribute| {
+            a.cmp_sort_first(b, sort_first, base)
+        };
 
         for (SortableHtmlAttribute(attr), SortableHtmlAttribute(sorted_attr)) in
             zip(state.attrs.iter(), state.get_sorted_attributes(comparator)?)
diff --git a/crates/biome_html_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs b/crates/biome_html_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
index 8ff774941469..9f50d7f9c6c5 100644
--- a/crates/biome_html_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
+++ b/crates/biome_html_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
@@ -1,12 +1,13 @@
+use crate::tailwind::host_range;
 use biome_analyze::{
-    Ast, Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,
+    Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,
 };
 use biome_console::markup;
-use biome_html_syntax::{AnyHtmlAttributeInitializer, HtmlAttribute, inner_string_text};
-use biome_rowan::{TextRange, TextSize};
+use biome_html_syntax::HtmlAttribute;
+use biome_rowan::TextRange;
 use biome_rule_options::no_tailwind_arbitrary_value::NoTailwindArbitraryValueOptions;
-use biome_tailwind_parser::parse_tailwind;
-use biome_tailwind_syntax::lint_utils::arbitrary_ranges;
+use biome_tailwind_logic::no_tailwind_arbitrary_value::analyze_tailwind_arbitrary_values;
+use biome_tailwind_logic::syntax_service::TailwindSyntax;
 
 declare_lint_rule! {
     /// Disallow arbitrary values in Tailwind CSS utility classes.
@@ -42,29 +43,19 @@ declare_lint_rule! {
     /// <div class="[&:nth-child(3)]:px-2"></div>
     /// ```
     ///
-    /// ## Options
+    /// ## Tailwind configuration
     ///
-    /// By default, this rule checks the `class` attribute. The `attributes`
-    /// option adds more HTML attributes to check.
+    /// Use the top-level `tailwind` configuration to control which attributes
+    /// contain Tailwind classes. Specified arrays replace the defaults.
     ///
-    /// ```json,options
+    /// ```json
     /// {
-    ///     "options": {
-    ///         "attributes": ["classList"]
+    ///     "tailwind": {
+    ///         "attributes": ["class", "classList"]
     ///     }
     /// }
     /// ```
     ///
-    /// ```html,use_options,expect_diagnostic
-    /// <div classList="w-[400px]"></div>
-    /// ```
-    ///
-    /// ### attributes
-    ///
-    /// Additional HTML attribute names to check.
-    ///
-    /// Default: `[]` (the `class` attribute is always checked).
-    ///
     pub NoTailwindArbitraryValue {
         version: "2.5.7",
         name: "noTailwindArbitraryValue",
@@ -76,55 +67,20 @@ declare_lint_rule! {
 }
 
 impl Rule for NoTailwindArbitraryValue {
-    type Query = Ast<HtmlAttribute>;
+    type Query = TailwindSyntax<HtmlAttribute>;
     type State = TextRange;
     type Signals = Vec<TextRange>;
     type Options = NoTailwindArbitraryValueOptions;
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
-        let attribute = ctx.query();
-        let options = ctx.options();
-
-        let Some(name) = attribute
-            .name()
-            .ok()
-            .and_then(|name| name.value_token().ok())
-            .map(|token| token.token_text_trimmed())
-        else {
-            return vec![];
-        };
-
-        if !is_html_class_attribute(name.text(), options) {
-            return vec![];
-        }
-
-        let Some(initializer) = attribute.initializer() else {
-            return vec![];
-        };
-        let Ok(AnyHtmlAttributeInitializer::HtmlString(html_string)) = initializer.value() else {
-            return vec![];
-        };
-        let Ok(token) = html_string.value_token() else {
-            return vec![];
-        };
-
-        let text = inner_string_text(&token);
-        if !text.text().contains('[') {
-            return vec![];
-        }
-
-        // HTML attribute values are always quoted per spec
-        let content_start = token.text_trimmed_range().start() + TextSize::from(1);
-
-        let parse = parse_tailwind(text.text());
-        arbitrary_ranges(&parse.tree().candidates(), content_start)
+        analyze_tailwind_arbitrary_values(&ctx.query().tailwind_root().candidates())
     }
 
-    fn diagnostic(_ctx: &RuleContext<Self>, range: &Self::State) -> Option<RuleDiagnostic> {
+    fn diagnostic(ctx: &RuleContext<Self>, range: &Self::State) -> Option<RuleDiagnostic> {
         Some(
             RuleDiagnostic::new(
                 rule_category!(),
-                range,
+                host_range(ctx.query().node(), *range)?,
                 markup! { "Found an arbitrary value in a Tailwind CSS class." },
             )
             .note(markup! {
@@ -136,13 +92,3 @@ impl Rule for NoTailwindArbitraryValue {
         )
     }
 }
-
-fn is_html_class_attribute(name: &str, options: &NoTailwindArbitraryValueOptions) -> bool {
-    name.eq_ignore_ascii_case("class")
-        || options
-            .attributes
-            .iter()
-            .flatten()
-            .any(|attribute| attribute.as_ref().eq_ignore_ascii_case(name))
-}
-
diff --git a/crates/biome_html_analyze/src/lint/nursery/use_sorted_classes.rs b/crates/biome_html_analyze/src/lint/nursery/use_sorted_classes.rs
new file mode 100644
index 000000000000..303afc3accae
--- /dev/null
+++ b/crates/biome_html_analyze/src/lint/nursery/use_sorted_classes.rs
@@ -0,0 +1,151 @@
+use biome_analyze::{
+    Ast, FixKind, Rule, RuleDiagnostic, context::RuleContext, declare_lint_rule,
+};
+use biome_analyze::shared::sorted_classes::{
+    sort::sort_class_name,
+    sort_config::DEFAULT_SORT_CONFIG,
+};
+use biome_console::markup;
+use biome_html_factory::make;
+use biome_html_syntax::{
+    HtmlAttribute, HtmlString, HtmlSyntaxKind, HtmlSyntaxToken, inner_string_text,
+};
+use biome_languages::HtmlFileSource;
+use biome_rowan::{AstNode, BatchMutationExt};
+use biome_rule_options::use_sorted_classes::UseSortedClassesOptions;
+
+use crate::HtmlRuleAction;
+
+declare_lint_rule! {
+    /// Enforce the sorting of CSS utility classes.
+    ///
+    /// This rule implements the same sorting algorithm as [Tailwind CSS](https://tailwindcss.com/blog/automatic-class-sorting-with-prettier#how-classes-are-sorted), but supports any utility class framework including [UnoCSS](https://unocss.dev/).
+    ///
+    /// It is analogous to [`prettier-plugin-tailwindcss`](https://github.com/tailwindlabs/prettier-plugin-tailwindcss).
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```html,expect_diagnostic
+    /// <div class="px-2 foo p-4 bar"></div>
+    /// ```
+    ///
+    /// ```html,expect_diagnostic
+    /// <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```html
+    /// <div class="bar foo p-4 px-2"></div>
+    /// ```
+    ///
+    pub UseSortedClasses {
+        version: "2.5.0",
+        name: "useSortedClasses",
+        language: "html",
+        recommended: false,
+        fix_kind: FixKind::Unsafe,
+        issue_number: Some("9181"),
+    }
+}
+
+impl Rule for UseSortedClasses {
+    type Query = Ast<HtmlAttribute>;
+    type State = HtmlSortedClassesState;
+    type Signals = Option<Self::State>;
+    type Options = UseSortedClassesOptions;
+
+    fn run(ctx: &RuleContext<Self>) -> Option<Self::State> {
+        let attribute = ctx.query();
+        let file_source = ctx.source_type::<HtmlFileSource>();
+        let options = ctx.options();
+
+        let name = attribute.name().ok()?;
+        let name_token = name.value_token().ok()?;
+        let name_text = name_token.text_trimmed();
+        let matches = if file_source.is_html() {
+            name_text.eq_ignore_ascii_case("class")
+                || options
+                    .attributes
+                    .iter()
+                    .flatten()
+                    .any(|attr| attr.eq_ignore_ascii_case(name_text))
+        } else {
+            name_text == "class"
+                || options
+                    .attributes
+                    .iter()
+                    .flatten()
+                    .any(|attr| attr.as_ref() == name_text)
+        };
+        if !matches {
+            return None;
+        }
+
+        let initializer = attribute.initializer()?;
+        let value = initializer.value().ok()?;
+        let html_string = value.as_html_string()?.clone();
+        let value_token = html_string.value_token().ok()?;
+        let inner_text = inner_string_text(&value_token);
+        let value_str = inner_text.text();
+
+        let sorted_value = sort_class_name(&inner_text, &DEFAULT_SORT_CONFIG);
+        if sorted_value.is_empty() {
+            return None;
+        }
+        if value_str != sorted_value {
+            let is_single_quote = value_token.text_trimmed().starts_with('\'');
+            return Some(HtmlSortedClassesState {
+                html_string,
+                sorted: sorted_value.into(),
+                is_single_quote,
+            });
+        }
+
+        None
+    }
+
+    fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+        Some(RuleDiagnostic::new(
+            rule_category!(),
+            state.html_string.range(),
+            "These CSS classes should be sorted.",
+        ))
+    }
+
+    fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<HtmlRuleAction> {
+        let mut mutation = ctx.root().begin();
+
+        let new_token = if state.is_single_quote {
+            HtmlSyntaxToken::new_detached(
+                HtmlSyntaxKind::HTML_STRING_LITERAL,
+                &format!("'{}'", state.sorted),
+                [],
+                [],
+            )
+        } else {
+            make::html_string_literal(&state.sorted)
+        };
+
+        let new_html_string = make::html_string(new_token);
+        mutation.replace_node(state.html_string.clone(), new_html_string);
+
+        Some(HtmlRuleAction::new(
+            ctx.metadata().action_category(ctx.category(), ctx.group()),
+            ctx.metadata().applicability(),
+            markup! {
+                "Sort the classes."
+            }
+            .to_owned(),
+            mutation,
+        ))
+    }
+}
+
+pub struct HtmlSortedClassesState {
+    html_string: HtmlString,
+    sorted: Box<str>,
+    is_single_quote: bool,
+}
diff --git a/crates/biome_html_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs b/crates/biome_html_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
index 49c408bd7ccc..a2c85331c20f 100644
--- a/crates/biome_html_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
+++ b/crates/biome_html_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
@@ -42,6 +42,17 @@ declare_lint_rule! {
     /// <div class="size-4"></div>
     /// ```
     ///
+    /// Configure the recognized attributes with the top-level `tailwind` configuration.
+    /// Specified arrays replace the defaults.
+    ///
+    /// ```json
+    /// {
+    ///     "tailwind": {
+    ///         "attributes": ["class", "classList"]
+    ///     }
+    /// }
+    /// ```
+    ///
     /// ## Known limitations
     ///
     /// This rule currently doesn't check bare strings inside framework-specific class collections,
diff --git a/crates/biome_html_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid.options.json b/crates/biome_html_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid.options.json
index 08b7cbc249bb..e4f4f46dacc4 100644
--- a/crates/biome_html_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid.options.json
+++ b/crates/biome_html_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid.options.json
@@ -1,14 +1,12 @@
 {
 	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"tailwind": {
+		"attributes": ["class", "classList"]
+	},
 	"linter": {
 		"rules": {
 			"nursery": {
-				"noTailwindArbitraryValue": {
-					"level": "error",
-					"options": {
-						"attributes": ["classList"]
-					}
-				}
+				"noTailwindArbitraryValue": "error"
 			}
 		}
 	}
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html
new file mode 100644
index 000000000000..f3927f16a41c
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html
@@ -0,0 +1,3 @@
+<!-- should generate diagnostics -->
+
+<div data-class="px-2 foo p-4 bar"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html.snap
new file mode 100644
index 000000000000..3ceac65e77a5
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.html.snap
@@ -0,0 +1,38 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: invalid.html
+---
+# Input
+```html
+<!-- should generate diagnostics -->
+
+<div data-class="px-2 foo p-4 bar"></div>
+
+```
+
+# Diagnostics
+```
+invalid.html:3:17 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × These CSS classes should be sorted.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ 
+  > 3 │ <div data-class="px-2 foo p-4 bar"></div>
+      │                 ^^^^^^^^^^^^^^^^^^
+    4 │ 
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2 2 │   
+    3   │ - <div·data-class="px-2·foo·p-4·bar"></div>
+      3 │ + <div·data-class="foo·bar·p-4·px-2"></div>
+    4 4 │   
+  
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.options.json b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.options.json
new file mode 100644
index 000000000000..0856cedc3550
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/invalid.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "linter": {
+    "rules": {
+      "nursery": {
+        "useSortedClasses": {
+          "level": "error",
+          "options": {
+            "attributes": ["data-class"]
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html
new file mode 100644
index 000000000000..84b96798ee1c
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html
@@ -0,0 +1,3 @@
+<!-- should not generate diagnostics -->
+
+<div data-class="bar foo p-4 px-2"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html.snap
new file mode 100644
index 000000000000..99ae77e84a3f
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.html.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: valid.html
+---
+# Input
+```html
+<!-- should not generate diagnostics -->
+
+<div data-class="bar foo p-4 px-2"></div>
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.options.json b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.options.json
new file mode 100644
index 000000000000..0856cedc3550
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/custom-attribute/valid.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "linter": {
+    "rules": {
+      "nursery": {
+        "useSortedClasses": {
+          "level": "error",
+          "options": {
+            "attributes": ["data-class"]
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro
new file mode 100644
index 000000000000..365757279475
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro
@@ -0,0 +1,5 @@
+<!-- should generate diagnostics -->
+
+<div class="px-2 foo p-4 bar"></div>
+
+<div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro.snap
new file mode 100644
index 000000000000..99136aa60438
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.astro.snap
@@ -0,0 +1,68 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: invalid.astro
+---
+# Input
+```astro
+<!-- should generate diagnostics -->
+
+<div class="px-2 foo p-4 bar"></div>
+
+<div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+
+```
+
+# Diagnostics
+```
+invalid.astro:3:12 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These CSS classes should be sorted.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ 
+  > 3 │ <div class="px-2 foo p-4 bar"></div>
+      │            ^^^^^^^^^^^^^^^^^^
+    4 │ 
+    5 │ <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2 2 │   
+    3   │ - <div·class="px-2·foo·p-4·bar"></div>
+      3 │ + <div·class="foo·bar·p-4·px-2"></div>
+    4 4 │   
+    5 5 │   <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+  
+
+```
+
+```
+invalid.astro:5:12 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These CSS classes should be sorted.
+  
+    3 │ <div class="px-2 foo p-4 bar"></div>
+    4 │ 
+  > 5 │ <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+      │            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    6 │ 
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    3 3 │   <div class="px-2 foo p-4 bar"></div>
+    4 4 │   
+    5   │ - <div·class="hover:focus:m-2·foo·hover:px-2·p-4"></div>
+      5 │ + <div·class="foo·p-4·hover:px-2·hover:focus:m-2"></div>
+    6 6 │   
+  
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html
new file mode 100644
index 000000000000..77d50627c112
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html
@@ -0,0 +1,7 @@
+<!-- should generate diagnostics -->
+
+<div class="px-2 foo p-4 bar"></div>
+
+<div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+
+<div CLASS="px-2 foo p-4 bar"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html.snap
new file mode 100644
index 000000000000..d61c5c41443d
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/invalid.html.snap
@@ -0,0 +1,98 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: invalid.html
+---
+# Input
+```html
+<!-- should generate diagnostics -->
+
+<div class="px-2 foo p-4 bar"></div>
+
+<div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+
+<div CLASS="px-2 foo p-4 bar"></div>
+
+```
+
+# Diagnostics
+```
+invalid.html:3:12 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These CSS classes should be sorted.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ 
+  > 3 │ <div class="px-2 foo p-4 bar"></div>
+      │            ^^^^^^^^^^^^^^^^^^
+    4 │ 
+    5 │ <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2 2 │   
+    3   │ - <div·class="px-2·foo·p-4·bar"></div>
+      3 │ + <div·class="foo·bar·p-4·px-2"></div>
+    4 4 │   
+    5 5 │   <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+  
+
+```
+
+```
+invalid.html:5:12 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These CSS classes should be sorted.
+  
+    3 │ <div class="px-2 foo p-4 bar"></div>
+    4 │ 
+  > 5 │ <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+      │            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    6 │ 
+    7 │ <div CLASS="px-2 foo p-4 bar"></div>
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    3 3 │   <div class="px-2 foo p-4 bar"></div>
+    4 4 │   
+    5   │ - <div·class="hover:focus:m-2·foo·hover:px-2·p-4"></div>
+      5 │ + <div·class="foo·p-4·hover:px-2·hover:focus:m-2"></div>
+    6 6 │   
+    7 7 │   <div CLASS="px-2 foo p-4 bar"></div>
+  
+
+```
+
+```
+invalid.html:7:12 lint/nursery/useSortedClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These CSS classes should be sorted.
+  
+    5 │ <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+    6 │ 
+  > 7 │ <div CLASS="px-2 foo p-4 bar"></div>
+      │            ^^^^^^^^^^^^^^^^^^
+    8 │ 
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9181 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Sort the classes.
+  
+    5 5 │   <div class="hover:focus:m-2 foo hover:px-2 p-4"></div>
+    6 6 │   
+    7   │ - <div·CLASS="px-2·foo·p-4·bar"></div>
+      7 │ + <div·CLASS="foo·bar·p-4·px-2"></div>
+    8 8 │   
+  
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro
new file mode 100644
index 000000000000..33976ad977d5
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro
@@ -0,0 +1,3 @@
+<!-- should not generate diagnostics -->
+
+<div class="bar foo p-4 px-2"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro.snap
new file mode 100644
index 000000000000..609bdd30b188
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.astro.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: valid.astro
+---
+# Input
+```astro
+<!-- should not generate diagnostics -->
+
+<div class="bar foo p-4 px-2"></div>
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html
new file mode 100644
index 000000000000..33976ad977d5
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html
@@ -0,0 +1,3 @@
+<!-- should not generate diagnostics -->
+
+<div class="bar foo p-4 px-2"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html.snap b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html.snap
new file mode 100644
index 000000000000..1f574076fea5
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useSortedClasses/valid.html.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: valid.html
+---
+# Input
+```html
+<!-- should not generate diagnostics -->
+
+<div class="bar foo p-4 px-2"></div>
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html
index 0792c11f0e42..b661321e305d 100644
--- a/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html
+++ b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html
@@ -1 +1,2 @@
+<!-- should generate diagnostics -->
 <div data-classes="px-2 py-2"></div>
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html.snap b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html.snap
index 5b8b60c99d11..581b9ea115ba 100644
--- a/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html.snap
+++ b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.html.snap
@@ -4,6 +4,41 @@ expression: custom-attribute.html
 ---
 # Input
 ```html
+<!-- should generate diagnostics -->
 <div data-classes="px-2 py-2"></div>
 
 ```
+
+# Diagnostics
+```
+custom-attribute.html:2:20 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━
+
+  × These Tailwind classes can be replaced with a shorthand class.
+  
+    1 │ <!-- should generate diagnostics -->
+  > 2 │ <div data-classes="px-2 py-2"></div>
+      │                    ^^^^
+    3 │ 
+  
+  i Compressible utility used here.
+  
+    1 │ <!-- should generate diagnostics -->
+  > 2 │ <div data-classes="px-2 py-2"></div>
+      │                         ^^^^
+    3 │ 
+  
+  i Using fewer classes reduces duplication and improves readability.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/11342 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Use the Tailwind shorthand classes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2   │ - <div·data-classes="px-2·py-2"></div>
+      2 │ + <div·data-classes="p-2"></div>
+    3 3 │   
+  
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.options.json b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.options.json
new file mode 100644
index 000000000000..e2150a1aea49
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/nursery/useTailwindShorthandClasses/custom-attribute.options.json
@@ -0,0 +1,13 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"tailwind": {
+		"attributes": ["data-classes"]
+	},
+	"linter": {
+		"rules": {
+			"nursery": {
+				"useTailwindShorthandClasses": "error"
+			}
+		}
+	}
+}
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html
new file mode 100644
index 000000000000..b081156e669d
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html
@@ -0,0 +1,3 @@
+<!-- should generate diagnostics -->
+<input id="name" name="name" type="text" />
+<input checked name="" id="" type="checkbox">
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html.snap b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html.snap
new file mode 100644
index 000000000000..4f266d56828c
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.html.snap
@@ -0,0 +1,56 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: invalid.html
+---
+# Input
+```html
+<!-- should generate diagnostics -->
+<input id="name" name="name" type="text" />
+<input checked name="" id="" type="checkbox">
+
+```
+
+# Diagnostics
+```
+invalid.html:2:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted.
+  
+    1 │ <!-- should generate diagnostics -->
+  > 2 │ <input id="name" name="name" type="text" />
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    3 │ <input checked name="" id="" type="checkbox">
+    4 │ 
+  
+  i Safe fix: Sort the HTML attributes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2   │ - <input·id="name"·name="name"·type="text"·/>
+      2 │ + <input·type="text"·id="name"·name="name"·/>
+    3 3 │   <input checked name="" id="" type="checkbox">
+    4 4 │   
+  
+
+```
+
+```
+invalid.html:3:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ <input id="name" name="name" type="text" />
+  > 3 │ <input checked name="" id="" type="checkbox">
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    4 │ 
+  
+  i Safe fix: Sort the HTML attributes.
+  
+    1 1 │   <!-- should generate diagnostics -->
+    2 2 │   <input id="name" name="name" type="text" />
+    3   │ - <input·checked·name=""·id=""·type="checkbox">
+      3 │ + <input·type="checkbox"·id=""·checked·name=""·>
+    4 4 │   
+  
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.options.json b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.options.json
new file mode 100644
index 000000000000..1f078f2b52e3
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/invalid.options.json
@@ -0,0 +1,15 @@
+{
+    "$schema": "../../../../../../../packages/@biomejs/biome/configuration_schema.json",
+    "assist": {
+        "actions": {
+            "source": {
+                "useSortedAttributes": {
+                    "level": "on",
+                    "options": {
+                        "sortFirst": ["type", "id"]
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html
new file mode 100644
index 000000000000..6bb1e7c7a4c8
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html
@@ -0,0 +1,2 @@
+<!-- should not generate diagnostics -->
+<input type="text" id="name" name="name" />
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html.snap b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html.snap
new file mode 100644
index 000000000000..fcbbad5af5d6
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.html.snap
@@ -0,0 +1,10 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: valid.html
+---
+# Input
+```html
+<!-- should not generate diagnostics -->
+<input type="text" id="name" name="name" />
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.options.json b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.options.json
new file mode 100644
index 000000000000..1f078f2b52e3
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/source/useSortedAttributes/html/valid.options.json
@@ -0,0 +1,15 @@
+{
+    "$schema": "../../../../../../../packages/@biomejs/biome/configuration_schema.json",
+    "assist": {
+        "actions": {
+            "source": {
+                "useSortedAttributes": {
+                    "level": "on",
+                    "options": {
+                        "sortFirst": ["type", "id"]
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/biome_js_analyze/Cargo.toml b/crates/biome_js_analyze/Cargo.toml
index 7b2572d2eb90..b4ff4ce1c283 100644
--- a/crates/biome_js_analyze/Cargo.toml
+++ b/crates/biome_js_analyze/Cargo.toml
@@ -59,7 +59,6 @@ biome_tailwind_logic      = { workspace = true }
 biome_tailwind_parser     = { workspace = true }
 biome_tailwind_syntax     = { workspace = true }
 biome_unicode_table       = { workspace = true }
-bitvec                    = "1.0.1"
 camino                    = { workspace = true }
 either                    = { workspace = true }
 enumflags2                = { workspace = true }
diff --git a/crates/biome_js_analyze/benches/use_sorted_classes_parser.rs b/crates/biome_js_analyze/benches/use_sorted_classes_parser.rs
index 4fbf92d40833..72e5f7dc7242 100644
--- a/crates/biome_js_analyze/benches/use_sorted_classes_parser.rs
+++ b/crates/biome_js_analyze/benches/use_sorted_classes_parser.rs
@@ -1,4 +1,4 @@
-use biome_js_analyze::lint::nursery::use_sorted_classes::class_lexer::tokenize_class;
+use biome_analyze::shared::sorted_classes::tokenize_class;
 use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 
 #[cfg(target_os = "windows")]
diff --git a/crates/biome_js_analyze/src/assist/source/use_sorted_attributes.rs b/crates/biome_js_analyze/src/assist/source/use_sorted_attributes.rs
index cd4f566b7ba6..b18a84b801a0 100644
--- a/crates/biome_js_analyze/src/assist/source/use_sorted_attributes.rs
+++ b/crates/biome_js_analyze/src/assist/source/use_sorted_attributes.rs
@@ -71,6 +71,22 @@ declare_source_rule! {
     /// <Hello tel={5555555} {...this.props} opt1="John" opt2="" opt12="" opt11="" />;
     /// ```
     ///
+    /// ### `sortFirst`
+    /// A list of attribute names that should be sorted before all other attributes,
+    /// in the order they appear in this list. The remaining attributes are sorted
+    /// after the listed ones. This is useful to keep attributes such as `key` first.
+    ///
+    /// ```json,options
+    /// {
+    ///     "options": {
+    ///         "sortFirst": ["key"]
+    ///     }
+    /// }
+    /// ```
+    /// ```jsx,use_options,expect_diagnostic
+    /// <Hello firstName="John" key={id} lastName="Smith" />;
+    /// ```
+    ///
     pub UseSortedAttributes {
         version: "2.0.0",
         name: "useSortedAttributes",
@@ -93,12 +109,17 @@ impl Rule for UseSortedAttributes {
         let mut prop_groups = Vec::new();
         let options = ctx.options();
         let sort_by = options.sort_order.unwrap_or_default();
+        let sort_first = options.sort_first.as_deref().unwrap_or_default();
 
-        let comparator = match sort_by {
+        let base = match sort_by {
             SortOrder::Natural => SortableJsxAttribute::ascii_nat_cmp,
             SortOrder::Lexicographic => SortableJsxAttribute::lexicographic_cmp,
         };
 
+        let comparator = |a: &SortableJsxAttribute, b: &SortableJsxAttribute| {
+            a.cmp_sort_first(b, sort_first, base)
+        };
+
         // Convert to boolean-based comparator for is_sorted_by
         let boolean_comparator = |a: &SortableJsxAttribute, b: &SortableJsxAttribute| {
             comparator(a, b) != Ordering::Greater
@@ -156,12 +177,17 @@ impl Rule for UseSortedAttributes {
         let mut mutation = ctx.root().begin();
         let options = ctx.options();
         let sort_by = options.sort_order.unwrap_or_default();
+        let sort_first = options.sort_first.as_deref().unwrap_or_default();
 
-        let comparator = match sort_by {
+        let base = match sort_by {
             SortOrder::Natural => SortableJsxAttribute::ascii_nat_cmp,
             SortOrder::Lexicographic => SortableJsxAttribute::lexicographic_cmp,
         };
 
+        let comparator = |a: &SortableJsxAttribute, b: &SortableJsxAttribute| {
+            a.cmp_sort_first(b, sort_first, base)
+        };
+
         for (SortableJsxAttribute(attr), SortableJsxAttribute(sorted_attr)) in
             zip(state.attrs.iter(), state.get_sorted_attributes(comparator)?)
         {
diff --git a/crates/biome_js_analyze/src/assist/source/use_sorted_interface_members.rs b/crates/biome_js_analyze/src/assist/source/use_sorted_interface_members.rs
index 81a1bc703986..b87c65dde4d5 100644
--- a/crates/biome_js_analyze/src/assist/source/use_sorted_interface_members.rs
+++ b/crates/biome_js_analyze/src/assist/source/use_sorted_interface_members.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, cmp::Ordering, collections::HashSet};
 
 use biome_analyze::{
     Ast, FixKind, Rule, RuleAction, RuleDiagnostic, RuleSource, context::RuleContext,
@@ -7,12 +7,12 @@ use biome_analyze::{
 
 use biome_console::markup;
 use biome_js_syntax::{
-    AnyJsObjectMemberName, AnyTsTypeMember, TsInterfaceDeclaration, TsTypeMemberList,
+    AnyJsObjectMemberName, AnyTsTypeMember, JsLanguage, TsInterfaceDeclaration, TsTypeMemberList,
 };
 use biome_rule_options::use_sorted_interface_members::UseSortedInterfaceMembersOptions;
 
 use crate::JsRuleAction;
-use biome_rowan::{AstNode, AstNodeExt, AstNodeList, BatchMutationExt, TextRange};
+use biome_rowan::{AstNode, AstNodeExt, AstNodeList, BatchMutationExt, SyntaxTriviaPiece, TextRange};
 use biome_string_case::comparable_token::ComparableToken;
 declare_source_rule! {
     /// Sort interface members by key.
@@ -66,6 +66,40 @@ declare_source_rule! {
     /// }
     /// ```
     ///
+    /// ## Options
+    ///
+    /// ### `partitionByNewLine`
+    ///
+    /// When enabled, members separated by a blank line are kept in their own
+    /// section and sorted only within that section. This preserves logical
+    /// groupings that the author intentionally introduced with empty lines.
+    ///
+    /// > Default: `false`
+    ///
+    /// ```json,options
+    /// {
+    ///     "options": {
+    ///         "partitionByNewLine": true
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// With the option enabled, the following interface is considered sorted
+    /// because each section is sorted on its own:
+    ///
+    /// ```ts,use_options
+    /// interface User {
+    ///   id: string;
+    ///
+    ///   createdAt: Date;
+    ///   updatedAt: Date;
+    ///
+    ///   email: string;
+    ///   name: string;
+    ///   passwordHash: string;
+    /// }
+    /// ```
+    ///
     pub UseSortedInterfaceMembers {
         version: "2.4.0",
         name: "useSortedInterfaceMembers",
@@ -83,7 +117,8 @@ impl Rule for UseSortedInterfaceMembers {
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let interface = ctx.query();
         let body = interface.members();
-        if is_interface_members_sorted(&body, comparator) {
+        let partition_by_new_line = ctx.options().partition_by_new_line.unwrap_or_default();
+        if is_interface_members_sorted(&body, comparator, partition_by_new_line) {
             None
         } else {
             Some(())
@@ -106,12 +141,13 @@ impl Rule for UseSortedInterfaceMembers {
     fn action(ctx: &RuleContext<Self>, _state: &Self::State) -> Option<JsRuleAction> {
         let interface = ctx.query();
         let list = interface.members();
+        let partition_by_new_line = ctx.options().partition_by_new_line.unwrap_or_default();
         let mut mutation = ctx.root().begin();
 
         // Instead of rebuilding the entire list, replace individual members
         // that are in the wrong position. This preserves comments better.
         // If any token replacements fail, propagate None to skip the fix.
-        sort_interface_members_in_place(&list, comparator, &mut mutation)?;
+        sort_interface_members_in_place(&list, comparator, partition_by_new_line, &mut mutation)?;
 
         Some(RuleAction::new(
             rule_action_category!(),
@@ -135,15 +171,84 @@ fn get_type_member_name(member: &AnyTsTypeMember) -> Option<AnyJsObjectMemberNam
         _ => None,
     }
 }
+
+/// Returns true if `member`'s leading trivia contains a blank line.
+///
+/// A blank line is a pair of newlines optionally separated by whitespace
+/// pieces. Comments between newlines do not count as a blank line.
+fn has_blank_line_before(member: &AnyTsTypeMember) -> bool {
+    let Some(first_token) = member.syntax().first_token() else {
+        return false;
+    };
+    let mut seen_newline = false;
+    for piece in first_token.leading_trivia().pieces() {
+        if piece.is_newline() {
+            if seen_newline {
+                return true;
+            }
+            seen_newline = true;
+        } else if !piece.is_whitespace() {
+            seen_newline = false;
+        }
+    }
+    false
+}
+
+/// Returns the index of the second newline of the last blank line in `pieces`.
+/// This is the boundary between "detached" (section-break) trivia and
+/// "attached" (member-attached) trivia.
+///
+/// Whitespace pieces between two newlines are ignored.
+fn find_last_blank_line_idx(pieces: &[SyntaxTriviaPiece<JsLanguage>]) -> Option<usize> {
+    let mut last = None;
+    let mut seen_newline = false;
+    for (i, piece) in pieces.iter().enumerate() {
+        if piece.is_newline() {
+            if seen_newline {
+                last = Some(i);
+            }
+            seen_newline = true;
+        } else if !piece.is_whitespace() {
+            seen_newline = false;
+        }
+    }
+    last
+}
+
+/// Returns the boundaries (start indices and trailing length sentinel) of
+/// sections in the given member list.
+///
+/// When `partition_by_new_line` is false, the returned vector contains just
+/// `[0, members.len()]` (a single section).
+fn compute_section_boundaries(members: &[AnyTsTypeMember], partition_by_new_line: bool) -> Vec<usize> {
+    let mut boundaries = vec![0_usize];
+    if partition_by_new_line {
+        // `skip(1)` as the first boundary is always 0 (the start of the list)
+        for (i, member) in members.iter().enumerate().skip(1) {
+            if has_blank_line_before(member) {
+                boundaries.push(i);
+            }
+        }
+    }
+    boundaries.push(members.len());
+    boundaries
+}
+
 fn is_interface_members_sorted(
     list: &TsTypeMemberList,
     comparator: impl Fn(&ComparableToken, &ComparableToken) -> std::cmp::Ordering,
+    partition_by_new_line: bool,
 ) -> bool {
-    use std::cmp::Ordering;
     let mut prev_key: Option<ComparableToken> = None;
     let mut saw_non_sortable = false;
 
-    for member in list.iter() {
+    for (i, member) in list.iter().enumerate() {
+        if partition_by_new_line && i > 0 && has_blank_line_before(&member) {
+            // New section: reset state.
+            prev_key = None;
+            saw_non_sortable = false;
+        }
+
         if let Some(name) = get_type_member_name(&member)
             && let Some(token_text) = name.name()
         {
@@ -174,89 +279,119 @@ fn is_interface_members_sorted(
 fn sort_interface_members_in_place(
     list: &TsTypeMemberList,
     comparator: impl Fn(&ComparableToken, &ComparableToken) -> std::cmp::Ordering,
+    partition_by_new_line: bool,
     mutation: &mut biome_rowan::BatchMutation<biome_js_syntax::JsLanguage>,
 ) -> Option<()> {
-    // Collect current members with their trivia
-    let members_with_trivia: Vec<_> = list
-        .iter()
-        .map(|member| {
-            let syntax = member.syntax();
-            let leading_trivia: Vec<_> = syntax
-                .first_token()
-                .map(|token| token.leading_trivia().pieces().collect())
-                .unwrap_or_default();
-            let trailing_trivia: Vec<_> = syntax
-                .last_token()
-                .map(|token| token.trailing_trivia().pieces().collect())
-                .unwrap_or_default();
-
-            (member, leading_trivia, trailing_trivia)
-        })
-        .collect();
+    let members: Vec<_> = list.iter().collect();
+    let section_boundaries = compute_section_boundaries(&members, partition_by_new_line);
 
-    // Separate sortable from non-sortable members
-    let mut sortable_indices = Vec::new();
-    let mut non_sortable_indices = Vec::new();
+    // For each section, compute the expected order:
+    // sortable members sorted alphabetically, followed by non-sortable members
+    // in their original order.
+    let mut expected_indices = Vec::with_capacity(members.len());
+    for &[start, end] in section_boundaries.array_windows::<2>() {
+        let mut sortable = Vec::new();
+        let mut non_sortable = Vec::new();
 
-    for (index, (member, _, _)) in members_with_trivia.iter().enumerate() {
-        if let Some(name) = get_type_member_name(member)
-            && name.name().is_some()
-        {
-            sortable_indices.push(index);
-        } else {
-            non_sortable_indices.push(index);
+        for (idx, member) in members.iter().enumerate().take(end).skip(start) {
+            if let Some(name) = get_type_member_name(member)
+                && name.name().is_some()
+            {
+                sortable.push(idx);
+            } else {
+                non_sortable.push(idx);
+            }
         }
+
+        sortable.sort_by(|&a, &b| {
+            let key_a = get_type_member_name(&members[a])
+                .and_then(|name| name.name())
+                .map(ComparableToken::new);
+            let key_b = get_type_member_name(&members[b])
+                .and_then(|name| name.name())
+                .map(ComparableToken::new);
+
+            match (key_a, key_b) {
+                (Some(a), Some(b)) => comparator(&a, &b),
+                _ => std::cmp::Ordering::Equal,
+            }
+        });
+
+        expected_indices.extend(sortable);
+        expected_indices.extend(non_sortable);
     }
 
-    // Sort the sortable members by their keys
-    sortable_indices.sort_by(|&a, &b| {
-        let (member_a, _, _) = &members_with_trivia[a];
-        let (member_b, _, _) = &members_with_trivia[b];
-
-        let key_a = get_type_member_name(member_a)
-            .and_then(|name| name.name())
-            .map(ComparableToken::new);
-        let key_b = get_type_member_name(member_b)
-            .and_then(|name| name.name())
-            .map(ComparableToken::new);
-
-        match (key_a, key_b) {
-            (Some(a), Some(b)) => comparator(&a, &b),
-            _ => std::cmp::Ordering::Equal,
-        }
-    });
-
-    // Collect current members in order
-    // Build the expected order: sortable first, then everything else
-    let current_members: Vec<_> = list.iter().collect();
-    let expected_indices: Vec<_> = sortable_indices
-        .into_iter()
-        .chain(non_sortable_indices)
+    // Positions (other than 0) that begin a new section. At these positions
+    // the blank line of the original section start must be preserved, while
+    // the moving member should contribute only its attached trivia.
+    let section_start_positions: HashSet<_> = section_boundaries
+        .iter()
+        .copied()
+        .filter(|&i| i > 0 && i < members.len())
         .collect();
 
-    // Replace each member that's in the wrong position
-    for (current_index, current_member) in current_members.iter().enumerate() {
+    for (current_index, current_member) in members.iter().enumerate() {
         let expected_index = expected_indices[current_index];
 
-        if current_index != expected_index {
-            let (expected_member, leading, trailing) = &members_with_trivia[expected_index];
-            let mut new_member = expected_member.clone();
+        if current_index == expected_index {
+            continue;
+        }
 
-            if let Some(first_token) = new_member.syntax().first_token() {
-                let new_first = first_token
-                    .with_leading_trivia(leading.iter().map(|piece| (piece.kind(), piece.text())));
-                new_member =
-                    new_member.replace_token_discard_trivia(first_token.clone(), new_first)?;
-            }
-            if let Some(last_token) = new_member.syntax().last_token() {
-                let new_last = last_token.with_trailing_trivia_pieces(trailing.iter().cloned());
-                new_member =
-                    new_member.replace_token_discard_trivia(last_token.clone(), new_last)?;
+        let expected_member = &members[expected_index];
+
+        let expected_leading: Vec<_> = expected_member
+            .syntax()
+            .first_token()
+            .map(|token| token.leading_trivia().pieces().collect())
+            .unwrap_or_default();
+        let expected_trailing: Vec<_> = expected_member
+            .syntax()
+            .last_token()
+            .map(|token| token.trailing_trivia().pieces().collect())
+            .unwrap_or_default();
+
+        // Build the new leading trivia for the expected member at this position.
+        let new_leading = if partition_by_new_line {
+            // The expected member's attached trivia (everything after its
+            // own last blank line, if any).
+            let attached_start = find_last_blank_line_idx(&expected_leading).unwrap_or(0);
+            let attached_iter = expected_leading.iter().skip(attached_start).cloned();
+
+            if section_start_positions.contains(&current_index) {
+                // Preserve the section break (blank line + any preceding
+                // detached trivia) from the original member at this position.
+                let current_leading: Vec<_> = current_member
+                    .syntax()
+                    .first_token()
+                    .map(|token| token.leading_trivia().pieces().collect())
+                    .unwrap_or_default();
+                let detached_end = find_last_blank_line_idx(&current_leading).unwrap_or(0);
+                current_leading
+                    .iter()
+                    .take(detached_end)
+                    .cloned()
+                    .chain(attached_iter)
+                    .collect()
+            } else {
+                attached_iter.collect()
             }
+        } else {
+            expected_leading.clone()
+        };
 
-            // Use replace_node_discard_trivia to avoid transferring trivia from current_member
-            mutation.replace_node_discard_trivia(current_member.clone(), new_member);
+        let mut new_member = expected_member.clone();
+
+        if let Some(first_token) = new_member.syntax().first_token() {
+            let new_first = first_token.with_leading_trivia_pieces(new_leading.iter().cloned());
+            new_member = new_member.replace_token_discard_trivia(first_token.clone(), new_first)?;
+        }
+        if let Some(last_token) = new_member.syntax().last_token() {
+            let new_last = last_token.with_trailing_trivia_pieces(expected_trailing.iter().cloned());
+            new_member = new_member.replace_token_discard_trivia(last_token.clone(), new_last)?;
         }
+
+        // Use replace_node_discard_trivia to avoid transferring trivia from current_member
+        mutation.replace_node_discard_trivia(current_member.clone(), new_member);
     }
 
     Some(())
diff --git a/crates/biome_js_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs b/crates/biome_js_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
index e54b4403146a..0dd4693209a2 100644
--- a/crates/biome_js_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
+++ b/crates/biome_js_analyze/src/lint/nursery/no_tailwind_arbitrary_value.rs
@@ -1,13 +1,12 @@
-use crate::shared::any_class_string_like::AnyClassStringLike;
+use crate::tailwind::{AnyTailwindClassString, host_range};
 use biome_analyze::{
-    Ast, Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,
+    Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,
 };
 use biome_console::markup;
-use biome_js_syntax::JsSyntaxKind;
-use biome_rowan::{TextRange, TextSize, TokenText};
+use biome_rowan::TextRange;
 use biome_rule_options::no_tailwind_arbitrary_value::NoTailwindArbitraryValueOptions;
-use biome_tailwind_parser::parse_tailwind;
-use biome_tailwind_syntax::lint_utils::arbitrary_ranges;
+use biome_tailwind_logic::no_tailwind_arbitrary_value::analyze_tailwind_arbitrary_values;
+use biome_tailwind_logic::syntax_service::TailwindSyntax;
 
 declare_lint_rule! {
     /// Disallow arbitrary values in Tailwind CSS utility classes.
@@ -43,37 +42,21 @@ declare_lint_rule! {
     /// <div className="[&:nth-child(3)]:px-2" />;
     /// ```
     ///
-    /// ## Options
+    /// ## Tailwind configuration
     ///
-    /// By default, this rule checks the `class` and `className` JSX attributes.
-    /// The `attributes` option adds more JSX attributes to check, and `functions`
-    /// enables checking string arguments and tagged templates in matching utilities.
+    /// Use the top-level `tailwind` configuration to control which attributes,
+    /// functions, and tagged templates contain Tailwind classes. Specified arrays
+    /// replace the defaults.
     ///
-    /// ```json,options
+    /// ```json
     /// {
-    ///     "options": {
-    ///         "attributes": ["classList"],
-    ///         "functions": ["clsx"]
+    ///     "tailwind": {
+    ///         "attributes": ["class", "className", "classList"],
+    ///         "functions": ["clsx", "tw"]
     ///     }
     /// }
     /// ```
     ///
-    /// ### attributes
-    ///
-    /// Additional JSX attribute names to check.
-    ///
-    /// Default: `[]` (the `class` and `className` attributes are always checked).
-    ///
-    /// ### functions
-    ///
-    /// Function or tagged template names whose classes will be checked for arbitrary values.
-    ///
-    /// Default: `[]`.
-    ///
-    /// ```jsx,use_options,expect_diagnostic
-    /// <div className={clsx("w-[400px]")} />;
-    /// ```
-    ///
     pub NoTailwindArbitraryValue {
         version: "2.5.7",
         name: "noTailwindArbitraryValue",
@@ -85,38 +68,20 @@ declare_lint_rule! {
 }
 
 impl Rule for NoTailwindArbitraryValue {
-    type Query = Ast<AnyClassStringLike>;
+    type Query = TailwindSyntax<AnyTailwindClassString>;
     type State = TextRange;
     type Signals = Vec<TextRange>;
     type Options = NoTailwindArbitraryValueOptions;
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
-        let node = ctx.query();
-
-        let Some(source) = class_string_source(node) else {
-            return vec![];
-        };
-
-        // Arbitrary values and properties always contain `[`. This cheap check
-        // runs before `should_visit`, whose ancestor walk would otherwise execute
-        // for every string literal in the file, not just class strings.
-        if !source.text.text().contains('[') {
-            return vec![];
-        }
-
-        if node.should_visit(ctx.options()).is_none() {
-            return vec![];
-        }
-
-        let parse = parse_tailwind(source.text.text());
-        arbitrary_ranges(&parse.tree().candidates(), source.content_start)
+        analyze_tailwind_arbitrary_values(&ctx.query().tailwind_root().candidates())
     }
 
-    fn diagnostic(_ctx: &RuleContext<Self>, range: &Self::State) -> Option<RuleDiagnostic> {
+    fn diagnostic(ctx: &RuleContext<Self>, range: &Self::State) -> Option<RuleDiagnostic> {
         Some(
             RuleDiagnostic::new(
                 rule_category!(),
-                range,
+                host_range(ctx.query().node(), *range)?,
                 markup! { "Found an arbitrary value in a Tailwind CSS class." },
             )
             .note(markup! {
@@ -128,47 +93,3 @@ impl Rule for NoTailwindArbitraryValue {
         )
     }
 }
-
-struct ClassStringSource {
-    text: TokenText,
-    content_start: TextSize,
-}
-
-fn class_string_source(node: &AnyClassStringLike) -> Option<ClassStringSource> {
-    match node {
-        AnyClassStringLike::JsxString(jsx_string) => {
-            let token = jsx_string.value_token().ok()?;
-            Some(ClassStringSource {
-                text: jsx_string.inner_string_text().ok()?,
-                content_start: token.text_trimmed_range().start() + TextSize::from(1),
-            })
-        }
-        AnyClassStringLike::JsStringLiteralExpression(string_literal) => {
-            let token = string_literal.value_token().ok()?;
-            Some(ClassStringSource {
-                text: string_literal.inner_string_text().ok()?,
-                content_start: token.text_trimmed_range().start() + TextSize::from(1),
-            })
-        }
-        AnyClassStringLike::JsTemplateChunkElement(chunk) => {
-            let token = chunk.template_chunk_token().ok()?;
-            Some(ClassStringSource {
-                text: token.token_text(),
-                content_start: token.text_trimmed_range().start(),
-            })
-        }
-        AnyClassStringLike::JsLiteralMemberName(member_name) => {
-            let token = member_name.value().ok()?;
-            let quote_offset = if token.kind() == JsSyntaxKind::JS_STRING_LITERAL {
-                TextSize::from(1)
-            } else {
-                TextSize::from(0)
-            };
-
-            Some(ClassStringSource {
-                text: member_name.name().ok()?,
-                content_start: token.text_trimmed_range().start() + quote_offset,
-            })
-        }
-    }
-}
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes.rs b/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes.rs
index 22f4fc23075e..5880b2a8a0f4 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes.rs
+++ b/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes.rs
@@ -1,21 +1,14 @@
-mod class_info;
-pub mod class_lexer;
-mod presets;
+mod arbitrary_value_match;
 mod sort;
-mod sort_config;
 pub mod sort_v4;
 mod sort_v4_variants;
-mod tailwind_preset;
 mod tailwind_preset_v4;
 mod tailwind_preset_v4_types;
-mod arbitrary_value_match;
 
-use self::{
-    presets::UseSortedClassesPreset, sort::get_sort_class_name_range, sort::sort_class_name,
-    sort_config::SortConfig,
-};
+use self::sort::{get_sort_class_name_range, sort_class_name};
 use crate::JsRuleAction;
 use crate::shared::any_class_string_like::AnyClassStringLike;
+use biome_analyze::shared::sorted_classes::sort_config::DEFAULT_SORT_CONFIG;
 use biome_analyze::{Ast, FixKind, Rule, RuleDiagnostic, context::RuleContext, declare_lint_rule};
 use biome_console::markup;
 use biome_js_factory::make::{
@@ -24,8 +17,6 @@ use biome_js_factory::make::{
 };
 use biome_rowan::{AstNode, BatchMutationExt};
 use biome_rule_options::use_sorted_classes::UseSortedClassesOptions;
-use presets::get_config_preset;
-use std::sync::LazyLock;
 
 declare_lint_rule! {
     /// Enforce the sorting of CSS utility classes.
@@ -164,9 +155,6 @@ declare_lint_rule! {
     }
 }
 
-static SORT_CONFIG: LazyLock<SortConfig> =
-    LazyLock::new(|| SortConfig::new(&get_config_preset(&UseSortedClassesPreset::default())));
-
 impl Rule for UseSortedClasses {
     type Query = Ast<AnyClassStringLike>;
     type State = Box<str>;
@@ -181,7 +169,7 @@ impl Rule for UseSortedClasses {
             && let Some(value) = node.value()
         {
             let template_ctx = sort::get_template_literal_space_context(node);
-            let sorted_value: String = sort_class_name(&value, &SORT_CONFIG, &template_ctx);
+            let sorted_value: String = sort_class_name(&value, &DEFAULT_SORT_CONFIG, &template_ctx);
             if sorted_value.is_empty() {
                 return None;
             }
@@ -218,7 +206,9 @@ impl Rule for UseSortedClasses {
             AnyClassStringLike::JsStringLiteralExpression(string_literal) => {
                 let is_double_quote = string_literal
                     .value_token()
-                    .map_or(ctx.preferred_quote().is_double(), |token| token.text_trimmed().starts_with('"'));
+                    .map_or(ctx.preferred_quote().is_double(), |token| {
+                        token.text_trimmed().starts_with('"')
+                    });
                 let replacement = js_string_literal_expression(if is_double_quote {
                     js_string_literal(state)
                 } else {
@@ -237,7 +227,9 @@ impl Rule for UseSortedClasses {
             AnyClassStringLike::JsxString(jsx_string_node) => {
                 let is_double_quote = jsx_string_node
                     .value_token()
-                    .map_or(ctx.preferred_jsx_quote().is_double(), |token| token.text_trimmed().starts_with('"'));
+                    .map_or(ctx.preferred_jsx_quote().is_double(), |token| {
+                        token.text_trimmed().starts_with('"')
+                    });
                 let replacement = jsx_string(if is_double_quote {
                     js_string_literal(state)
                 } else {
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort.rs b/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort.rs
index a24ffe7a5462..0fae672fd0d3 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort.rs
+++ b/crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/sort.rs
@@ -1,132 +1,10 @@
+use biome_analyze::shared::sorted_classes::sort as shared_sort;
 use biome_js_syntax::{JsTemplateChunkElement, JsTemplateElement};
 use biome_rowan::{AstNode, TextRange, TextSize, TokenText};
-use std::cmp::Ordering;
 
-use super::{
-    class_info::{ClassInfo, get_class_info},
-    sort_config::SortConfig,
-};
+use biome_analyze::shared::sorted_classes::sort_config::SortConfig;
 use crate::shared::any_class_string_like::AnyClassStringLike;
 
-impl ClassInfo {
-    /// Compare based on the existence of variants. Classes with variants go last.
-    /// Returns `None` if both or none of the classes has variants.
-    fn cmp_variants_weight_existence(&self, other: &Self) -> Option<Ordering> {
-        match (&self.variant_weight, &other.variant_weight) {
-            (Some(_), Some(_)) => None,
-            (Some(_), _) => Some(Ordering::Greater),
-            (_, Some(_)) => Some(Ordering::Less),
-            (None, None) => None,
-        }
-    }
-
-    /// Compare based on layer indexes. Classes with lower indexes go first.
-    /// Returns `None` if the indexes are equal.
-    fn cmp_layers(&self, other: &Self) -> Option<Ordering> {
-        let result = self.layer_index.cmp(&other.layer_index);
-        if result != Ordering::Equal {
-            return Some(result);
-        }
-        None
-    }
-
-    /// Compare based on variants weight. Classes with lower weight go first.
-    /// First compare variants weight length. Only if their equal compare their actual weight.
-    /// Returns `None` if they have the same weight.
-    fn cmp_variants_weight(&self, other: &Self) -> Option<Ordering> {
-        let current_weight = self.variant_weight.as_ref()?;
-        let other_weight = other.variant_weight.as_ref()?;
-
-        let mut result = current_weight.len().cmp(&other_weight.len());
-        if result == Ordering::Equal {
-            result = current_weight.cmp(other_weight);
-        }
-
-        if result != Ordering::Equal {
-            return Some(result);
-        }
-        None
-    }
-
-    /// Compare based on the existence of arbitrary variants. Classes with arbitrary variants go last.
-    /// Returns `None` if both or none of the classes has arbitrary variants.
-    fn cmp_arbitrary_variants_existence(&self, other: &Self) -> Option<Ordering> {
-        match (&self.arbitrary_variants, &other.arbitrary_variants) {
-            (Some(_), Some(_)) => None,
-            (Some(_), _) => Some(Ordering::Greater),
-            (_, Some(_)) => Some(Ordering::Less),
-            (None, None) => None,
-        }
-    }
-
-    /// Compare arbitrary variants based on their length and then lexicographically
-    fn cmp_arbitrary_variants(&self, other: &Self) -> Option<Ordering> {
-        let a = self.arbitrary_variants.as_ref()?;
-        let b = other.arbitrary_variants.as_ref()?;
-
-        let mut result = a.len().cmp(&b.len());
-        if result == Ordering::Equal {
-            result = a.cmp(b);
-        }
-
-        if result != Ordering::Equal {
-            return Some(result);
-        }
-        None
-    }
-
-    /// Compare based on utility index. Classes with lower indexes go first.
-    /// Returns `None` if the indexes are equal.
-    fn cmp_utilities(&self, other: &Self) -> Option<Ordering> {
-        let result = self.utility_index.cmp(&other.utility_index);
-        if result != Ordering::Equal {
-            return Some(result);
-        }
-        None
-    }
-}
-
-// TODO: implement through Ord/PartialOrd trait.
-
-// See: https://github.com/tailwindlabs/tailwindcss/blob/970f2ca704dda95cf328addfe67b81d6679c8755/src/lib/offsets.js#L206
-// This comparison function follows a very similar logic to the one in Tailwind CSS, with some
-// simplifications and necessary differences.
-fn compare_classes(a: &ClassInfo, b: &ClassInfo) -> Ordering {
-    // Classes with arbitrary variants go last
-    if let Some(has_arbitrary_variants) = a.cmp_arbitrary_variants_existence(b) {
-        return has_arbitrary_variants;
-    }
-
-    // Compare arbitrary variants
-    if let Some(arbitrary_variants_order) = a.cmp_arbitrary_variants(b) {
-        return arbitrary_variants_order;
-    }
-
-    // Classes with variants go last.
-    if let Some(has_variants_order) = a.cmp_variants_weight_existence(b) {
-        return has_variants_order;
-    }
-
-    // Compare utility layers.
-    if let Some(layers_order) = a.cmp_layers(b) {
-        return layers_order;
-    }
-
-    // TODO: sort screens at this point.
-
-    // Compare variant weights.
-    if let Some(variants_weight_order) = a.cmp_variants_weight(b) {
-        return variants_weight_order;
-    }
-
-    // Compare utility indexes.
-    if let Some(utilities_order) = a.cmp_utilities(b) {
-        return utilities_order;
-    }
-
-    Ordering::Equal
-}
-
 /// Sort the given class string according to the given sort config.
 pub fn sort_class_name(
     class_name: &TokenText,
@@ -152,49 +30,20 @@ pub fn sort_class_name(
 
     // Collect the remaining classes into a vector if needed.
     let classes: Vec<&str> = classes_iter.collect();
+    let sorted_value = shared_sort::sort_class_name_from_slice(&classes, sort_config);
 
-    // Separate custom classes from recognized classes, and compute the recognized classes' info.
-    // Custom classes always go first, in the order that they appear in.
-    let mut sorted_classes = Vec::new();
-    let mut classes_info = Vec::new();
-    for class in classes {
-        match get_class_info(class, sort_config) {
-            Some(class_info) => {
-                classes_info.push(class_info);
-            }
-            None => {
-                sorted_classes.push(class);
-            }
-        }
-    }
-
-    // TODO: make this the last step of compare instead?
-
-    // Pre-sort the recognized classes lexico-graphically.
-    classes_info.sort_unstable_by(|a, b| a.text.cmp(&b.text));
-
-    // Sort recognized classes using the compare function. Needs to be a stable sort to
-    // preserve the lexico-graphical order as a fallback.
-    classes_info.sort_by(compare_classes);
-
-    // Add the sorted classes to the result.
-    sorted_classes.extend(
-        classes_info
-            .iter()
-            .map(|class_info| class_info.text.as_ref()),
-    );
+    let mut parts: Vec<&str> = sorted_value.split_whitespace().collect();
 
     // Add the first class back if it was ignored.
     if let Some(class_str_prefix) = class_str_prefix {
-        sorted_classes.insert(0, class_str_prefix);
+        parts.insert(0, class_str_prefix);
     }
-
     // Add the last class back if it was ignored.
     if let Some(class_str_postfix) = class_str_postfix {
-        sorted_classes.push(class_str_postfix);
+        parts.push(class_str_postfix);
     }
 
-    let mut result = sorted_classes.join(" ");
+    let mut result = parts.join(" ");
 
     // Edge space handling for template literals only
     if let Some(ctx) = template_literal_space_context {
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs b/crates/biome_js_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
index de8ec4d5c752..48ccd98d04ef 100644
--- a/crates/biome_js_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
+++ b/crates/biome_js_analyze/src/lint/nursery/use_tailwind_shorthand_classes.rs
@@ -61,6 +61,17 @@ declare_lint_rule! {
     /// - `ctl`
     ///
     /// Tagged template members like `tw.div` are also checked when their base function name is recognized.
+    /// Configure the recognized attributes and functions with the top-level `tailwind` configuration.
+    /// Specified arrays replace the defaults.
+    ///
+    /// ```json
+    /// {
+    ///     "tailwind": {
+    ///         "attributes": ["class", "className", "classList"],
+    ///         "functions": ["clsx", "tw"]
+    ///     }
+    /// }
+    /// ```
     ///
     /// ## Known limitations
     ///
diff --git a/crates/biome_js_analyze/src/shared/any_class_string_like.rs b/crates/biome_js_analyze/src/shared/any_class_string_like.rs
index 6b8cdae59b56..96b8de474a11 100644
--- a/crates/biome_js_analyze/src/shared/any_class_string_like.rs
+++ b/crates/biome_js_analyze/src/shared/any_class_string_like.rs
@@ -4,6 +4,7 @@
 //! various AST nodes that can contain CSS class strings (string literals,
 //! JSX strings, template chunks, etc.).
 
+use biome_analyze::options::TailwindOptions;
 use biome_js_syntax::{
     AnyJsExpression, JsCallArguments, JsCallExpression, JsLiteralMemberName,
     JsStringLiteralExpression, JsSyntaxNode, JsTemplateChunkElement, JsTemplateExpression,
@@ -11,7 +12,6 @@ use biome_js_syntax::{
 };
 use biome_rowan::{AstNode, TokenText, declare_node_union};
 use biome_rule_options::no_duplicate_classes::NoDuplicateClassesOptions;
-use biome_rule_options::no_tailwind_arbitrary_value::NoTailwindArbitraryValueOptions;
 use biome_rule_options::use_sorted_classes::UseSortedClassesOptions;
 use biome_tailwind_logic::syntax_service::{TailwindClassString, TailwindClassStringHost};
 
@@ -46,36 +46,13 @@ impl ClassStringOptions for NoDuplicateClassesOptions {
     }
 }
 
-const CLASS_ATTRIBUTES: [&str; 2] = ["class", "className"];
-
-impl ClassStringOptions for NoTailwindArbitraryValueOptions {
-    fn has_attribute(&self, name: &str) -> bool {
-        CLASS_ATTRIBUTES.contains(&name)
-            || self.attributes.iter().flatten().any(|v| v.as_ref() == name)
-    }
-    fn has_function(&self, name: &str) -> bool {
-        self.functions.iter().flatten().any(|v| v.as_ref() == name)
-    }
-    fn match_function(&self, name: &str) -> bool {
-        self.functions.iter().flatten().any(|matcher| {
-            let mut matcher_parts = matcher.split('.');
-            let mut name_parts = name.split('.');
-            let all_parts_match = matcher_parts
-                .by_ref()
-                .zip(name_parts.by_ref())
-                .all(|(m, p)| m == "*" || m == p);
-            all_parts_match && matcher_parts.next().is_none() && name_parts.next().is_none()
-        })
-    }
-}
-
 impl TailwindClassStringHost for AnyClassStringLike {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
         match self {
-            Self::JsStringLiteralExpression(node) => node.tailwind_class_string(),
-            Self::JsxString(node) => node.tailwind_class_string(),
-            Self::JsTemplateChunkElement(node) => node.tailwind_class_string(),
-            Self::JsLiteralMemberName(node) => node.tailwind_class_string(),
+            Self::JsStringLiteralExpression(node) => node.tailwind_class_string(options),
+            Self::JsxString(node) => node.tailwind_class_string(options),
+            Self::JsTemplateChunkElement(node) => node.tailwind_class_string(options),
+            Self::JsLiteralMemberName(node) => node.tailwind_class_string(options),
         }
     }
 }
diff --git a/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid_functions.options.json b/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid_functions.options.json
index 6a1ffb39b54c..efb09369af89 100644
--- a/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid_functions.options.json
+++ b/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/invalid_functions.options.json
@@ -1,14 +1,12 @@
 {
 	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"tailwind": {
+		"functions": ["clsx", "cn", "classnames", "tw"]
+	},
 	"linter": {
 		"rules": {
 			"nursery": {
-				"noTailwindArbitraryValue": {
-					"level": "error",
-					"options": {
-						"functions": ["clsx", "cn", "classnames", "tw", "tw.*"]
-					}
-				}
+				"noTailwindArbitraryValue": "error"
 			}
 		}
 	}
diff --git a/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/valid_functions.options.json b/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/valid_functions.options.json
index 6a1ffb39b54c..efb09369af89 100644
--- a/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/valid_functions.options.json
+++ b/crates/biome_js_analyze/tests/specs/nursery/noTailwindArbitraryValue/valid_functions.options.json
@@ -1,14 +1,12 @@
 {
 	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"tailwind": {
+		"functions": ["clsx", "cn", "classnames", "tw"]
+	},
 	"linter": {
 		"rules": {
 			"nursery": {
-				"noTailwindArbitraryValue": {
-					"level": "error",
-					"options": {
-						"functions": ["clsx", "cn", "classnames", "tw", "tw.*"]
-					}
-				}
+				"noTailwindArbitraryValue": "error"
 			}
 		}
 	}
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx
index 5bdbd14bd900..019e9ce2b9ca 100644
--- a/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx
+++ b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx
@@ -1,3 +1,6 @@
-const button = cn("px-2 py-2");
+/* should generate diagnostics */
+const button = cx("px-2 py-2");
 
 const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+
+const spaced = tw /* comment */ .div`px-2 py-2`;
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx.snap b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx.snap
index 7ca478ab493a..c33e4eb9ade0 100644
--- a/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx.snap
+++ b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.jsx.snap
@@ -4,29 +4,34 @@ expression: with-functions.jsx
 ---
 # Input
 ```jsx
-const button = cn("px-2 py-2");
+/* should generate diagnostics */
+const button = cx("px-2 py-2");
 
 const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
 
+const spaced = tw /* comment */ .div`px-2 py-2`;
+
 ```
 
 # Diagnostics
 ```
-with-functions.jsx:1:20 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━
+with-functions.jsx:2:20 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━
 
   i These Tailwind classes can be replaced with a shorthand class.
   
-  > 1 │ const button = cn("px-2 py-2");
+    1 │ /* should generate diagnostics */
+  > 2 │ const button = cx("px-2 py-2");
       │                    ^^^^
-    2 │ 
-    3 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    3 │ 
+    4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
   
   i Compressible utility used here.
   
-  > 1 │ const button = cn("px-2 py-2");
+    1 │ /* should generate diagnostics */
+  > 2 │ const button = cx("px-2 py-2");
       │                         ^^^^
-    2 │ 
-    3 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    3 │ 
+    4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
   
   i Using fewer classes reduces duplication and improves readability.
   
@@ -36,40 +41,81 @@ with-functions.jsx:1:20 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━
   
   i Unsafe fix: Use the Tailwind shorthand classes.
   
-    1   │ - const·button·=·cn("px-2·py-2");
-      1 │ + const·button·=·cn("p-2");
-    2 2 │   
-    3 3 │   const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    1 1 │   /* should generate diagnostics */
+    2   │ - const·button·=·cx("px-2·py-2");
+      2 │ + const·button·=·cx("p-2");
+    3 3 │   
+    4 4 │   const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
   
 
 ```
 
 ```
-with-functions.jsx:3:21 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━
+with-functions.jsx:4:21 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━
 
   i These Tailwind classes can be replaced with a shorthand class.
   
-    1 │ const button = cn("px-2 py-2");
-    2 │ 
-  > 3 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    2 │ const button = cx("px-2 py-2");
+    3 │ 
+  > 4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
       │                     ^^^^^^^^^^^^^^^
-    4 │ 
+    5 │ 
+    6 │ const spaced = tw /* comment */ .div`px-2 py-2`;
   
   i Compressible utility used here.
   
-    1 │ const button = cn("px-2 py-2");
-    2 │ 
-  > 3 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    2 │ const button = cx("px-2 py-2");
+    3 │ 
+  > 4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
       │                                     ^^^^^^^^^^^^^
-    4 │ 
+    5 │ 
+    6 │ const spaced = tw /* comment */ .div`px-2 py-2`;
   
   i Compressible utility used here.
   
-    1 │ const button = cn("px-2 py-2");
-    2 │ 
-  > 3 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    2 │ const button = cx("px-2 py-2");
+    3 │ 
+  > 4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
       │                                                   ^^^^^^^^^^^^^^^^^
-    4 │ 
+    5 │ 
+    6 │ const spaced = tw /* comment */ .div`px-2 py-2`;
+  
+  i Using fewer classes reduces duplication and improves readability.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/11342 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+  i Unsafe fix: Use the Tailwind shorthand classes.
+  
+    2 2 │   const button = cx("px-2 py-2");
+    3 3 │   
+    4   │ - const·card·=·tw.div`overflow-hidden·text-ellipsis·whitespace-nowrap`;
+      4 │ + const·card·=·tw.div`truncate`;
+    5 5 │   
+    6 6 │   const spaced = tw /* comment */ .div`px-2 py-2`;
+  
+
+```
+
+```
+with-functions.jsx:6:38 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i These Tailwind classes can be replaced with a shorthand class.
+  
+    4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    5 │ 
+  > 6 │ const spaced = tw /* comment */ .div`px-2 py-2`;
+      │                                      ^^^^
+    7 │ 
+  
+  i Compressible utility used here.
+  
+    4 │ const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    5 │ 
+  > 6 │ const spaced = tw /* comment */ .div`px-2 py-2`;
+      │                                           ^^^^
+    7 │ 
   
   i Using fewer classes reduces duplication and improves readability.
   
@@ -79,11 +125,11 @@ with-functions.jsx:3:21 lint/nursery/useTailwindShorthandClasses  FIXABLE  ━
   
   i Unsafe fix: Use the Tailwind shorthand classes.
   
-    1 1 │   const button = cn("px-2 py-2");
-    2 2 │   
-    3   │ - const·card·=·tw.div`overflow-hidden·text-ellipsis·whitespace-nowrap`;
-      3 │ + const·card·=·tw.div`truncate`;
-    4 4 │   
+    4 4 │   const card = tw.div`overflow-hidden text-ellipsis whitespace-nowrap`;
+    5 5 │   
+    6   │ - const·spaced·=·tw·/*·comment·*/·.div`px-2·py-2`;
+      6 │ + const·spaced·=·tw·/*·comment·*/·.div`p-2`;
+    7 7 │   
   
 
 ```
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.options.json b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.options.json
new file mode 100644
index 000000000000..3006a066bfc0
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/nursery/useTailwindShorthandClasses/with-functions.options.json
@@ -0,0 +1,13 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"tailwind": {
+		"functions": ["cx", "tw"]
+	},
+	"linter": {
+		"rules": {
+			"nursery": {
+				"useTailwindShorthandClasses": "error"
+			}
+		}
+	}
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx
new file mode 100644
index 000000000000..e94b64c0c822
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx
@@ -0,0 +1,6 @@
+/* should generate diagnostics */
+<Hello firstName="John" key={id} lastName="Smith" />;
+
+<Hello a="1" ref={r} key={id} b="2" />;
+
+<Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx.snap b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx.snap
new file mode 100644
index 000000000000..d785f1cc29f2
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.jsx.snap
@@ -0,0 +1,105 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.jsx
+---
+# Input
+```jsx
+/* should generate diagnostics */
+<Hello firstName="John" key={id} lastName="Smith" />;
+
+<Hello a="1" ref={r} key={id} b="2" />;
+
+<Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
+
+```
+
+# Diagnostics
+```
+invalid.jsx:2:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted. 
+  
+    1 │ /* should generate diagnostics */
+  > 2 │ <Hello firstName="John" key={id} lastName="Smith" />;
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    3 │ 
+    4 │ <Hello a="1" ref={r} key={id} b="2" />;
+  
+  i Safe fix: Sort the JSX props.
+  
+    1 1 │   /* should generate diagnostics */
+    2   │ - <Hello·firstName="John"·key={id}·lastName="Smith"·/>;
+      2 │ + <Hello·key={id}·firstName="John"·lastName="Smith"·/>;
+    3 3 │   
+    4 4 │   <Hello a="1" ref={r} key={id} b="2" />;
+  
+
+```
+
+```
+invalid.jsx:4:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted. 
+  
+    2 │ <Hello firstName="John" key={id} lastName="Smith" />;
+    3 │ 
+  > 4 │ <Hello a="1" ref={r} key={id} b="2" />;
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    5 │ 
+    6 │ <Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
+  
+  i Safe fix: Sort the JSX props.
+  
+    2 2 │   <Hello firstName="John" key={id} lastName="Smith" />;
+    3 3 │   
+    4   │ - <Hello·a="1"·ref={r}·key={id}·b="2"·/>;
+      4 │ + <Hello·key={id}·ref={r}·a="1"·b="2"·/>;
+    5 5 │   
+    6 6 │   <Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
+  
+
+```
+
+```
+invalid.jsx:6:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted. 
+  
+    4 │ <Hello a="1" ref={r} key={id} b="2" />;
+    5 │ 
+  > 6 │ <Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    7 │ 
+  
+  i Safe fix: Sort the JSX props.
+  
+    4 4 │   <Hello a="1" ref={r} key={id} b="2" />;
+    5 5 │   
+    6   │ - <Hello·a="1"·key={id}·{...props}·z="2"·key={id2}·b="3"·/>;
+      6 │ + <Hello·a="1"·key={id}·{...props}·key={id2}·b="3"·z="2"·/>;
+    7 7 │   
+  
+
+```
+
+```
+invalid.jsx:6:1 assist/source/useSortedAttributes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The attributes are not sorted. 
+  
+    4 │ <Hello a="1" ref={r} key={id} b="2" />;
+    5 │ 
+  > 6 │ <Hello a="1" key={id} {...props} z="2" key={id2} b="3" />;
+      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    7 │ 
+  
+  i Safe fix: Sort the JSX props.
+  
+    4 4 │   <Hello a="1" ref={r} key={id} b="2" />;
+    5 5 │   
+    6   │ - <Hello·a="1"·key={id}·{...props}·z="2"·key={id2}·b="3"·/>;
+      6 │ + <Hello·key={id}·a="1"·{...props}·z="2"·key={id2}·b="3"·/>;
+    7 7 │   
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.options.json
new file mode 100644
index 000000000000..dba8334b54cc
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/invalid.options.json
@@ -0,0 +1,15 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"assist": {
+		"actions": {
+			"source": {
+				"useSortedAttributes": {
+					"level": "on",
+					"options": {
+						"sortFirst": ["key", "ref"]
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx
new file mode 100644
index 000000000000..20a6a2fa76c2
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx
@@ -0,0 +1,3 @@
+/* should not generate diagnostics */
+<Hello key={id} ref={r} firstName="John" lastName="Smith" />;
+<Hello key={id} a="1" b="2" />;
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx.snap b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx.snap
new file mode 100644
index 000000000000..41f9229e9931
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.jsx.snap
@@ -0,0 +1,11 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: valid.jsx
+---
+# Input
+```jsx
+/* should not generate diagnostics */
+<Hello key={id} ref={r} firstName="John" lastName="Smith" />;
+<Hello key={id} a="1" b="2" />;
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.options.json
new file mode 100644
index 000000000000..dba8334b54cc
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedAttributes/valid.options.json
@@ -0,0 +1,15 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"assist": {
+		"actions": {
+			"source": {
+				"useSortedAttributes": {
+					"level": "on",
+					"options": {
+						"sortFirst": ["key", "ref"]
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts
new file mode 100644
index 000000000000..a654a25c55e8
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts
@@ -0,0 +1,5 @@
+interface Test {
+	z: string;
+	// a comment
+	a: string;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts.snap
new file mode 100644
index 000000000000..77b5b3e1e394
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_comment_not_a_section.ts.snap
@@ -0,0 +1,44 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_comment_not_a_section.ts
+---
+# Input
+```ts
+interface Test {
+	z: string;
+	// a comment
+	a: string;
+}
+
+```
+
+# Diagnostics
+```
+partition_by_new_line_comment_not_a_section.ts:1:1 assist/source/useSortedInterfaceMembers  FIXABLE  ━━━━━━━━━━
+
+  i The interface members are not sorted by key.
+  
+  > 1 │ interface Test {
+      │ ^^^^^^^^^^^^^^^^
+  > 2 │ 	z: string;
+  > 3 │ 	// a comment
+  > 4 │ 	a: string;
+  > 5 │ }
+      │ ^
+    6 │ 
+  
+  i Safe fix: Sort the interface members by key.
+  
+    1 1 │   interface Test {
+    2   │ - → z:·string;
+    3   │ - → //·a·comment
+    4   │ - → a:·string;
+      2 │ + → //·a·comment
+      3 │ + → a:·string;
+      4 │ + → z:·string;
+    5 5 │   }
+    6 6 │   
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts
new file mode 100644
index 000000000000..ed6154c19c35
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts
@@ -0,0 +1,6 @@
+interface Test {
+
+
+	z: string;
+	a: string;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts.snap
new file mode 100644
index 000000000000..7a87eace2371
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_leading_blank_lines.ts.snap
@@ -0,0 +1,46 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_leading_blank_lines.ts
+---
+# Input
+```ts
+interface Test {
+
+
+	z: string;
+	a: string;
+}
+
+```
+
+# Diagnostics
+```
+partition_by_new_line_leading_blank_lines.ts:1:1 assist/source/useSortedInterfaceMembers  FIXABLE  ━━━━━━━━━━
+
+  i The interface members are not sorted by key.
+  
+  > 1 │ interface Test {
+      │ ^^^^^^^^^^^^^^^^
+  > 2 │ 
+  > 3 │ 
+  > 4 │ 	z: string;
+  > 5 │ 	a: string;
+  > 6 │ }
+      │ ^
+    7 │ 
+  
+  i Safe fix: Sort the interface members by key.
+  
+    1 1 │   interface Test {
+    2   │ - 
+    3   │ - 
+    4   │ - → z:·string;
+    5   │ - → a:·string;
+      2 │ + → a:·string;
+      3 │ + → z:·string;
+    6 4 │   }
+    7 5 │   
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts
new file mode 100644
index 000000000000..e38da1224002
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts
@@ -0,0 +1,7 @@
+interface Example {
+	z: string;
+	(): void;
+
+	b: string;
+	a: string;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts.snap
new file mode 100644
index 000000000000..25080aa7cefb
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_non_sortable_in_section.ts.snap
@@ -0,0 +1,47 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_non_sortable_in_section.ts
+---
+# Input
+```ts
+interface Example {
+	z: string;
+	(): void;
+
+	b: string;
+	a: string;
+}
+
+```
+
+# Diagnostics
+```
+partition_by_new_line_non_sortable_in_section.ts:1:1 assist/source/useSortedInterfaceMembers  FIXABLE  ━━━━━━━━━━
+
+  i The interface members are not sorted by key.
+  
+  > 1 │ interface Example {
+      │ ^^^^^^^^^^^^^^^^^^^
+  > 2 │ 	z: string;
+  > 3 │ 	(): void;
+  > 4 │ 
+  > 5 │ 	b: string;
+  > 6 │ 	a: string;
+  > 7 │ }
+      │ ^
+    8 │ 
+  
+  i Safe fix: Sort the interface members by key.
+  
+    3 3 │     (): void;
+    4 4 │   
+    5   │ - → b:·string;
+    6   │ - → a:·string;
+      5 │ + → a:·string;
+      6 │ + → b:·string;
+    7 7 │   }
+    8 8 │   
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts
new file mode 100644
index 000000000000..efbdce3c6bf7
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts
@@ -0,0 +1,10 @@
+interface User {
+	id: string;
+
+	createdAt: Date;
+	updatedAt: Date;
+
+	email: string;
+	name: string;
+	passwordHash: string;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts.snap
new file mode 100644
index 000000000000..bf723a54ecc3
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_sorted.ts.snap
@@ -0,0 +1,19 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_sorted.ts
+---
+# Input
+```ts
+interface User {
+	id: string;
+
+	createdAt: Date;
+	updatedAt: Date;
+
+	email: string;
+	name: string;
+	passwordHash: string;
+}
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts
new file mode 100644
index 000000000000..8f25c23cfb4e
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts
@@ -0,0 +1,10 @@
+interface User {
+	id: string;
+
+	updatedAt: Date;
+	createdAt: Date;
+
+	passwordHash: string;
+	name: string;
+	email: string;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts.snap
new file mode 100644
index 000000000000..5aec7703d28b
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_unsorted.ts.snap
@@ -0,0 +1,57 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_unsorted.ts
+---
+# Input
+```ts
+interface User {
+	id: string;
+
+	updatedAt: Date;
+	createdAt: Date;
+
+	passwordHash: string;
+	name: string;
+	email: string;
+}
+
+```
+
+# Diagnostics
+```
+partition_by_new_line_unsorted.ts:1:1 assist/source/useSortedInterfaceMembers  FIXABLE  ━━━━━━━━━━━━
+
+  i The interface members are not sorted by key.
+  
+   > 1 │ interface User {
+       │ ^^^^^^^^^^^^^^^^
+   > 2 │ 	id: string;
+   > 3 │ 
+   > 4 │ 	updatedAt: Date;
+        ...
+   > 8 │ 	name: string;
+   > 9 │ 	email: string;
+  > 10 │ }
+       │ ^
+    11 │ 
+  
+  i Safe fix: Sort the interface members by key.
+  
+     2  2 │     id: string;
+     3  3 │   
+     4    │ - → updatedAt:·Date;
+     5    │ - → createdAt:·Date;
+        4 │ + → createdAt:·Date;
+        5 │ + → updatedAt:·Date;
+     6  6 │   
+     7    │ - → passwordHash:·string;
+        7 │ + → email:·string;
+     8  8 │     name: string;
+     9    │ - → email:·string;
+        9 │ + → passwordHash:·string;
+    10 10 │   }
+    11 11 │   
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.options.json b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.options.json
new file mode 100644
index 000000000000..6fa87000aa0a
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.options.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "useSortedInterfaceMembers": {
+          "level": "on",
+          "options": {
+            "partitionByNewLine": true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts
new file mode 100644
index 000000000000..bf74beb70be5
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts
@@ -0,0 +1,5 @@
+interface User {
+	id: string;
+	
+	createdAt: Date;
+}
diff --git a/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts.snap b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts.snap
new file mode 100644
index 000000000000..390d96b8556e
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/source/useSortedInterfaceMembers/partition_by_new_line_whitespace.ts.snap
@@ -0,0 +1,14 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 149
+expression: partition_by_new_line_whitespace.ts
+---
+# Input
+```ts
+interface User {
+	id: string;
+	
+	createdAt: Date;
+}
+
+```
diff --git a/crates/biome_languages/src/html.rs b/crates/biome_languages/src/html.rs
index 7de9c477a321..ea3e8aa6db24 100644
--- a/crates/biome_languages/src/html.rs
+++ b/crates/biome_languages/src/html.rs
@@ -48,8 +48,7 @@ impl HtmlFileSource {
         }
     }
 
-    /// Returns `true` if the current file is `.html` and doesn't support
-    /// any text expression capability
+    /// Returns `true` for standard HTML sources without text-expression support.
     pub const fn is_html(&self) -> bool {
         matches!(self.variant, HtmlVariant::Standard(_))
     }
@@ -146,7 +145,7 @@ impl HtmlFileSource {
     pub fn try_from_extension(extension: &str) -> Result<Self, FileSourceError> {
         // We assume the file extension is normalized to lowercase
         match extension {
-            "html" | "svg" => Ok(Self::html()),
+            "htm" | "html" | "svg" => Ok(Self::html()),
             "astro" => Ok(Self::astro()),
             "vue" => Ok(Self::vue()),
             "svelte" => Ok(Self::svelte()),
diff --git a/crates/biome_lsp/src/server.tests.rs b/crates/biome_lsp/src/server.tests.rs
index 5ed1904a69c4..d70861e9cabd 100644
--- a/crates/biome_lsp/src/server.tests.rs
+++ b/crates/biome_lsp/src/server.tests.rs
@@ -1760,6 +1760,83 @@ async fn pull_diagnostics_for_css_files() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn pull_diagnostics_for_htm_files() -> Result<()> {
+    let fs = MemoryFileSystem::default();
+    let config = r#"{
+        "html": {
+            "linter": { "enabled": true }
+        }
+    }"#;
+
+    fs.insert(to_utf8_file_path_buf(uri!("biome.json")), config);
+
+    let factory = ServerFactory::new_with_fs(Arc::new(fs));
+    let (service, client) = factory.create().into_inner();
+
+    let (stream, sink) = client.split();
+    let mut server = Server::new(service);
+
+    let (sender, mut receiver) = channel(CHANNEL_BUFFER_SIZE);
+    let reader = tokio::spawn(client_handler(stream, sink, sender));
+
+    server.initialize().await?;
+    server.initialized().await?;
+
+    server.load_configuration().await?;
+
+    let invalid_html = r#"<div scope="col"></div>"#;
+    server
+        // VS Code assigns the `html` language identifier to `.htm` files.
+        .open_named_document(invalid_html, uri!("document.htm"), "html")
+        .await?;
+
+    let notification = wait_for_notification(&mut receiver, |n| n.is_publish_diagnostics()).await;
+
+    assert_eq!(
+        notification,
+        Some(ServerNotification::PublishDiagnostics(
+            PublishDiagnosticsParams {
+                uri: uri!("document.htm"),
+                version: Some(0),
+                diagnostics: vec![Diagnostic {
+                    range: Range {
+                        start: Position {
+                            line: 0,
+                            character: 5,
+                        },
+                        end: Position {
+                            line: 0,
+                            character: 16,
+                        },
+                    },
+                    severity: Some(DiagnosticSeverity::ERROR),
+                    code: Some(NumberOrString::String(String::from(
+                        "lint/a11y/noHeaderScope"
+                    ))),
+                    code_description: Some(CodeDescription {
+                        href: "https://biomejs.dev/linter/rules/no-header-scope".parse()?
+                    }),
+                    source: Some(String::from("biome")),
+                    message: String::from(
+                        "Avoid using the scope attribute on elements other than th elements.",
+                    ),
+                    related_information: None,
+                    tags: None,
+                    data: None,
+                }],
+            }
+        ))
+    );
+
+    server.close_document().await?;
+
+    server.shutdown().await?;
+    reader.abort();
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn pull_diagnostics_for_svg_files() -> Result<()> {
     let fs = MemoryFileSystem::default();
diff --git a/crates/biome_module_graph/CONTRIBUTING.md b/crates/biome_module_graph/CONTRIBUTING.md
index 89a886ee6518..cebeb399e86a 100644
--- a/crates/biome_module_graph/CONTRIBUTING.md
+++ b/crates/biome_module_graph/CONTRIBUTING.md
@@ -153,8 +153,9 @@ Like an analyzer rule's metadata trait, `TypeInferenceRequestMetadata` is
 implemented by each request type and required by `TypeInferenceRequest`. A
 request therefore cannot compile without its static identity.
 
-Request IDs are stable maintenance identifiers printed in profiles. Use
-lowercase words separated by hyphens after the `request.` prefix:
+Request IDs are stable identities used to aggregate records for the same
+request contract. Use lowercase words separated by hyphens after the
+`request.` prefix:
 
 ```text
 request.expected-call-argument-type
@@ -319,10 +320,10 @@ line, and symbol adjacent to the canonical `execute` method. Inference profiles
 use this reference to lead maintainers from a reported source range to the
 implementation that orchestrated the work.
 
-Query families and whole-module reasons also have stable IDs. Each recorded
-query execution retains its own implementation reference, so multiple query
-bodies can share one family. Code references correspond to the Biome version
-that produced a report.
+Each recorded query execution retains its own implementation reference, so
+multiple query bodies can share one family. Whole-module records retain the
+implementation responsible for widening inference to complete tables. Code
+references correspond to the Biome version that produced a report.
 
 Do not read `ModuleInfo::path` from inside a tracked query for profiling. The
 path is a Salsa input, so reading it changes the query's dependency set. The
@@ -332,17 +333,23 @@ request and carries only module identities and `TextRange` values.
 
 ## Profiling inference
 
-Maintainers can ask a user to reproduce CLI inference work with the hidden
-maintenance option:
+Use `--profile-type-inference` to inspect CLI inference work:
 
 ```shell
 biome lint --profile-type-inference path/to/reproduction
 biome check --profile-type-inference path/to/reproduction
 ```
 
-The default report ranks requests by consumer, tracked query bodies, and
-whole-module widening. Use `--verbose` to show every recorded source range and
-implementation reference.
+The report groups records by source file. The default output shows the ten files
+with the highest cumulative request time. Within each file, it shows the top
+five request groups, top eight query groups, and top five whole-module groups.
+It includes the total number of groups, source records, and completed executions
+so omitted work remains visible.
+
+Use `--verbose` to show detailed metrics and implementation references for the
+top five request records, top eight query records, and top five whole-module
+records in each file. Verbose output includes every file while retaining the
+per-file limits.
 
 Request and query timings are inclusive and must not be added together. A high
 request count with few tracked query executions usually indicates Salsa reuse.
diff --git a/crates/biome_module_graph/src/type_inference/profiling.rs b/crates/biome_module_graph/src/type_inference/profiling.rs
index be7e0b2aa4a4..7a3c1f3086c1 100644
--- a/crates/biome_module_graph/src/type_inference/profiling.rs
+++ b/crates/biome_module_graph/src/type_inference/profiling.rs
@@ -20,7 +20,7 @@
 
 mod display;
 
-pub use display::DisplayTypeInferenceProfile;
+pub use display::TypeInferenceProfileDiagnostic;
 
 use std::cell::{Cell, RefCell};
 use std::cmp;
@@ -134,10 +134,6 @@ impl RequestMetadata {
         }
     }
 
-    const fn id(self) -> &'static str {
-        self.id
-    }
-
     const fn label(self) -> &'static str {
         self.label
     }
@@ -1016,30 +1012,3 @@ impl TypeInferenceProfileSnapshot {
         });
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use super::{BreadthMetric, DurationMetric};
-
-    #[test]
-    fn duration_and_breadth_metrics_exclude_aborted_work() {
-        let mut duration = DurationMetric::default();
-        duration.record_completed(Duration::from_millis(1));
-        duration.record_aborted();
-        duration.record_completed(Duration::from_millis(3));
-        assert_eq!(duration.completed, 2);
-        assert_eq!(duration.aborted, 1);
-        assert_eq!(duration.min(), Duration::from_millis(1));
-        assert_eq!(duration.average(), Duration::from_millis(2));
-        assert_eq!(duration.max, Duration::from_millis(3));
-
-        let mut breadth = BreadthMetric::default();
-        breadth.record(2);
-        breadth.record(4);
-        assert_eq!(breadth.min, 2);
-        assert_eq!(breadth.average(), 3.0);
-        assert_eq!(breadth.max, 4);
-    }
-}
diff --git a/crates/biome_module_graph/src/type_inference/profiling/display.rs b/crates/biome_module_graph/src/type_inference/profiling/display.rs
index 397ba6ca0e3a..53688cb28c52 100644
--- a/crates/biome_module_graph/src/type_inference/profiling/display.rs
+++ b/crates/biome_module_graph/src/type_inference/profiling/display.rs
@@ -1,35 +1,36 @@
-//! Terminal output for type-inference profiles.
-//!
-//! The default report groups related records and limits the number shown. The
-//! verbose report prints every captured source record and the Rust location of
-//! the code that produced it.
-
+//! Diagnostic output for type-inference profiles.
 mod compact;
 mod verbose;
 
-use std::io;
-use std::time::Duration;
-
 use biome_console::fmt::{Display, Formatter};
 use biome_console::markup;
+use biome_diagnostics::{
+    Advices, Category, Diagnostic, DiagnosticTags, LogCategory, Severity, Visit, category,
+};
 use camino::Utf8Path;
+use std::fmt;
+use std::io;
+use std::time::Duration;
 
 use super::{
     TypeInferenceLocationAttribution, TypeInferenceProfileLocation, TypeInferenceProfileSnapshot,
     TypeInferenceQueryProfile, TypeInferenceRequestProfile, TypeInferenceWholeModuleProfile,
 };
 
-const RECORD_INDENT: usize = 2;
+const REQUEST_LIMIT: usize = 5;
+const QUERY_LIMIT: usize = 8;
+const WHOLE_MODULE_LIMIT: usize = 5;
+const FILE_LIMIT: usize = 10;
 
-/// Renders one type-inference profile for terminal-oriented CLI output.
-pub struct DisplayTypeInferenceProfile<'a> {
+/// Diagnostic for one type-inference profile.
+pub struct TypeInferenceProfileDiagnostic<'a> {
     snapshot: &'a TypeInferenceProfileSnapshot,
     working_directory: Option<&'a Utf8Path>,
     version: &'a str,
     verbose: bool,
 }
 
-impl<'a> DisplayTypeInferenceProfile<'a> {
+impl<'a> TypeInferenceProfileDiagnostic<'a> {
     pub fn new(
         snapshot: &'a TypeInferenceProfileSnapshot,
         working_directory: Option<&'a Utf8Path>,
@@ -43,32 +44,56 @@ impl<'a> DisplayTypeInferenceProfile<'a> {
         }
     }
 
-    /// Selects the report format.
-    ///
-    /// `true` prints every captured source record and its code reference.
-    /// `false` groups records and limits the ranked request and query sections.
+    /// Selects whether source records include detailed metrics and code references.
     pub const fn with_verbose(mut self, verbose: bool) -> Self {
         self.verbose = verbose;
         self
     }
 }
 
-impl Display for DisplayTypeInferenceProfile<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+impl fmt::Debug for TypeInferenceProfileDiagnostic<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TypeInferenceProfileDiagnostic")
+            .field("version", &self.version)
+            .field("verbose", &self.verbose)
+            .finish_non_exhaustive()
+    }
+}
+
+impl Diagnostic for TypeInferenceProfileDiagnostic<'_> {
+    fn category(&self) -> Option<&'static Category> {
+        Some(category!("reporter/profiler"))
+    }
+
+    fn severity(&self) -> Severity {
+        Severity::Information
+    }
+
+    fn description(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Type inference profile (Biome {})", self.version)
+    }
+
+    fn tags(&self) -> DiagnosticTags {
+        if self.verbose {
+            DiagnosticTags::VERBOSE
+        } else {
+            DiagnosticTags::empty()
+        }
+    }
+
+    fn message(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        f.write_markup(markup! {
+            "Type inference profile "<Dim>"(Biome "{self.version}")"</Dim>
+        })
+    }
+
+    fn advices(&self, visitor: &mut dyn Visit) -> io::Result<()> {
         if self.verbose {
-            verbose::VerboseTypeInferenceProfile::new(
-                self.snapshot,
-                self.working_directory,
-                self.version,
-            )
-            .fmt(f)
+            verbose::VerboseTypeInferenceProfile::new(self.snapshot, self.working_directory)
+                .record(visitor)
         } else {
-            compact::CompactTypeInferenceProfile::new(
-                self.snapshot,
-                self.working_directory,
-                self.version,
-            )
-            .fmt(f)
+            compact::CompactTypeInferenceProfile::new(self.snapshot, self.working_directory)
+                .record(visitor)
         }
     }
 }
@@ -192,134 +217,98 @@ impl Display for TypeInferenceLocationAttribution {
     }
 }
 
-struct SourceLocation<'a> {
-    location: &'a TypeInferenceProfileLocation,
+struct SourcePath<'a> {
+    path: &'a str,
     working_directory: Option<&'a Utf8Path>,
 }
 
-impl<'a> SourceLocation<'a> {
-    const fn new(
-        location: &'a TypeInferenceProfileLocation,
-        working_directory: Option<&'a Utf8Path>,
-    ) -> Self {
+impl<'a> SourcePath<'a> {
+    const fn new(path: &'a str, working_directory: Option<&'a Utf8Path>) -> Self {
         Self {
-            location,
+            path,
             working_directory,
         }
     }
 }
 
-impl Display for SourceLocation<'_> {
+impl Display for SourcePath<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        let path = Utf8Path::new(&self.location.path);
+        let path = Utf8Path::new(self.path);
         if !path.is_absolute() {
-            f.write_str(path.as_str())?;
+            f.write_str(path.as_str())
         } else if let Some(relative) = self
             .working_directory
             .and_then(|working_directory| path.strip_prefix(working_directory).ok())
         {
-            f.write_str(relative.as_str())?;
+            f.write_str(relative.as_str())
         } else {
             f.write_str("<external>/")?;
-            f.write_str(path.file_name().unwrap_or("unknown"))?;
+            f.write_str(path.file_name().unwrap_or("unknown"))
         }
-        if let Some(range) = self.location.range {
+    }
+}
+
+struct SourceRange(Option<biome_rowan::TextRange>);
+
+impl Display for SourceRange {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        if let Some(range) = self.0 {
             f.write_fmt(format_args!(
-                ":{}..{}",
+                "{}..{}",
                 u32::from(range.start()),
                 u32::from(range.end())
-            ))?;
+            ))
+        } else {
+            f.write_str("document-wide")
         }
-        Ok(())
     }
 }
 
-struct CapacityWarning<'a>(&'a TypeInferenceProfileSnapshot);
+struct SourceLocation<'a> {
+    location: &'a TypeInferenceProfileLocation,
+    working_directory: Option<&'a Utf8Path>,
+}
 
-impl Display for CapacityWarning<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        let dropped_metric_events = self
-            .0
-            .dropped_request_keys
-            .saturating_add(self.0.dropped_query_keys)
-            .saturating_add(self.0.dropped_whole_module_keys);
-        let dropped_documents = self.0.dropped_documents;
-        if dropped_metric_events > 0 || dropped_documents > 0 {
-            f.write_markup(markup! {
-                <Warn>"Profile capacity was reached; uncaptured metric events: "{dropped_metric_events}", uncaptured document paths: "{dropped_documents}". Rerun on a narrower path."</Warn>"\n"
-            })?;
+impl<'a> SourceLocation<'a> {
+    const fn new(
+        location: &'a TypeInferenceProfileLocation,
+        working_directory: Option<&'a Utf8Path>,
+    ) -> Self {
+        Self {
+            location,
+            working_directory,
         }
-        Ok(())
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use biome_console::fmt::{Formatter, Termcolor};
-    use biome_console::markup;
-    use biome_diagnostics::termcolor::NoColor;
-    use biome_rowan::TextRange;
-    use camino::Utf8Path;
-
-    use super::{SourceLocation, TimingCutoffs, TimingMetrics, TypeInferenceProfileLocation};
-    use crate::type_inference::profiling::TypeInferenceLocationAttribution;
-
-    fn render(display: SourceLocation<'_>) -> String {
-        let mut buffer = Vec::new();
-        let mut writer = Termcolor(NoColor::new(&mut buffer));
-        let mut f = Formatter::new(&mut writer);
-        f.write_markup(markup! {{ display }}).unwrap();
-        String::from_utf8(buffer).unwrap()
-    }
-
-    #[test]
-    fn timing_cutoffs_select_the_highest_ten_percent() {
-        let cutoffs = TimingCutoffs::new((1..=10).map(|seconds| TimingMetrics {
-            total: Duration::from_secs(seconds),
-            average: Duration::from_secs(seconds * 2),
-            min: Duration::from_secs(seconds * 3),
-            max: Duration::from_secs(seconds * 4),
-            completed: 1,
-            aborted: 0,
-        }));
-
-        assert_eq!(cutoffs.total, Some(Duration::from_secs(10)));
-        assert_eq!(cutoffs.average, Some(Duration::from_secs(20)));
-        assert_eq!(cutoffs.min, Some(Duration::from_secs(30)));
-        assert_eq!(cutoffs.max, Some(Duration::from_secs(40)));
+impl Display for SourceLocation<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        SourcePath::new(&self.location.path, self.working_directory).fmt(f)?;
+        if self.location.range.is_some() {
+            f.write_str(":")?;
+            SourceRange(self.location.range).fmt(f)?;
+        }
+        Ok(())
     }
+}
 
-    #[test]
-    fn location_uses_relative_path_and_text_range() {
-        let workspace = if cfg!(windows) {
-            Utf8Path::new("C:\\workspace")
-        } else {
-            Utf8Path::new("/workspace")
-        };
-        let other = if cfg!(windows) {
-            Utf8Path::new("C:\\other")
-        } else {
-            Utf8Path::new("/other")
-        };
-        let location = TypeInferenceProfileLocation {
-            path: workspace
-                .join("packages")
-                .join("example.ts")
-                .into_string()
-                .into(),
-            range: Some(TextRange::new(2.into(), 8.into())),
-            attribution: TypeInferenceLocationAttribution::Exact,
-        };
-
-        assert_eq!(
-            render(SourceLocation::new(&location, Some(workspace))),
-            format!("{}:2..8", Utf8Path::new("packages").join("example.ts"))
-        );
-        assert_eq!(
-            render(SourceLocation::new(&location, Some(other))),
-            "<external>/example.ts:2..8"
-        );
+fn record_capacity_warning(
+    visitor: &mut dyn Visit,
+    snapshot: &TypeInferenceProfileSnapshot,
+) -> io::Result<()> {
+    let dropped_metric_events = snapshot
+        .dropped_request_keys
+        .saturating_add(snapshot.dropped_query_keys)
+        .saturating_add(snapshot.dropped_whole_module_keys);
+    let dropped_documents = snapshot.dropped_documents;
+    if dropped_metric_events > 0 || dropped_documents > 0 {
+        visitor.record_log(
+            LogCategory::Warn,
+            &markup! {
+                "Profile capacity was reached; uncaptured metric events: "{dropped_metric_events}
+                ", uncaptured document paths: "{dropped_documents}". Rerun on a narrower path."
+            },
+        )?;
     }
+    Ok(())
 }
diff --git a/crates/biome_module_graph/src/type_inference/profiling/display/compact.rs b/crates/biome_module_graph/src/type_inference/profiling/display/compact.rs
index bf24ff2e4876..daf87228dcae 100644
--- a/crates/biome_module_graph/src/type_inference/profiling/display/compact.rs
+++ b/crates/biome_module_graph/src/type_inference/profiling/display/compact.rs
@@ -1,106 +1,345 @@
-//! Grouped terminal output for type-inference profiles.
-//!
-//! The report groups requests by analyzer and queries by the Rust function that
-//! ran. Each group shows its slowest source location. Request and query groups
-//! have separate display limits.
-
-use std::collections::BTreeMap;
-use std::io;
-use std::time::Duration;
-
-use biome_console::fmt::{Display, Formatter};
-use biome_console::{HARD_LINE, HorizontalLine, Padding, markup};
-use camino::Utf8Path;
+//! Grouped diagnostic advice for type-inference profiles.
 
 use super::{
-    CapacityWarning, HighlightedDuration, RECORD_INDENT, SourceLocation, TimingCutoffs,
-    TimingMetrics,
+    DisplayDuration, FILE_LIMIT, HighlightedDuration, QUERY_LIMIT, REQUEST_LIMIT, SourceLocation,
+    SourcePath, SourceRange, TimingCutoffs, TimingMetrics, WHOLE_MODULE_LIMIT,
+    record_capacity_warning,
 };
 use crate::type_inference::profiling::{
-    RequestMetadata, TypeInferenceProfileLocation, TypeInferenceProfileSnapshot,
-    TypeInferenceQueryProfile, TypeInferenceRequestProfile, TypeInferenceWholeModuleProfile,
+    RequestMetadata, TypeInferenceProfileSnapshot, TypeInferenceQueryProfile,
+    TypeInferenceRequestProfile, TypeInferenceWholeModuleProfile,
 };
 use crate::type_inference::{
     TypeInferenceCaller, TypeInferenceCodeReference, TypeInferenceQueryKind,
     TypeInferenceWholeModuleReason,
 };
-
-const REQUEST_GROUP_LIMIT: usize = 5;
-const QUERY_GROUP_LIMIT: usize = 8;
+use biome_console::fmt::{Display, Formatter};
+use biome_console::markup;
+use biome_diagnostics::{Advices, LogCategory, Visit};
+use camino::Utf8Path;
+use std::collections::BTreeMap;
+use std::io;
+use std::time::Duration;
 
 pub(super) struct CompactTypeInferenceProfile<'a> {
     snapshot: &'a TypeInferenceProfileSnapshot,
     working_directory: Option<&'a Utf8Path>,
-    version: &'a str,
 }
 
 impl<'a> CompactTypeInferenceProfile<'a> {
     pub(super) const fn new(
         snapshot: &'a TypeInferenceProfileSnapshot,
         working_directory: Option<&'a Utf8Path>,
-        version: &'a str,
     ) -> Self {
         Self {
             snapshot,
             working_directory,
-            version,
         }
     }
 }
 
-impl Display for CompactTypeInferenceProfile<'_> {
+impl Advices for CompactTypeInferenceProfile<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        visitor.record_log(
+            LogCategory::None,
+            &ProfileSummary {
+                snapshot: self.snapshot,
+                verbose: false,
+            },
+        )?;
+
+        if self.snapshot.is_empty() {
+            visitor.record_log(
+                LogCategory::None,
+                &"No type-inference requests or queries were recorded.",
+            )?;
+            return record_capacity_warning(visitor, self.snapshot);
+        }
+
+        let files = collect_files(self.snapshot);
+        for file in files.iter().take(FILE_LIMIT) {
+            visitor.record_group(
+                &FileTitle::new(file, self.working_directory),
+                &CompactFileAdvice {
+                    file,
+                    working_directory: self.working_directory,
+                },
+            )?;
+        }
+        record_omitted(visitor, files.len(), FILE_LIMIT, "file", "files")?;
+
+        record_capacity_warning(visitor, self.snapshot)?;
+
+        visitor.record_log(LogCategory::Info, &markup! {
+            "To show all the information, use the "<Emphasis>"--verbose"</Emphasis>" option. The output might be very verbose, so it's advised to analyze a single file."
+        })?;
+
+        visitor
+            .record_command("biome lint --profile-type-inference --verbose ./path/to/file.ts")?;
+
+        Ok(())
+    }
+}
+
+pub(super) struct ProfileSummary<'a> {
+    pub(super) snapshot: &'a TypeInferenceProfileSnapshot,
+    pub(super) verbose: bool,
+}
+
+impl Display for ProfileSummary<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        let request_runs = self
-            .snapshot
+        let request_executions = completed_requests(self.snapshot);
+        let query_executions = completed_queries(self.snapshot);
+        let whole_module_executions = completed_whole_modules(self.snapshot);
+        f.write_markup(markup! {
+            "Completed executions: "{request_executions}" requests, "{query_executions}
+            " tracked queries, "{whole_module_executions}" whole-module inferences.\n"
+        })?;
+        if self.verbose {
+            f.write_markup(markup! {
+                "Showing the top "{REQUEST_LIMIT}" requests, top "{QUERY_LIMIT}" queries, and top "
+                {WHOLE_MODULE_LIMIT}" whole-module records per file.\n"
+            })?;
+        } else {
+            f.write_markup(markup! {
+                "Showing the "{FILE_LIMIT}" files with the highest cumulative request time.\n"
+            })?;
+        }
+        f.write_str(
+            "Inclusive timings are non-additive; the highest 10% are highlighted in sections with at least ten entries.\n",
+        )?;
+        f.write_str("Ranges are zero-based, half-open UTF-8 byte offsets.")
+    }
+}
+
+fn completed_requests(snapshot: &TypeInferenceProfileSnapshot) -> u64 {
+    snapshot
+        .requests
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_queries(snapshot: &TypeInferenceProfileSnapshot) -> u64 {
+    snapshot
+        .queries
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_whole_modules(snapshot: &TypeInferenceProfileSnapshot) -> u64 {
+    snapshot
+        .whole_module_inferences
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+#[derive(Default)]
+pub(super) struct FileProfiles<'a> {
+    pub(super) path: &'a str,
+    pub(super) requests: Vec<&'a TypeInferenceRequestProfile>,
+    pub(super) queries: Vec<&'a TypeInferenceQueryProfile>,
+    pub(super) whole_modules: Vec<&'a TypeInferenceWholeModuleProfile>,
+}
+
+impl FileProfiles<'_> {
+    pub(super) fn cumulative_request_time(&self) -> Duration {
+        self.requests.iter().fold(Duration::ZERO, |total, profile| {
+            total.saturating_add(profile.total)
+        })
+    }
+}
+
+pub(super) fn collect_files(snapshot: &TypeInferenceProfileSnapshot) -> Vec<FileProfiles<'_>> {
+    let mut files = BTreeMap::<&str, FileProfiles>::new();
+    for profile in &snapshot.requests {
+        files
+            .entry(&profile.location.path)
+            .or_insert_with(|| FileProfiles {
+                path: &profile.location.path,
+                ..FileProfiles::default()
+            })
             .requests
-            .iter()
-            .map(|profile| u64::from(profile.completed))
-            .sum::<u64>();
-        let query_runs = self
-            .snapshot
+            .push(profile);
+    }
+    for profile in &snapshot.queries {
+        files
+            .entry(&profile.location.path)
+            .or_insert_with(|| FileProfiles {
+                path: &profile.location.path,
+                ..FileProfiles::default()
+            })
             .queries
-            .iter()
-            .map(|profile| u64::from(profile.completed))
-            .sum::<u64>();
-        let whole_module_runs = self
-            .snapshot
-            .whole_module_inferences
-            .iter()
-            .map(|profile| u64::from(profile.completed))
-            .sum::<u64>();
+            .push(profile);
+    }
+    for profile in &snapshot.whole_module_inferences {
+        files
+            .entry(&profile.root.path)
+            .or_insert_with(|| FileProfiles {
+                path: &profile.root.path,
+                ..FileProfiles::default()
+            })
+            .whole_modules
+            .push(profile);
+    }
+
+    let mut files = files.into_values().collect::<Vec<_>>();
+    files.sort_by(|left, right| {
+        right
+            .cumulative_request_time()
+            .cmp(&left.cumulative_request_time())
+            .then_with(|| left.path.cmp(right.path))
+    });
+    files
+}
+
+pub(super) struct FileTitle<'a> {
+    file: &'a FileProfiles<'a>,
+    working_directory: Option<&'a Utf8Path>,
+}
 
+impl<'a> FileTitle<'a> {
+    pub(super) const fn new(
+        file: &'a FileProfiles<'a>,
+        working_directory: Option<&'a Utf8Path>,
+    ) -> Self {
+        Self {
+            file,
+            working_directory,
+        }
+    }
+}
+
+impl Display for FileTitle<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        let path = Utf8Path::new(self.file.path);
+        let target = if path.is_absolute() {
+            format!("file://{path}")
+        } else if let Some(working_directory) = self.working_directory {
+            format!("file://{}", working_directory.join(path))
+        } else {
+            self.file.path.to_string()
+        };
         f.write_markup(markup! {
-            {HorizontalLine::new(20)}
-            <Emphasis>"Type inference profile"</Emphasis>" "<Dim>"(Biome "{self.version}")"</Dim>"\n"
-            <Dim>"Timings are inclusive and non-additive; the highest 10% are highlighted in sections with at least ten groups."</Dim>"\n"
-            <Dim>"Completed runs: requests "{request_runs}", tracked queries "{query_runs}", whole-module "{whole_module_runs}"."</Dim>"\n"
-            <Dim>"Showing ranked aggregates; use --verbose for every source record and code reference."</Dim>"\n"
-            <Dim>"Ranges use zero-based UTF-8 byte offsets; paths may reveal project structure."</Dim>
-            {HARD_LINE}
-        })?;
+            <Hyperlink href={target.as_str()}>
+                {SourcePath::new(self.file.path, self.working_directory)}
+            </Hyperlink>
+            " ("{DisplayDuration(self.file.cumulative_request_time())}")"
+        })
+    }
+}
 
-        if self.snapshot.is_empty() {
-            f.write_markup(markup! {
-                "No type-inference requests or queries were recorded.\n"
-                {CapacityWarning(self.snapshot)}
-            })?;
-            return Ok(());
+struct CompactFileAdvice<'a> {
+    file: &'a FileProfiles<'a>,
+    working_directory: Option<&'a Utf8Path>,
+}
+
+impl Advices for CompactFileAdvice<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        if !self.file.requests.is_empty() {
+            let groups = aggregate_request_profiles(&self.file.requests);
+            visitor.record_group(
+                &CompactSectionTitle::new(
+                    "Requests",
+                    groups.len().min(REQUEST_LIMIT),
+                    groups.len(),
+                    self.file.requests.len(),
+                    completed_request_profiles(&self.file.requests),
+                ),
+                &CompactRequestProfiles { groups: &groups },
+            )?;
+        }
+
+        if !self.file.queries.is_empty() {
+            let groups = aggregate_query_profiles(&self.file.queries);
+            visitor.record_group(
+                &CompactSectionTitle::new(
+                    "Queries",
+                    groups.len().min(QUERY_LIMIT),
+                    groups.len(),
+                    self.file.queries.len(),
+                    completed_query_profiles(&self.file.queries),
+                ),
+                &CompactQueryProfiles { groups: &groups },
+            )?;
         }
 
+        let groups = aggregate_whole_module_profiles(&self.file.whole_modules);
+        let advice = CompactWholeModuleProfiles {
+            groups: &groups,
+            working_directory: self.working_directory,
+        };
+        if groups.is_empty() {
+            visitor.record_group(&"Whole-module inference", &advice)
+        } else {
+            visitor.record_group(
+                &CompactSectionTitle::new(
+                    "Whole-module inference",
+                    groups.len().min(WHOLE_MODULE_LIMIT),
+                    groups.len(),
+                    self.file.whole_modules.len(),
+                    completed_whole_module_profiles(&self.file.whole_modules),
+                ),
+                &advice,
+            )
+        }
+    }
+}
+
+fn completed_request_profiles(profiles: &[&TypeInferenceRequestProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_query_profiles(profiles: &[&TypeInferenceQueryProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_whole_module_profiles(profiles: &[&TypeInferenceWholeModuleProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+struct CompactSectionTitle {
+    label: &'static str,
+    shown: usize,
+    groups: usize,
+    source_records: usize,
+    executions: u64,
+}
+
+impl CompactSectionTitle {
+    const fn new(
+        label: &'static str,
+        shown: usize,
+        groups: usize,
+        source_records: usize,
+        executions: u64,
+    ) -> Self {
+        Self {
+            label,
+            shown,
+            groups,
+            source_records,
+            executions,
+        }
+    }
+}
+
+impl Display for CompactSectionTitle {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            {CompactRequestProfiles {
-                profiles: &self.snapshot.requests,
-                working_directory: self.working_directory,
-            }}
-            {CompactQueryProfiles {
-                profiles: &self.snapshot.queries,
-                working_directory: self.working_directory,
-            }}
-            {CompactWholeModuleProfiles {
-                profiles: &self.snapshot.whole_module_inferences,
-                working_directory: self.working_directory,
-            }}
-            {CapacityWarning(self.snapshot)}
+            {self.label}" (top "{self.shown}" of "{Count::groups(self.groups)}"; "
+            {Count::source_records(self.source_records)}"; "{Count::executions(self.executions)}")"
         })
     }
 }
@@ -148,46 +387,35 @@ impl<'a> RequestGroup<'a> {
 }
 
 struct CompactRequestProfiles<'a> {
-    profiles: &'a [TypeInferenceRequestProfile],
-    working_directory: Option<&'a Utf8Path>,
+    groups: &'a [RequestGroup<'a>],
 }
 
-impl Display for CompactRequestProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        if self.profiles.is_empty() {
-            return Ok(());
-        }
-
-        let groups = aggregate_request_profiles(self.profiles);
-        let shown = groups.len().min(REQUEST_GROUP_LIMIT);
-        let cutoffs = TimingCutoffs::new(groups.iter().map(|group| group.timing.metrics()));
-        f.write_markup(markup! {
-            <Emphasis>"Requests by consumer"</Emphasis>" "<Dim>"(top "{shown}" of "{Count::groups(groups.len())}"; "{Count::source_records(self.profiles.len())}")"</Dim>"\n"
-        })?;
-        for (index, group) in groups.iter().take(shown).enumerate() {
-            f.write_markup(markup! {
-                {CompactRequestProfileRecord {
+impl Advices for CompactRequestProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let cutoffs = TimingCutoffs::new(self.groups.iter().map(|group| group.timing.metrics()));
+        for (index, group) in self.groups.iter().take(REQUEST_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &CompactRequestProfileRecord {
                     index: index + 1,
                     group,
-                    working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
-        }
-        let omitted = groups.len().saturating_sub(shown);
-        if omitted > 0 {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}<Dim>{Count::groups(omitted)}" omitted; use --verbose for every source record."</Dim>"\n"
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {{HARD_LINE}})
+        record_omitted(
+            visitor,
+            self.groups.len(),
+            REQUEST_LIMIT,
+            "request group",
+            "request groups",
+        )
     }
 }
 
 struct CompactRequestProfileRecord<'a> {
     index: usize,
     group: &'a RequestGroup<'a>,
-    working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
 }
 
@@ -195,10 +423,12 @@ impl Display for CompactRequestProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let group = self.group;
         f.write_markup(markup! {
-            {self.index}". "<Info>{group.key.metadata.label()}</Info><Dim>" <- "</Dim>{group.key.caller.group()}"/"{group.key.caller.name()}"\n"
-            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}
-            {Padding::new(RECORD_INDENT)}<Dim>"hottest origin: "</Dim>{SourceLocation::new(&group.hottest.location, self.working_directory)}"\n"
-        })
+            {self.index}". "<Success>{group.key.metadata.label()}</Success><Dim>" <- "</Dim>
+            {group.key.caller.group()}"/"{group.key.caller.name()}"\n"
+            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}"\n"
+            <Info>"Hottest range: "</Info>{SourceRange(group.hottest.location.range)}
+        })?;
+        Ok(())
     }
 }
 
@@ -268,46 +498,35 @@ impl<'a> QueryGroup<'a> {
 }
 
 struct CompactQueryProfiles<'a> {
-    profiles: &'a [TypeInferenceQueryProfile],
-    working_directory: Option<&'a Utf8Path>,
+    groups: &'a [QueryGroup<'a>],
 }
 
-impl Display for CompactQueryProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        if self.profiles.is_empty() {
-            return Ok(());
-        }
-
-        let groups = aggregate_query_profiles(self.profiles);
-        let shown = groups.len().min(QUERY_GROUP_LIMIT);
-        let cutoffs = TimingCutoffs::new(groups.iter().map(|group| group.timing.metrics()));
-        f.write_markup(markup! {
-            <Emphasis>"Query bodies"</Emphasis>" "<Dim>"(top "{shown}" of "{Count::groups(groups.len())}"; "{Count::source_records(self.profiles.len())}")"</Dim>"\n"
-        })?;
-        for (index, group) in groups.iter().take(shown).enumerate() {
-            f.write_markup(markup! {
-                {CompactQueryProfileRecord {
+impl Advices for CompactQueryProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let cutoffs = TimingCutoffs::new(self.groups.iter().map(|group| group.timing.metrics()));
+        for (index, group) in self.groups.iter().take(QUERY_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &CompactQueryProfileRecord {
                     index: index + 1,
                     group,
-                    working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
-        }
-        let omitted = groups.len().saturating_sub(shown);
-        if omitted > 0 {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}<Dim>{Count::groups(omitted)}" omitted; use --verbose for every source record."</Dim>"\n"
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {{HARD_LINE}})
+        record_omitted(
+            visitor,
+            self.groups.len(),
+            QUERY_LIMIT,
+            "query group",
+            "query groups",
+        )
     }
 }
 
 struct CompactQueryProfileRecord<'a> {
     index: usize,
     group: &'a QueryGroup<'a>,
-    working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
 }
 
@@ -315,27 +534,20 @@ impl Display for CompactQueryProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let group = self.group;
         f.write_markup(markup! {
-            {self.index}". "<Info>{group.key.kind.label()}</Info><Dim>" / "</Dim>{group.key.implementation.symbol()}"\n"
-            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}
+            {self.index}". "<Success>{group.key.kind.label()}</Success><Dim>" / "</Dim>
+            {group.key.implementation.symbol()}"\n"
+            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}"\n"
         })?;
         if let Some(consumer) = group.top_consumer() {
             f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}<Dim>"top consumer: "</Dim>{QueryConsumer(consumer)}"\n"
+                <Info>"Consumer: "</Info>{consumer.request.label()}"\n"
+                <Info>"Caller: "</Info>{consumer.caller.group()}"/"{consumer.caller.name()}"\n"
             })?;
         }
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>"hottest source: "</Dim>{SourceLocation::new(&group.hottest.location, self.working_directory)}"\n"
-        })
-    }
-}
-
-struct QueryConsumer(QueryConsumerKey);
-
-impl Display for QueryConsumer {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        f.write_markup(markup! {
-            {self.0.request.label()}<Dim>" <- "</Dim>{self.0.caller.group()}"/"{self.0.caller.name()}
-        })
+            <Info>"Hottest range: "</Info>{SourceRange(group.hottest.location.range)}
+        })?;
+        Ok(())
     }
 }
 
@@ -388,42 +600,43 @@ impl<'a> WholeModuleGroup<'a> {
 }
 
 struct CompactWholeModuleProfiles<'a> {
-    profiles: &'a [TypeInferenceWholeModuleProfile],
+    groups: &'a [WholeModuleGroup<'a>],
     working_directory: Option<&'a Utf8Path>,
 }
 
-impl Display for CompactWholeModuleProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        f.write_markup(markup! {
-            <Emphasis>"Whole-module widening"</Emphasis>"\n"
-        })?;
-        if self.profiles.is_empty() {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"No widening to complete module tables was recorded."
-                {HARD_LINE}
-            })?;
-            return Ok(());
+impl Advices for CompactWholeModuleProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        if self.groups.is_empty() {
+            return visitor.record_log(
+                LogCategory::None,
+                &"No requests triggered whole-module inference.",
+            );
         }
 
-        let groups = aggregate_whole_module_profiles(self.profiles);
-        let cutoffs = TimingCutoffs::new(groups.iter().map(|group| group.timing.metrics()));
-        for group in &groups {
-            f.write_markup(markup! {
-                {CompactWholeModuleProfileRecord {
+        let cutoffs = TimingCutoffs::new(self.groups.iter().map(|group| group.timing.metrics()));
+        for (index, group) in self.groups.iter().take(WHOLE_MODULE_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &CompactWholeModuleProfileRecord {
+                    index: index + 1,
                     group,
                     working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>"Breadth values are independent maxima across completed runs."</Dim>
-            {HARD_LINE}
-        })
+        record_omitted(
+            visitor,
+            self.groups.len(),
+            WHOLE_MODULE_LIMIT,
+            "whole-module group",
+            "whole-module groups",
+        )
     }
 }
 
 struct CompactWholeModuleProfileRecord<'a> {
+    index: usize,
     group: &'a WholeModuleGroup<'a>,
     working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
@@ -433,17 +646,20 @@ impl Display for CompactWholeModuleProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let group = self.group;
         f.write_markup(markup! {
-            <Info>{group.reason.label()}</Info>"\n"
-            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}
-            {Padding::new(RECORD_INDENT)}<Dim>"maximum breadth: "</Dim>{group.modules_max}<Dim>" modules, slots T/E/B "</Dim>{group.type_slots_max}"/"{group.expression_slots_max}"/"{group.binding_slots_max}"\n"
+            {self.index}". "<Success>{group.reason.label()}</Success>"\n"
+            {CompactTimingMetricsDisplay::new(group.timing.metrics(), self.cutoffs)}"\n"
+            <Info>"Maximum breadth: "</Info>{group.modules_max}" modules\n"
+            <Info>"Maximum slots: "</Info>{group.type_slots_max}" types, "
+            {group.expression_slots_max}" expressions, "{group.binding_slots_max}" bindings\n"
         })?;
         if group.cycle_recoveries > 0 {
             f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}<Dim>"cycle recoveries: "</Dim>{group.cycle_recoveries}"\n"
+                <Info>"Cycle recoveries: "</Info>{group.cycle_recoveries}"\n"
             })?;
         }
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>"hottest transition: "</Dim>{SourceLocation::new(&group.hottest.root, self.working_directory)}<Dim>" -> "</Dim>{SourceLocation::new(&group.hottest.trigger, self.working_directory)}"\n"
+            <Info>"Hottest transition: "</Info>{SourceRange(group.hottest.root.range)}
+            <Info>" -> "</Info>{SourceLocation::new(&group.hottest.trigger, self.working_directory)}
         })
     }
 }
@@ -501,22 +717,25 @@ impl CompactTimingMetricsDisplay {
 impl Display for CompactTimingMetricsDisplay {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>"time: total "</Dim>{HighlightedDuration::new(self.metrics.total, self.cutoffs.total)}
-            <Dim>", "</Dim>{self.metrics.completed}<Dim>" runs, average "</Dim>{HighlightedDuration::new(self.metrics.average, self.cutoffs.average)}
-            <Dim>", max "</Dim>{HighlightedDuration::new(self.metrics.max, self.cutoffs.max)}
+            <Info>"Total "</Info>{HighlightedDuration::new(self.metrics.total, self.cutoffs.total)}
+            <Info>", "</Info>{Count::executions(u64::from(self.metrics.completed))}
+            <Info>", Average "</Info>{HighlightedDuration::new(self.metrics.average, self.cutoffs.average)}
+            <Info>", Max "</Info>{HighlightedDuration::new(self.metrics.max, self.cutoffs.max)}
         })?;
         if self.metrics.aborted > 0 {
             f.write_markup(markup! {
-                <Dim>", "</Dim>{self.metrics.aborted}<Dim>" aborted"</Dim>
+                <Info>", "</Info>{self.metrics.aborted}<Info>" aborted"</Info>
             })?;
         }
-        f.write_str("\n")
+        Ok(())
     }
 }
 
-fn aggregate_request_profiles(profiles: &[TypeInferenceRequestProfile]) -> Vec<RequestGroup<'_>> {
+fn aggregate_request_profiles<'a>(
+    profiles: &[&'a TypeInferenceRequestProfile],
+) -> Vec<RequestGroup<'a>> {
     let mut groups = BTreeMap::<RequestGroupKey, RequestGroup>::new();
-    for profile in profiles {
+    for &profile in profiles {
         let key = RequestGroupKey {
             metadata: profile.metadata,
             caller: profile.caller,
@@ -537,9 +756,9 @@ fn aggregate_request_profiles(profiles: &[TypeInferenceRequestProfile]) -> Vec<R
     groups
 }
 
-fn aggregate_query_profiles(profiles: &[TypeInferenceQueryProfile]) -> Vec<QueryGroup<'_>> {
+fn aggregate_query_profiles<'a>(profiles: &[&'a TypeInferenceQueryProfile]) -> Vec<QueryGroup<'a>> {
     let mut groups = BTreeMap::<QueryGroupKey, QueryGroup>::new();
-    for profile in profiles {
+    for &profile in profiles {
         let key = QueryGroupKey {
             kind: profile.kind,
             implementation: profile.implementation,
@@ -559,11 +778,11 @@ fn aggregate_query_profiles(profiles: &[TypeInferenceQueryProfile]) -> Vec<Query
     groups
 }
 
-fn aggregate_whole_module_profiles(
-    profiles: &[TypeInferenceWholeModuleProfile],
-) -> Vec<WholeModuleGroup<'_>> {
+fn aggregate_whole_module_profiles<'a>(
+    profiles: &[&'a TypeInferenceWholeModuleProfile],
+) -> Vec<WholeModuleGroup<'a>> {
     let mut groups = BTreeMap::<TypeInferenceWholeModuleReason, WholeModuleGroup>::new();
-    for profile in profiles {
+    for &profile in profiles {
         groups
             .entry(profile.reason)
             .and_modify(|group| group.add(profile))
@@ -579,11 +798,7 @@ fn aggregate_whole_module_profiles(
     groups
 }
 
-impl TypeInferenceProfileLocation {
-    /// Returns whether a record at this location ranks ahead of another record.
-    ///
-    /// Total time takes precedence over maximum time. Equal timings use source
-    /// order so repeated reports choose the same representative location.
+impl crate::type_inference::profiling::TypeInferenceProfileLocation {
     fn is_hotter_than(
         &self,
         total: Duration,
@@ -597,28 +812,54 @@ impl TypeInferenceProfileLocation {
     }
 }
 
+fn record_omitted(
+    visitor: &mut dyn Visit,
+    total: usize,
+    limit: usize,
+    singular: &'static str,
+    plural: &'static str,
+) -> io::Result<()> {
+    let omitted = total.saturating_sub(limit);
+    if omitted > 0 {
+        let label = if omitted == 1 { singular } else { plural };
+        visitor.record_log(
+            LogCategory::None,
+            &markup! { <Dim>{omitted}" "{label}" omitted."</Dim> },
+        )?;
+    }
+    Ok(())
+}
+
 struct Count {
-    count: usize,
+    count: u64,
     singular: &'static str,
     plural: &'static str,
 }
 
 impl Count {
-    const fn source_records(count: usize) -> Self {
+    fn source_records(count: usize) -> Self {
         Self {
-            count,
+            count: count as u64,
             singular: "source record",
             plural: "source records",
         }
     }
 
-    const fn groups(count: usize) -> Self {
+    fn groups(count: usize) -> Self {
         Self {
-            count,
+            count: count as u64,
             singular: "group",
             plural: "groups",
         }
     }
+
+    const fn executions(count: u64) -> Self {
+        Self {
+            count,
+            singular: "execution",
+            plural: "executions",
+        }
+    }
 }
 
 impl Display for Count {
@@ -634,264 +875,3 @@ impl Display for Count {
         ))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use biome_console::fmt::{Display, Formatter, Termcolor};
-    use biome_console::markup;
-    use biome_diagnostics::termcolor::NoColor;
-    use biome_rowan::TextRange;
-
-    use super::CompactTypeInferenceProfile;
-    use crate::type_inference::profiling::{
-        RequestMetadata, TypeInferenceBreadthProfile, TypeInferenceLocationAttribution,
-        TypeInferenceProfileLocation, TypeInferenceProfileSnapshot, TypeInferenceQueryProfile,
-        TypeInferenceRequestProfile, TypeInferenceWholeModuleProfile,
-    };
-    use crate::type_inference::{
-        ArrayOfPromisesClassificationRequest, FunctionReturnTypeRequest, MemberReturnTypeRequest,
-        NormalizedBindingTypeRequest, NormalizedExpressionTypeRequest,
-        PromiseClassificationRequest, TypeInferenceCaller, TypeInferenceCodeReference,
-        TypeInferenceQueryKind, TypeInferenceWholeModuleReason,
-    };
-
-    const IMPLEMENTATION: TypeInferenceCodeReference = TypeInferenceCodeReference::new(
-        "crates/biome_module_graph/src/test.rs",
-        1,
-        "test_implementation",
-    );
-
-    fn render(display: impl Display) -> String {
-        let mut buffer = Vec::new();
-        let mut writer = Termcolor(NoColor::new(&mut buffer));
-        let mut f = Formatter::new(&mut writer);
-        f.write_markup(markup! {{ display }}).unwrap();
-        String::from_utf8(buffer).unwrap()
-    }
-
-    fn location(path: &str, start: u32) -> TypeInferenceProfileLocation {
-        TypeInferenceProfileLocation {
-            path: path.into(),
-            range: Some(TextRange::new(start.into(), (start + 1).into())),
-            attribution: TypeInferenceLocationAttribution::Exact,
-        }
-    }
-
-    fn request_profile(
-        metadata: RequestMetadata,
-        caller: TypeInferenceCaller,
-        path: &str,
-        total: Duration,
-        completed: u32,
-    ) -> TypeInferenceRequestProfile {
-        TypeInferenceRequestProfile {
-            caller,
-            metadata,
-            location: location(path, 1),
-            implementation: IMPLEMENTATION,
-            completed,
-            aborted: 0,
-            total,
-            average: total / completed,
-            min: total / completed,
-            max: total,
-        }
-    }
-
-    #[test]
-    fn groups_request_origins_and_uses_a_weighted_average() {
-        let caller = TypeInferenceCaller::new("nursery", "noFloatingPromises");
-        let snapshot = TypeInferenceProfileSnapshot {
-            requests: vec![
-                request_profile(
-                    RequestMetadata::of::<PromiseClassificationRequest>(),
-                    caller,
-                    "src/first.ts",
-                    Duration::from_millis(2),
-                    2,
-                ),
-                request_profile(
-                    RequestMetadata::of::<PromiseClassificationRequest>(),
-                    caller,
-                    "src/hottest.ts",
-                    Duration::from_millis(6),
-                    3,
-                ),
-            ],
-            ..TypeInferenceProfileSnapshot::default()
-        };
-
-        let output = render(CompactTypeInferenceProfile::new(&snapshot, None, "test"));
-
-        assert!(output.contains("Requests by consumer (top 1 of 1 group; 2 source records)"));
-        assert!(output.contains("time: total 8.000ms, 5 runs, average 1.600ms"));
-        assert!(output.contains("hottest origin: src/hottest.ts:1..2"));
-        assert!(!output.contains("Code references"));
-    }
-
-    #[test]
-    fn request_groups_are_bounded() {
-        let caller = TypeInferenceCaller::new("nursery", "rule");
-        let metadata = [
-            RequestMetadata::of::<NormalizedExpressionTypeRequest>(),
-            RequestMetadata::of::<NormalizedBindingTypeRequest>(),
-            RequestMetadata::of::<PromiseClassificationRequest>(),
-            RequestMetadata::of::<ArrayOfPromisesClassificationRequest>(),
-            RequestMetadata::of::<FunctionReturnTypeRequest>(),
-            RequestMetadata::of::<MemberReturnTypeRequest<'static>>(),
-        ];
-        let snapshot = TypeInferenceProfileSnapshot {
-            requests: metadata
-                .into_iter()
-                .enumerate()
-                .map(|(index, metadata)| {
-                    request_profile(
-                        metadata,
-                        caller,
-                        "src/file.ts",
-                        Duration::from_millis((index + 1) as u64),
-                        1,
-                    )
-                })
-                .collect(),
-            ..TypeInferenceProfileSnapshot::default()
-        };
-
-        let output = render(CompactTypeInferenceProfile::new(&snapshot, None, "test"));
-
-        assert!(output.contains("Requests by consumer (top 5 of 6 groups; 6 source records)"));
-        assert!(output.contains("1 group omitted"));
-        assert!(!output.contains("Normalized expression type <- nursery/rule"));
-    }
-
-    #[test]
-    fn query_group_reports_its_largest_consumer() {
-        let first_caller = TypeInferenceCaller::new("nursery", "firstRule");
-        let second_caller = TypeInferenceCaller::new("nursery", "secondRule");
-        let query = |request, caller, path, millis| TypeInferenceQueryProfile {
-            kind: TypeInferenceQueryKind::Promises,
-            request,
-            caller,
-            location: location(path, 4),
-            implementation: IMPLEMENTATION,
-            completed: 1,
-            aborted: 0,
-            total: Duration::from_millis(millis),
-            average: Duration::from_millis(millis),
-            min: Duration::from_millis(millis),
-            max: Duration::from_millis(millis),
-        };
-        let snapshot = TypeInferenceProfileSnapshot {
-            queries: vec![
-                query(
-                    RequestMetadata::of::<PromiseClassificationRequest>(),
-                    first_caller,
-                    "src/first.ts",
-                    2,
-                ),
-                query(
-                    RequestMetadata::of::<ArrayOfPromisesClassificationRequest>(),
-                    second_caller,
-                    "src/second.ts",
-                    4,
-                ),
-            ],
-            ..TypeInferenceProfileSnapshot::default()
-        };
-
-        let output = render(CompactTypeInferenceProfile::new(&snapshot, None, "test"));
-
-        assert!(output.contains("Promises / test_implementation"));
-        assert!(output.contains("time: total 6.000ms, 2 runs, average 3.000ms"));
-        assert!(
-            output.contains("top consumer: Array of Promises classification <- nursery/secondRule")
-        );
-        assert!(output.contains("hottest source: src/second.ts:4..5"));
-    }
-
-    #[test]
-    fn query_groups_are_bounded() {
-        let snapshot = TypeInferenceProfileSnapshot {
-            queries: (1..=9)
-                .map(|line| TypeInferenceQueryProfile {
-                    kind: TypeInferenceQueryKind::Promises,
-                    request: RequestMetadata::of::<PromiseClassificationRequest>(),
-                    caller: TypeInferenceCaller::new("nursery", "rule"),
-                    location: location("src/file.ts", line),
-                    implementation: TypeInferenceCodeReference::new(
-                        "crates/biome_module_graph/src/test.rs",
-                        line,
-                        "query",
-                    ),
-                    completed: 1,
-                    aborted: 0,
-                    total: Duration::from_millis(u64::from(line)),
-                    average: Duration::from_millis(u64::from(line)),
-                    min: Duration::from_millis(u64::from(line)),
-                    max: Duration::from_millis(u64::from(line)),
-                })
-                .collect(),
-            ..TypeInferenceProfileSnapshot::default()
-        };
-
-        let output = render(CompactTypeInferenceProfile::new(&snapshot, None, "test"));
-
-        assert!(output.contains("Query bodies (top 8 of 9 groups; 9 source records)"));
-        assert!(output.contains("1 group omitted"));
-    }
-
-    #[test]
-    fn whole_module_groups_report_maximum_breadth_and_hottest_transition() {
-        let whole_module =
-            |path, millis, modules, cycle_recoveries| TypeInferenceWholeModuleProfile {
-                reason: TypeInferenceWholeModuleReason::ImportDepthLimit,
-                root: location("src/root.ts", 1),
-                trigger: location(path, 2),
-                implementation: IMPLEMENTATION,
-                completed: 1,
-                aborted: 0,
-                total: Duration::from_millis(millis),
-                average: Duration::from_millis(millis),
-                min: Duration::from_millis(millis),
-                max: Duration::from_millis(millis),
-                modules: TypeInferenceBreadthProfile {
-                    average: modules as f64,
-                    min: modules,
-                    max: modules,
-                },
-                type_slots: TypeInferenceBreadthProfile {
-                    average: 0.0,
-                    min: 0,
-                    max: modules * 10,
-                },
-                expression_slots: TypeInferenceBreadthProfile {
-                    average: 0.0,
-                    min: 0,
-                    max: modules * 20,
-                },
-                binding_slots: TypeInferenceBreadthProfile {
-                    average: 0.0,
-                    min: 0,
-                    max: modules * 5,
-                },
-                cycle_recoveries,
-            };
-        let snapshot = TypeInferenceProfileSnapshot {
-            whole_module_inferences: vec![
-                whole_module("src/first.ts", 2, 3, 1),
-                whole_module("src/hottest.ts", 4, 8, 2),
-            ],
-            ..TypeInferenceProfileSnapshot::default()
-        };
-
-        let output = render(CompactTypeInferenceProfile::new(&snapshot, None, "test"));
-
-        assert!(output.contains("Import depth limit"));
-        assert!(output.contains("time: total 6.000ms, 2 runs, average 3.000ms"));
-        assert!(output.contains("maximum breadth: 8 modules, slots T/E/B 80/160/40"));
-        assert!(output.contains("cycle recoveries: 3"));
-        assert!(output.contains("hottest transition: src/root.ts:1..2 -> src/hottest.ts:2..3"));
-    }
-}
diff --git a/crates/biome_module_graph/src/type_inference/profiling/display/verbose.rs b/crates/biome_module_graph/src/type_inference/profiling/display/verbose.rs
index 14ca0f51b074..5f397f19ade3 100644
--- a/crates/biome_module_graph/src/type_inference/profiling/display/verbose.rs
+++ b/crates/biome_module_graph/src/type_inference/profiling/display/verbose.rs
@@ -1,18 +1,16 @@
-//! Detailed terminal output for type-inference profiles.
-//!
-//! The report prints every captured source record, a short interpretation of
-//! the largest timings, and the Rust locations that produced the records.
+//! Detailed diagnostic advice for type-inference profiles.
 
-use std::collections::BTreeSet;
 use std::io;
 
 use biome_console::fmt::{Display, Formatter};
-use biome_console::{HARD_LINE, HorizontalLine, Padding, markup};
+use biome_console::markup;
+use biome_diagnostics::{Advices, LogCategory, Visit};
 use camino::Utf8Path;
 
+use super::compact::{FileProfiles, FileTitle, ProfileSummary, collect_files};
 use super::{
-    CapacityWarning, DisplayDuration, HighlightedDuration, RECORD_INDENT, SourceLocation,
-    TimingCutoffs, TimingMetrics,
+    HighlightedDuration, QUERY_LIMIT, REQUEST_LIMIT, SourceLocation, SourceRange, TimingCutoffs,
+    TimingMetrics, WHOLE_MODULE_LIMIT, record_capacity_warning,
 };
 use crate::type_inference::TypeInferenceCodeReference;
 use crate::type_inference::profiling::{
@@ -23,99 +21,222 @@ use crate::type_inference::profiling::{
 pub(super) struct VerboseTypeInferenceProfile<'a> {
     snapshot: &'a TypeInferenceProfileSnapshot,
     working_directory: Option<&'a Utf8Path>,
-    version: &'a str,
 }
 
 impl<'a> VerboseTypeInferenceProfile<'a> {
     pub(super) const fn new(
         snapshot: &'a TypeInferenceProfileSnapshot,
         working_directory: Option<&'a Utf8Path>,
-        version: &'a str,
     ) -> Self {
         Self {
             snapshot,
             working_directory,
-            version,
         }
     }
 }
 
-impl Display for VerboseTypeInferenceProfile<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        f.write_markup(markup! {
-            {HorizontalLine::new(20)}
-            <Emphasis>"Type inference profile"</Emphasis>" "<Dim>"(Biome "{self.version}")"</Dim>"\n"
-            <Dim>"Times are inclusive; nested query times must not be added together."</Dim>"\n"
-            <Dim>"Ranges are zero-based, half-open UTF-8 byte offsets."</Dim>"\n"
-            <Dim>"Timings exclude aborted work and profiler aggregation. In sections with at least ten records, the highest 10% are highlighted."</Dim>"\n"
-            <Dim>"Paths may reveal project structure."</Dim>
-            {HARD_LINE}
-        })?;
+impl Advices for VerboseTypeInferenceProfile<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        visitor.record_log(
+            LogCategory::None,
+            &ProfileSummary {
+                snapshot: self.snapshot,
+                verbose: true,
+            },
+        )?;
 
         if self.snapshot.is_empty() {
-            f.write_markup(markup! {
-                "No type-inference requests or queries were recorded.\n"
-                {CapacityWarning(self.snapshot)}
-            })?;
-            return Ok(());
+            visitor.record_log(
+                LogCategory::None,
+                &"No type-inference requests or queries were recorded.",
+            )?;
+            return record_capacity_warning(visitor, self.snapshot);
         }
 
-        f.write_markup(markup! {
-            {RequestProfiles {
-                profiles: &self.snapshot.requests,
-                working_directory: self.working_directory,
-            }}
-            {QueryProfiles {
-                profiles: &self.snapshot.queries,
-                working_directory: self.working_directory,
-            }}
-            {WholeModuleProfiles {
-                profiles: &self.snapshot.whole_module_inferences,
-                working_directory: self.working_directory,
-            }}
-            {ProfileInterpretation {
-                snapshot: self.snapshot,
-                working_directory: self.working_directory,
-            }}
-            {CodeReferences(self.snapshot)}
-            {CapacityWarning(self.snapshot)}
-        })
+        for file in collect_files(self.snapshot) {
+            visitor.record_group(
+                &FileTitle::new(&file, self.working_directory),
+                &VerboseFileAdvice {
+                    file: &file,
+                    working_directory: self.working_directory,
+                },
+            )?;
+        }
+
+        record_capacity_warning(visitor, self.snapshot)
     }
 }
 
-struct RequestProfiles<'a> {
-    profiles: &'a [TypeInferenceRequestProfile],
+struct VerboseFileAdvice<'a> {
+    file: &'a FileProfiles<'a>,
     working_directory: Option<&'a Utf8Path>,
 }
 
-impl Display for RequestProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        if self.profiles.is_empty() {
-            return Ok(());
+impl Advices for VerboseFileAdvice<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        if !self.file.requests.is_empty() {
+            visitor.record_group(
+                &VerboseSectionTitle::new(
+                    "Requests",
+                    self.file.requests.len().min(REQUEST_LIMIT),
+                    self.file.requests.len(),
+                    completed_requests(&self.file.requests),
+                ),
+                &VerboseRequestProfiles {
+                    profiles: &self.file.requests,
+                },
+            )?;
+        }
+
+        if !self.file.queries.is_empty() {
+            visitor.record_group(
+                &VerboseSectionTitle::new(
+                    "Queries",
+                    self.file.queries.len().min(QUERY_LIMIT),
+                    self.file.queries.len(),
+                    completed_queries(&self.file.queries),
+                ),
+                &VerboseQueryProfiles {
+                    profiles: &self.file.queries,
+                },
+            )?;
         }
 
+        let advice = VerboseWholeModuleProfiles {
+            profiles: &self.file.whole_modules,
+            working_directory: self.working_directory,
+        };
+        if self.file.whole_modules.is_empty() {
+            visitor.record_group(&"Whole-module inference", &advice)
+        } else {
+            visitor.record_group(
+                &VerboseSectionTitle::new(
+                    "Whole-module inference",
+                    self.file.whole_modules.len().min(WHOLE_MODULE_LIMIT),
+                    self.file.whole_modules.len(),
+                    completed_whole_modules(&self.file.whole_modules),
+                ),
+                &advice,
+            )
+        }
+    }
+}
+
+fn completed_requests(profiles: &[&TypeInferenceRequestProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_queries(profiles: &[&TypeInferenceQueryProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+fn completed_whole_modules(profiles: &[&TypeInferenceWholeModuleProfile]) -> u64 {
+    profiles
+        .iter()
+        .map(|profile| u64::from(profile.completed))
+        .sum()
+}
+
+struct VerboseSectionTitle {
+    label: &'static str,
+    shown: usize,
+    source_records: usize,
+    executions: u64,
+}
+
+impl VerboseSectionTitle {
+    const fn new(
+        label: &'static str,
+        shown: usize,
+        source_records: usize,
+        executions: u64,
+    ) -> Self {
+        Self {
+            label,
+            shown,
+            source_records,
+            executions,
+        }
+    }
+}
+
+impl Display for VerboseSectionTitle {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            <Emphasis>"Hot request origins"</Emphasis>" "<Dim>"(sorted by cumulative request time)"</Dim>"\n"
-        })?;
-        let cutoffs = TimingCutoffs::new(self.profiles.iter().map(TimingMetrics::from));
-        for profile in self.profiles.iter() {
-            f.write_markup(markup! {
-                {RequestProfileRecord {
+            {self.label}" (top "{self.shown}" of "{SourceRecordCount(self.source_records)}"; "
+            {ExecutionCount(self.executions)}")"
+        })
+    }
+}
+
+struct SourceRecordCount(usize);
+
+impl Display for SourceRecordCount {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        f.write_fmt(format_args!(
+            "{} source {}",
+            self.0,
+            if self.0 == 1 { "record" } else { "records" }
+        ))
+    }
+}
+
+struct ExecutionCount(u64);
+
+impl Display for ExecutionCount {
+    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
+        f.write_fmt(format_args!(
+            "{} {}",
+            self.0,
+            if self.0 == 1 {
+                "execution"
+            } else {
+                "executions"
+            }
+        ))
+    }
+}
+
+struct VerboseRequestProfiles<'a> {
+    profiles: &'a [&'a TypeInferenceRequestProfile],
+}
+
+impl Advices for VerboseRequestProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let cutoffs = TimingCutoffs::new(
+            self.profiles
+                .iter()
+                .map(|profile| TimingMetrics::from(*profile)),
+        );
+        for (index, profile) in self.profiles.iter().take(REQUEST_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &RequestProfileRecord {
+                    index: index + 1,
                     profile,
-                    working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {
-            {HARD_LINE}
-        })
+        record_omitted(
+            visitor,
+            self.profiles.len(),
+            REQUEST_LIMIT,
+            "request source record",
+            "request source records",
+        )
     }
 }
 
 struct RequestProfileRecord<'a> {
+    index: usize,
     profile: &'a TypeInferenceRequestProfile,
-    working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
 }
 
@@ -123,47 +244,49 @@ impl Display for RequestProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let profile = self.profile;
         f.write_markup(markup! {
-            <Info>{profile.metadata.label()}</Info>"\n"
-            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}
-            {Padding::new(RECORD_INDENT)}<Dim>"source: "</Dim>{SourceLocation::new(&profile.location, self.working_directory)}"\n"
-            {Padding::new(RECORD_INDENT)}<Dim>"caller: "</Dim>{profile.caller.group()}"/"{profile.caller.name()}"\n"
+            {self.index}". "<Success>{profile.metadata.label()}</Success>"\n"
+            <Info>"Range: "</Info>{SourceRange(profile.location.range)}"\n"
+            <Info>"Caller: "</Info>{profile.caller.group()}"/"{profile.caller.name()}"\n"
+            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}"\n"
+            {CodeReference::new(profile.implementation)}
         })
     }
 }
 
-struct QueryProfiles<'a> {
-    profiles: &'a [TypeInferenceQueryProfile],
-    working_directory: Option<&'a Utf8Path>,
+struct VerboseQueryProfiles<'a> {
+    profiles: &'a [&'a TypeInferenceQueryProfile],
 }
 
-impl Display for QueryProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        if self.profiles.is_empty() {
-            return Ok(());
-        }
-
-        f.write_markup(markup! {
-            <Emphasis>"Hot inference queries"</Emphasis>" "<Dim>"(tracked query bodies)"</Dim>"\n"
-        })?;
-        let cutoffs = TimingCutoffs::new(self.profiles.iter().map(TimingMetrics::from));
-        for profile in self.profiles.iter() {
-            f.write_markup(markup! {
-                {QueryProfileRecord {
+impl Advices for VerboseQueryProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let cutoffs = TimingCutoffs::new(
+            self.profiles
+                .iter()
+                .map(|profile| TimingMetrics::from(*profile)),
+        );
+        for (index, profile) in self.profiles.iter().take(QUERY_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &QueryProfileRecord {
+                    index: index + 1,
                     profile,
-                    working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {
-            {HARD_LINE}
-        })
+        record_omitted(
+            visitor,
+            self.profiles.len(),
+            QUERY_LIMIT,
+            "query source record",
+            "query source records",
+        )
     }
 }
 
 struct QueryProfileRecord<'a> {
+    index: usize,
     profile: &'a TypeInferenceQueryProfile,
-    working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
 }
 
@@ -171,50 +294,60 @@ impl Display for QueryProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let profile = self.profile;
         f.write_markup(markup! {
-            <Info>{profile.kind.label()}</Info><Dim>" / "</Dim>{profile.implementation.symbol()}"\n"
-            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}
-            {Padding::new(RECORD_INDENT)}<Dim>"source: "</Dim>{SourceLocation::new(&profile.location, self.working_directory)}<Dim>" ("{profile.location.attribution}")"</Dim>"\n"
-            {Padding::new(RECORD_INDENT)}<Dim>"request: "</Dim>{profile.request.label()}"\n"
-            {Padding::new(RECORD_INDENT)}<Dim>"caller: "</Dim>{profile.caller.group()}"/"{profile.caller.name()}"\n"
+            {self.index}". "<Success>{profile.kind.label()}</Success><Dim>" / "</Dim>
+            {profile.implementation.symbol()}"\n"
+            <Info>"Range: "</Info>{SourceRange(profile.location.range)}"\n"
+            <Info>"Attribution: "</Info>{profile.location.attribution}"\n"
+            <Info>"Request: "</Info>{profile.request.label()}"\n"
+            <Info>"Caller: "</Info>{profile.caller.group()}"/"{profile.caller.name()}"\n"
+            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}"\n"
+            {CodeReference::new(profile.implementation)}
         })
     }
 }
 
-struct WholeModuleProfiles<'a> {
-    profiles: &'a [TypeInferenceWholeModuleProfile],
+struct VerboseWholeModuleProfiles<'a> {
+    profiles: &'a [&'a TypeInferenceWholeModuleProfile],
     working_directory: Option<&'a Utf8Path>,
 }
 
-impl Display for WholeModuleProfiles<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        f.write_markup(markup! {
-            <Emphasis>"Whole-module inference"</Emphasis>"\n"
-        })?;
+impl Advices for VerboseWholeModuleProfiles<'_> {
+    fn record(&self, visitor: &mut dyn Visit) -> io::Result<()> {
         if self.profiles.is_empty() {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"No request required complete module tables."
-                {HARD_LINE}
-            })?;
-            return Ok(());
+            return visitor.record_log(
+                LogCategory::None,
+                &"No requests triggered whole-module inference.",
+            );
         }
 
-        let cutoffs = TimingCutoffs::new(self.profiles.iter().map(TimingMetrics::from));
-        for profile in self.profiles.iter() {
-            f.write_markup(markup! {
-                {WholeModuleProfileRecord {
+        let cutoffs = TimingCutoffs::new(
+            self.profiles
+                .iter()
+                .map(|profile| TimingMetrics::from(*profile)),
+        );
+        for (index, profile) in self.profiles.iter().take(WHOLE_MODULE_LIMIT).enumerate() {
+            visitor.record_log(
+                LogCategory::None,
+                &WholeModuleProfileRecord {
+                    index: index + 1,
                     profile,
                     working_directory: self.working_directory,
                     cutoffs,
-                }}
-            })?;
+                },
+            )?;
         }
-        f.write_markup(markup! {
-            {HARD_LINE}
-        })
+        record_omitted(
+            visitor,
+            self.profiles.len(),
+            WHOLE_MODULE_LIMIT,
+            "whole-module source record",
+            "whole-module source records",
+        )
     }
 }
 
 struct WholeModuleProfileRecord<'a> {
+    index: usize,
     profile: &'a TypeInferenceWholeModuleProfile,
     working_directory: Option<&'a Utf8Path>,
     cutoffs: TimingCutoffs,
@@ -224,21 +357,21 @@ impl Display for WholeModuleProfileRecord<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         let profile = self.profile;
         f.write_markup(markup! {
-            <Info>{profile.reason.label()}</Info>"\n"
-            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}
-            {Padding::new(RECORD_INDENT)}<Dim>"root: "</Dim>{SourceLocation::new(&profile.root, self.working_directory)}"\n"
-            {Padding::new(RECORD_INDENT)}<Dim>"trigger: "</Dim>{SourceLocation::new(&profile.trigger, self.working_directory)}"\n"
-            {BreadthMetrics::new("modules", profile.modules)}
-            {BreadthMetrics::new("type slots", profile.type_slots)}
-            {BreadthMetrics::new("expression slots", profile.expression_slots)}
-            {BreadthMetrics::new("binding slots", profile.binding_slots)}
+            {self.index}". "<Success>{profile.reason.label()}</Success>"\n"
+            <Info>"Root range: "</Info>{SourceRange(profile.root.range)}"\n"
+            <Info>"Trigger: "</Info>{SourceLocation::new(&profile.trigger, self.working_directory)}"\n"
+            {TimingMetricsDisplay::new(TimingMetrics::from(profile), self.cutoffs)}"\n"
+            {BreadthMetrics::new("Modules", profile.modules)}"\n"
+            {BreadthMetrics::new("Type slots", profile.type_slots)}"\n"
+            {BreadthMetrics::new("Expression slots", profile.expression_slots)}"\n"
+            {BreadthMetrics::new("Binding slots", profile.binding_slots)}"\n"
         })?;
         if profile.cycle_recoveries > 0 {
             f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}<Dim>"cycle recoveries: "</Dim>{profile.cycle_recoveries}"\n"
+                <Info>"Cycle recoveries: "</Info>{profile.cycle_recoveries}"\n"
             })?;
         }
-        Ok(())
+        CodeReference::new(profile.implementation).fmt(f)
     }
 }
 
@@ -256,11 +389,12 @@ impl TimingMetricsDisplay {
 impl Display for TimingMetricsDisplay {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>"time: total "</Dim>{HighlightedDuration::new(self.metrics.total, self.cutoffs.total)}
-            <Dim>", average "</Dim>{HighlightedDuration::new(self.metrics.average, self.cutoffs.average)}
-            <Dim>", min "</Dim>{HighlightedDuration::new(self.metrics.min, self.cutoffs.min)}
-            <Dim>", max "</Dim>{HighlightedDuration::new(self.metrics.max, self.cutoffs.max)}"\n"
-            {Padding::new(RECORD_INDENT)}<Dim>"runs: "</Dim>{self.metrics.completed}<Dim>" completed, "</Dim>{self.metrics.aborted}<Dim>" aborted"</Dim>"\n"
+            <Info>"Total "</Info>{HighlightedDuration::new(self.metrics.total, self.cutoffs.total)}
+            <Info>", Average "</Info>{HighlightedDuration::new(self.metrics.average, self.cutoffs.average)}
+            <Info>", Min "</Info>{HighlightedDuration::new(self.metrics.min, self.cutoffs.min)}
+            <Info>", Max "</Info>{HighlightedDuration::new(self.metrics.max, self.cutoffs.max)}"\n"
+            <Info>"Executions: "</Info>{self.metrics.completed}<Info>" completed, "</Info>
+            {self.metrics.aborted}<Info>" aborted"</Info>
         })
     }
 }
@@ -279,9 +413,9 @@ impl BreadthMetrics {
 impl Display for BreadthMetrics {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}<Dim>{self.label}": min "</Dim>{self.metrics.min}
-            <Dim>", average "</Dim>{DisplayAverage(self.metrics.average)}
-            <Dim>", max "</Dim>{self.metrics.max}"\n"
+            <Info>{self.label}": Min "</Info>{self.metrics.min}
+            <Info>", Average "</Info>{DisplayAverage(self.metrics.average)}
+            <Info>", Max "</Info>{self.metrics.max}
         })
     }
 }
@@ -294,81 +428,15 @@ impl Display for DisplayAverage {
     }
 }
 
-struct ProfileInterpretation<'a> {
-    snapshot: &'a TypeInferenceProfileSnapshot,
-    working_directory: Option<&'a Utf8Path>,
-}
-
-impl Display for ProfileInterpretation<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        f.write_markup(markup! { <Emphasis>"Interpretation"</Emphasis>"\n" })?;
-        if let Some(request) = self.snapshot.requests.first() {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"The largest cumulative request was "{request.metadata.label()}" at "
-                {SourceLocation::new(&request.location, self.working_directory)}" ("
-                {DisplayDuration(request.total)}" total, "{DisplayDuration(request.max)}" max).\n"
-            })?;
-        }
-        if let Some(query) = self.snapshot.queries.first() {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"The largest inference query was "{query.implementation.symbol()}
-                " in "{query.kind.label()}" ("{DisplayDuration(query.total)}" total, "
-                {DisplayDuration(query.max)}" max).\n"
-            })?;
-        }
-        if let Some(whole_module) = self.snapshot.whole_module_inferences.first() {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"Complete module tables were inferred because of "
-                {whole_module.reason.label()}" at "
-                {SourceLocation::new(&whole_module.trigger, self.working_directory)}
-                ". The widest run covered "{whole_module.modules.max}" modules.\n"
-            })?;
-        } else {
-            f.write_markup(markup! {
-                {Padding::new(RECORD_INDENT)}"No request required complete module tables.\n"
-            })?;
-        }
-        f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}"A high max with a low min indicates an outlier; a high min indicates consistently expensive work."
-            {HARD_LINE}
-        })
-    }
-}
-
-struct CodeReferences<'a>(&'a TypeInferenceProfileSnapshot);
-
-impl Display for CodeReferences<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
-        let mut references = BTreeSet::new();
-        for profile in self.0.requests.iter() {
-            references.insert((profile.metadata.id(), profile.implementation));
-        }
-        for profile in self.0.queries.iter() {
-            references.insert((profile.kind.id(), profile.implementation));
-        }
-        for profile in self.0.whole_module_inferences.iter() {
-            references.insert((profile.reason.id(), profile.implementation));
-        }
-        if references.is_empty() {
-            return Ok(());
-        }
-
-        f.write_markup(markup! { <Emphasis>"Code references"</Emphasis>"\n" })?;
-        for (id, reference) in references {
-            f.write_markup(markup! {
-                {CodeReference { id, reference }}
-            })?;
-        }
-        Ok(())
-    }
-}
-
 struct CodeReference {
-    id: &'static str,
     reference: TypeInferenceCodeReference,
 }
 
 impl CodeReference {
+    const fn new(reference: TypeInferenceCodeReference) -> Self {
+        Self { reference }
+    }
+
     fn repository_path(&self) -> &'static str {
         let file = self.reference.file();
         if let Some(index) = file.find("crates/").or_else(|| file.find("crates\\")) {
@@ -382,9 +450,26 @@ impl CodeReference {
 impl Display for CodeReference {
     fn fmt(&self, f: &mut Formatter<'_>) -> io::Result<()> {
         f.write_markup(markup! {
-            {Padding::new(RECORD_INDENT)}{self.id}"\n"
-            {Padding::new(RECORD_INDENT * 2)}{self.repository_path()}":"{self.reference.line()}
-            " ("{self.reference.symbol()}")\n"
+            <Info>"Implementation: "</Info>{self.repository_path()}":"{self.reference.line()}"\n"
+            <Info>"Symbol: "</Info>{self.reference.symbol()}
         })
     }
 }
+
+fn record_omitted(
+    visitor: &mut dyn Visit,
+    total: usize,
+    limit: usize,
+    singular: &'static str,
+    plural: &'static str,
+) -> io::Result<()> {
+    let omitted = total.saturating_sub(limit);
+    if omitted > 0 {
+        let label = if omitted == 1 { singular } else { plural };
+        visitor.record_log(
+            LogCategory::None,
+            &markup! { <Dim>{omitted}" "{label}" omitted."</Dim> },
+        )?;
+    }
+    Ok(())
+}
diff --git a/crates/biome_module_graph/src/type_inference/registry.rs b/crates/biome_module_graph/src/type_inference/registry.rs
index 6541d103e91e..d65418ad58c0 100644
--- a/crates/biome_module_graph/src/type_inference/registry.rs
+++ b/crates/biome_module_graph/src/type_inference/registry.rs
@@ -22,18 +22,6 @@ pub(crate) enum TypeInferenceQueryKind {
 }
 
 impl TypeInferenceQueryKind {
-    /// Returns the stable profile ID for this query family.
-    pub(crate) const fn id(self) -> &'static str {
-        match self {
-            Self::Lookups => "query.lookups",
-            Self::Exports => "query.exports",
-            Self::Promises => "query.promises",
-            Self::Calls => "query.calls",
-            Self::Normalization => "query.normalization",
-            Self::ModuleTypes => "query.module-types",
-        }
-    }
-
     /// Returns the label rendered in human-readable profiles.
     pub(crate) const fn label(self) -> &'static str {
         match self {
@@ -57,14 +45,6 @@ pub(crate) enum TypeInferenceWholeModuleReason {
 }
 
 impl TypeInferenceWholeModuleReason {
-    /// Returns the stable profile ID for this widening reason.
-    pub(crate) const fn id(self) -> &'static str {
-        match self {
-            Self::ImportDepthLimit => "whole-module.import-depth-limit",
-            Self::InternalDependency => "whole-module.internal-dependency",
-        }
-    }
-
     /// Returns the label rendered in human-readable profiles.
     pub(crate) const fn label(self) -> &'static str {
         match self {
diff --git a/crates/biome_module_graph/src/type_inference/request.rs b/crates/biome_module_graph/src/type_inference/request.rs
index b7e02a4ae655..2de5757fcef3 100644
--- a/crates/biome_module_graph/src/type_inference/request.rs
+++ b/crates/biome_module_graph/src/type_inference/request.rs
@@ -106,7 +106,7 @@ mod private {
 /// different result contracts require distinct request types that each
 /// implement this trait.
 pub trait TypeInferenceRequestMetadata {
-    /// Stable maintenance identifier printed in verbose profiles.
+    /// Stable identifier used to aggregate records for this request contract.
     const ID: &'static str;
 
     /// Concise human-readable label printed in profiles.
diff --git a/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs b/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
index 044d7f79778e..d4e5b62a1482 100644
--- a/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
+++ b/crates/biome_plugin_loader/src/analyzer_grit_plugin.rs
@@ -38,7 +38,9 @@ impl AnalyzerGritPlugin {
         path: &Utf8Path,
         includes: Option<&[NormalizedGlob]>,
     ) -> Result<Self, PluginDiagnostic> {
-        let source = fs.read_file_from_path(path)?;
+        let source = fs.read_file_from_path(path).map_err(|source| {
+            PluginDiagnostic::cant_read_plugin_file(path.to_path_buf(), source)
+        })?;
         let options = CompilePatternOptions::default()
             .with_extra_built_ins(vec![
                 BuiltInFunction::new(
diff --git a/crates/biome_plugin_loader/src/configuration.rs b/crates/biome_plugin_loader/src/configuration.rs
index 1ce116f268be..d2e4510fa600 100644
--- a/crates/biome_plugin_loader/src/configuration.rs
+++ b/crates/biome_plugin_loader/src/configuration.rs
@@ -31,16 +31,43 @@ impl Plugins {
                 PluginConfiguration::Path(path) => path,
                 PluginConfiguration::PathWithOptions(opts) => &mut opts.path,
             };
-            let path_buf = Utf8Path::new(plugin_path.as_str());
-            if path_buf.is_absolute() {
+            if let Some(normalized_path) = normalize_plugin_path(plugin_path, base_dir) {
+                *plugin_path = normalized_path;
+            }
+        }
+    }
+
+    /// Normalizes object-syntax plugin paths with `resolutionKind: "config"` in-place.
+    ///
+    /// For each matching relative path, this joins it with `base_dir` and
+    /// normalizes `.` / `..` segments (without resolving symlinks).
+    ///
+    /// Paths that are already absolute are left unchanged.
+    pub fn normalize_object_relative_paths(&mut self, base_dir: &Utf8Path) {
+        for plugin_config in self.0.iter_mut() {
+            let PluginConfiguration::PathWithOptions(opts) = plugin_config else {
+                continue;
+            };
+            // Only normalize paths for plugins that explicitly opt in to config-relative resolution.
+            if opts.resolution_kind != Some(PluginResolvePath::Config) {
                 continue;
             }
-            let normalized = normalize_path(&base_dir.join(path_buf));
-            *plugin_path = normalized.to_string();
+
+            if let Some(normalized_path) = normalize_plugin_path(&opts.path, base_dir) {
+                opts.path = normalized_path;
+            }
         }
     }
 }
 
+fn normalize_plugin_path(plugin_path: &str, base_dir: &Utf8Path) -> Option<String> {
+    let path_buf = Utf8Path::new(plugin_path);
+    if path_buf.is_absolute() {
+        return None;
+    }
+    Some(normalize_path(&base_dir.join(path_buf)).to_string())
+}
+
 impl FromStr for Plugins {
     type Err = String;
 
@@ -71,7 +98,8 @@ impl DerefMut for Plugins {
 /// {
 ///   "plugins": [
 ///     "simple-plugin.grit",
-///     { "path": "scoped-plugin.grit", "includes": ["src/**/*.ts"] }
+///     { "path": "scoped-plugin.grit", "includes": ["src/**/*.ts"] },
+///     { "path": "./local-plugin.grit", "includes": ["src/**/*.ts"], "resolutionKind": "config" }
 ///   ]
 /// }
 /// ```
@@ -131,6 +159,27 @@ pub struct PluginWithOptions {
     /// these patterns. Use negated globs (e.g., `!**/*.test.ts`) for exclusions.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub includes: Option<Vec<NormalizedGlob>>,
+
+    /// Controls how the plugin is resolved.
+    ///
+    /// This only affects plugin resolution. It does not change how `includes`
+    /// are interpreted.
+    ///
+    /// When omitted, relative plugin paths are resolved from the consuming
+    /// project.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resolution_kind: Option<PluginResolvePath>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, PartialEq, Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase")]
+pub enum PluginResolvePath {
+    /// Resolve relative paths from the consuming project.
+    #[default]
+    Project,
+    /// Resolve relative paths from the configuration file that declared the plugin.
+    Config,
 }
 
 #[cfg(test)]
@@ -178,6 +227,7 @@ mod tests {
             PluginWithOptions {
                 path: "./my-plugin.grit".into(),
                 includes: Some(vec!["src/**/*.ts".parse().unwrap()]),
+                resolution_kind: None,
             },
         )]);
 
@@ -191,6 +241,42 @@ mod tests {
         assert!(plugins.0[0].includes().is_some());
     }
 
+    #[test]
+    fn normalize_object_relative_paths_leaves_string_entries_unchanged() {
+        let base_dir = Utf8Path::new("base");
+        let mut plugins = Plugins(vec![
+            PluginConfiguration::Path("./biome/../biome/my-plugin.grit".into()),
+            PluginConfiguration::PathWithOptions(PluginWithOptions {
+                path: "./default-plugin.grit".into(),
+                includes: None,
+                resolution_kind: None,
+            }),
+            PluginConfiguration::PathWithOptions(PluginWithOptions {
+                path: "./other/../other/object-plugin.grit".into(),
+                includes: None,
+                resolution_kind: Some(PluginResolvePath::Config),
+            }),
+            PluginConfiguration::PathWithOptions(PluginWithOptions {
+                path: "./project-plugin.grit".into(),
+                includes: None,
+                resolution_kind: Some(PluginResolvePath::Project),
+            }),
+        ]);
+
+        plugins.normalize_object_relative_paths(base_dir);
+
+        assert_eq!(plugins.0[0].path(), "./biome/../biome/my-plugin.grit");
+
+        assert_eq!(plugins.0[1].path(), "./default-plugin.grit");
+
+        let config_path = plugins.0[2].path();
+        assert!(Utf8Path::new(config_path).starts_with(base_dir));
+        let expected_suffix = Utf8Path::new("other").join("object-plugin.grit");
+        assert!(Utf8Path::new(config_path).ends_with(expected_suffix.as_path()));
+
+        assert_eq!(plugins.0[3].path(), "./project-plugin.grit");
+    }
+
     #[test]
     fn deserialize_plain_string() {
         let config: PluginConfiguration = serde_json::from_str(r#""my-plugin.grit""#).unwrap();
@@ -215,6 +301,30 @@ mod tests {
         assert!(config.includes().is_none());
     }
 
+    #[test]
+    fn deserialize_object_with_config_resolve_path() {
+        let config: PluginConfiguration =
+            serde_json::from_str(r#"{ "path": "my-plugin.grit", "resolutionKind": "config" }"#)
+                .unwrap();
+        let PluginConfiguration::PathWithOptions(options) = config else {
+            panic!("expected object syntax plugin");
+        };
+        assert_eq!(options.resolution_kind, Some(PluginResolvePath::Config));
+
+        let config = deserialize_from_json_str::<PluginConfiguration>(
+            r#"{ "path": "my-plugin.grit", "resolutionKind": "config" }"#,
+            JsonParserOptions::default(),
+            "",
+        );
+        let (config, diagnostics) = config.consume();
+        assert!(diagnostics.is_empty());
+
+        let Some(PluginConfiguration::PathWithOptions(options)) = config else {
+            panic!("expected object syntax plugin");
+        };
+        assert_eq!(options.resolution_kind, Some(PluginResolvePath::Config));
+    }
+
     #[test]
     fn deserialize_object_missing_path_emits_error() {
         let source = r#"{ "includes": ["src/**"] }"#;
diff --git a/crates/biome_plugin_loader/src/diagnostics.rs b/crates/biome_plugin_loader/src/diagnostics.rs
index 4d8fcec5d3b1..3ec82bfea5b2 100644
--- a/crates/biome_plugin_loader/src/diagnostics.rs
+++ b/crates/biome_plugin_loader/src/diagnostics.rs
@@ -82,6 +82,19 @@ impl From<SyntaxError> for PluginDiagnostic {
 }
 
 impl PluginDiagnostic {
+    pub fn cant_read_plugin_file(path: Utf8PathBuf, source: FileSystemDiagnostic) -> Self {
+        Self::InvalidManifest(InvalidManifest {
+            message: MessageAndDescription::from(
+                markup! {
+                    "Failed to read plugin file "
+                    <Emphasis>{path.to_string()}</Emphasis>
+                }
+                .to_owned(),
+            ),
+            source: Some(Error::from(source)),
+        })
+    }
+
     pub fn cant_resolve(path: Utf8PathBuf, kind: Option<ResolveError>) -> Self {
         Self::CantResolve(CantResolve {
             message: MessageAndDescription::from(
diff --git a/crates/biome_plugin_loader/src/lib.rs b/crates/biome_plugin_loader/src/lib.rs
index 3feac8109125..de87673fcf6d 100644
--- a/crates/biome_plugin_loader/src/lib.rs
+++ b/crates/biome_plugin_loader/src/lib.rs
@@ -49,7 +49,7 @@ impl BiomePlugin {
         base_path: &Utf8Path,
         includes: Option<&[NormalizedGlob]>,
     ) -> Result<(Self, Utf8PathBuf), PluginDiagnostic> {
-        let plugin_path = normalize_path(&base_path.join(plugin_path));
+        let plugin_path = resolve_plugin_path(base_path, plugin_path);
 
         // If the plugin path references a `.grit` file directly, treat it as
         // a single-rule plugin instead of going through the manifest process:
@@ -128,6 +128,17 @@ impl BiomePlugin {
     }
 }
 
+fn resolve_plugin_path(base_path: &Utf8Path, plugin_path: &str) -> Utf8PathBuf {
+    let plugin_path = Utf8Path::new(plugin_path);
+    if plugin_path.is_absolute()
+        || (!base_path.as_str().is_empty() && plugin_path.starts_with(base_path))
+    {
+        normalize_path(plugin_path)
+    } else {
+        normalize_path(&base_path.join(plugin_path))
+    }
+}
+
 /// Checks whether a file path matches the plugin's `includes` globs.
 ///
 /// Returns `true` if `includes` is `None` (no restriction).
@@ -222,6 +233,29 @@ mod test {
         snap_diagnostic("load_plugin_with_wrong_rule_extension", error.into());
     }
 
+    #[test]
+    fn load_plugin_path_already_rooted_at_base_path() {
+        let fs = MemoryFileSystem::default();
+        fs.insert(
+            "node_modules/@shared/config/grit/no-object-assign.grit".into(),
+            r#"`hello`"#,
+        );
+
+        let fs = Arc::new(fs) as Arc<dyn FsWithResolverProxy>;
+        let (plugin, path) = BiomePlugin::load(
+            fs,
+            "node_modules/@shared/config/grit/no-object-assign.grit",
+            Utf8Path::new("node_modules/@shared/config"),
+            None,
+        )
+        .expect("Couldn't load plugin");
+        assert_eq!(plugin.analyzer_plugins.len(), 1);
+        assert_eq!(
+            path,
+            Utf8PathBuf::from("node_modules/@shared/config/grit/no-object-assign.grit")
+        );
+    }
+
     #[test]
     fn load_single_rule_plugin() {
         let fs = MemoryFileSystem::default();
diff --git a/crates/biome_rule_options/src/no_tailwind_arbitrary_value.rs b/crates/biome_rule_options/src/no_tailwind_arbitrary_value.rs
index d3ce3828e717..2c0a32af13c5 100644
--- a/crates/biome_rule_options/src/no_tailwind_arbitrary_value.rs
+++ b/crates/biome_rule_options/src/no_tailwind_arbitrary_value.rs
@@ -2,16 +2,7 @@ use biome_deserialize_macros::{Deserializable, Merge};
 use serde::{Deserialize, Serialize};
 
 /// Options for the `noTailwindArbitraryValue` rule.
-///
-/// Controls which attributes and utility functions are checked for arbitrary values.
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Merge, Eq, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields, default)]
-pub struct NoTailwindArbitraryValueOptions {
-    /// Additional attributes that will be checked.
-    #[serde(skip_serializing_if = "Option::<_>::is_none")]
-    pub attributes: Option<Box<[Box<str>]>>,
-    /// Names of the functions or tagged templates that will be checked.
-    #[serde(skip_serializing_if = "Option::<_>::is_none")]
-    pub functions: Option<Box<[Box<str>]>>,
-}
+pub struct NoTailwindArbitraryValueOptions {}
diff --git a/crates/biome_rule_options/src/use_sorted_attributes.rs b/crates/biome_rule_options/src/use_sorted_attributes.rs
index 452cd174fd4e..5f356080226b 100644
--- a/crates/biome_rule_options/src/use_sorted_attributes.rs
+++ b/crates/biome_rule_options/src/use_sorted_attributes.rs
@@ -8,4 +8,12 @@ use serde::{Deserialize, Serialize};
 pub struct UseSortedAttributesOptions {
     #[serde(skip_serializing_if = "Option::<_>::is_none")]
     pub sort_order: Option<SortOrder>,
+
+    /// A list of attribute names that should be sorted before all other
+    /// attributes, in the order they appear in this list. The remaining
+    /// attributes are sorted after the listed ones.
+    ///
+    /// This is useful to keep attributes such as `key` first.
+    #[serde(skip_serializing_if = "Option::<_>::is_none")]
+    pub sort_first: Option<Box<[Box<str>]>>,
 }
diff --git a/crates/biome_rule_options/src/use_sorted_interface_members.rs b/crates/biome_rule_options/src/use_sorted_interface_members.rs
index 3947d614ed74..879e014ec452 100644
--- a/crates/biome_rule_options/src/use_sorted_interface_members.rs
+++ b/crates/biome_rule_options/src/use_sorted_interface_members.rs
@@ -3,4 +3,10 @@ use serde::{Deserialize, Serialize};
 #[derive(Default, Clone, Debug, Deserialize, Deserializable, Merge, Eq, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields, default)]
-pub struct UseSortedInterfaceMembersOptions {}
+pub struct UseSortedInterfaceMembersOptions {
+    /// When enabled, members separated by a blank line are kept in their own
+    /// section and sorted only within that section. This preserves logical
+    /// groupings the author intentionally introduced with empty lines.
+    #[serde(skip_serializing_if = "Option::<_>::is_none")]
+    pub partition_by_new_line: Option<bool>,
+}
diff --git a/crates/biome_service/src/configuration.rs b/crates/biome_service/src/configuration.rs
index 5e9237641d58..b03965c4ffe3 100644
--- a/crates/biome_service/src/configuration.rs
+++ b/crates/biome_service/src/configuration.rs
@@ -580,6 +580,13 @@ pub trait ConfigurationExt {
     ) -> Result<Vec<Deserialized<Configuration>>, WorkspaceError>;
 
     fn migrate_deprecated_fields(&mut self);
+
+    fn normalize_plugin(
+        &self,
+        config: &mut Configuration,
+        relative_resolution_base_path: Utf8PathBuf,
+        external_resolution_base_path: &Utf8Path,
+    );
 }
 
 impl ConfigurationExt for Configuration {
@@ -728,12 +735,52 @@ impl ConfigurationExt for Configuration {
                     },
                     "",
                 );
-                deserialized_configurations.push(deserialized)
+                let (mut config, diagnostics) = deserialized.consume();
+                if let Some(config) = config.as_mut() {
+                    self.normalize_plugin(
+                        config,
+                        extend_configuration_file_path,
+                        external_resolution_base_path,
+                    );
+                }
+                deserialized_configurations.push(Deserialized::new(config, diagnostics))
             }
         }
         Ok(deserialized_configurations)
     }
 
+    #[cfg(feature = "plugins")]
+    fn normalize_plugin(
+        &self,
+        config: &mut Configuration,
+        extend_configuration_file_path: Utf8PathBuf,
+        external_resolution_base_path: &Utf8Path,
+    ) {
+        let config_dir = extend_configuration_file_path
+            .parent()
+            .unwrap_or(external_resolution_base_path);
+        if let Some(plugins) = config.plugins.as_mut() {
+            plugins.normalize_object_relative_paths(config_dir);
+        }
+        if let Some(overrides) = config.overrides.as_mut() {
+            for pattern in overrides.0.iter_mut() {
+                if let Some(plugins) = pattern.plugins.as_mut() {
+                    // Normalize object-syntax plugin paths only
+                    plugins.normalize_object_relative_paths(config_dir);
+                }
+            }
+        }
+    }
+
+    #[cfg(not(feature = "plugins"))]
+    fn normalize_plugin(
+        &self,
+        _config: &mut Configuration,
+        _relative_resolution_base_path: Utf8PathBuf,
+        _external_resolution_base_path: &Utf8Path,
+    ) {
+    }
+
     /// Checks for the presence of deprecated fields and updates the
     /// configuration to apply them to the new schema.
     fn migrate_deprecated_fields(&mut self) {}
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
index 2605d5a8b968..69922eb1ace0 100644
--- a/crates/biome_service/src/file_handlers/html.rs
+++ b/crates/biome_service/src/file_handlers/html.rs
@@ -234,8 +234,9 @@ impl ServiceLanguage for HtmlLanguage {
         _file_source: &super::DocumentFileSource,
         suppression_reason: Option<&str>,
     ) -> AnalyzerOptions {
-        let configuration =
-            AnalyzerConfiguration::default().with_rules(to_analyzer_rules(global, path.as_path()));
+        let configuration = AnalyzerConfiguration::default()
+            .with_rules(to_analyzer_rules(global, path.as_path()))
+            .with_tailwind(global.tailwind.clone());
 
         AnalyzerOptions::default()
             .with_file_path(path.as_path())
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 2e7f01e42b50..93afc42476bc 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -479,6 +479,7 @@ impl ServiceLanguage for JsLanguage {
         let configuration = configuration
             .with_rules(to_analyzer_rules(global, path.as_path()))
             .with_globals(globals)
+            .with_tailwind(global.tailwind.clone())
             .with_preferred_quote(preferred_quote)
             .with_preferred_jsx_quote(preferred_jsx_quote)
             .with_preferred_indentation(preferred_indentation);
diff --git a/crates/biome_service/src/settings.rs b/crates/biome_service/src/settings.rs
index 6dc120a45946..5d1cca259cce 100644
--- a/crates/biome_service/src/settings.rs
+++ b/crates/biome_service/src/settings.rs
@@ -1,6 +1,6 @@
 use crate::workspace::{FeatureKind, ScanKind};
 use crate::{WorkspaceError, is_dir};
-use biome_analyze::{AnalyzerOptions, AnalyzerRules};
+use biome_analyze::{AnalyzerOptions, AnalyzerRules, options::TailwindOptions};
 #[cfg(feature = "lang_css")]
 use biome_configuration::CssConfiguration;
 #[cfg(feature = "lang_js")]
@@ -98,6 +98,9 @@ pub struct Settings {
     /// The VCS settings of the project
     pub vcs_settings: VcsSettings,
 
+    /// Settings used to recognize Tailwind class strings.
+    pub tailwind: TailwindOptions,
+
     // TODO: remove once HTML full support is stable
     #[cfg(feature = "lang_html")]
     pub experimental_full_html_support: Option<ExperimentalFullSupportEnabled>,
@@ -183,6 +186,10 @@ impl Settings {
             )?;
         }
 
+        if let Some(tailwind) = configuration.tailwind {
+            self.tailwind = tailwind.into();
+        }
+
         // assist part
         if let Some(assist) = configuration.assist {
             self.assist = to_assist_settings(
diff --git a/crates/biome_service/src/workspace.tests.rs b/crates/biome_service/src/workspace.tests.rs
index 31f7ba95e215..349a6037d0a3 100644
--- a/crates/biome_service/src/workspace.tests.rs
+++ b/crates/biome_service/src/workspace.tests.rs
@@ -1061,6 +1061,7 @@ fn correctly_scope_plugin_with_includes() {
                             biome_glob::NormalizedGlob::from_str("**/src/**/*.ts").unwrap(),
                             biome_glob::NormalizedGlob::from_str("!**/*.test.ts").unwrap(),
                         ]),
+                        resolution_kind: None,
                     },
                 )])),
                 ..Default::default()
diff --git a/crates/biome_tailwind_logic/src/lib.rs b/crates/biome_tailwind_logic/src/lib.rs
index 6b93e8f6f25f..4eca9844f6dd 100644
--- a/crates/biome_tailwind_logic/src/lib.rs
+++ b/crates/biome_tailwind_logic/src/lib.rs
@@ -1,2 +1,3 @@
+pub mod no_tailwind_arbitrary_value;
 pub mod syntax_service;
 pub mod use_tailwind_shorthand_classes;
diff --git a/crates/biome_tailwind_logic/src/no_tailwind_arbitrary_value.rs b/crates/biome_tailwind_logic/src/no_tailwind_arbitrary_value.rs
new file mode 100644
index 000000000000..c87631545658
--- /dev/null
+++ b/crates/biome_tailwind_logic/src/no_tailwind_arbitrary_value.rs
@@ -0,0 +1,64 @@
+use biome_rowan::{AstNode, AstNodeList, TextRange};
+use biome_tailwind_syntax::{
+    AnyTwCandidate, AnyTwFullCandidate, AnyTwModifier, AnyTwValue, TwCandidateList,
+};
+
+/// Returns the ranges of arbitrary values and properties in `candidates`.
+/// The ranges are relative to the parsed Tailwind source.
+pub fn analyze_tailwind_arbitrary_values(candidates: &TwCandidateList) -> Vec<TextRange> {
+    let mut results = Vec::new();
+
+    for candidate in candidates.iter() {
+        let AnyTwFullCandidate::TwFullCandidate(candidate) = candidate else {
+            continue;
+        };
+
+        match candidate.candidate() {
+            Ok(AnyTwCandidate::TwArbitraryCandidate(candidate)) => {
+                results.push(candidate.syntax().text_trimmed_range());
+            }
+            Ok(AnyTwCandidate::TwFunctionalCandidate(candidate)) => {
+                push_arbitrary_value_range(&mut results, candidate.value().ok());
+                push_modifier_range(&mut results, candidate.modifier());
+            }
+            _ => {}
+        }
+    }
+
+    results
+}
+
+fn push_arbitrary_value_range(results: &mut Vec<TextRange>, value: Option<AnyTwValue>) {
+    if let Some(AnyTwValue::TwArbitraryValue(value)) = value {
+        results.push(value.syntax().text_trimmed_range());
+    }
+}
+
+fn push_modifier_range(results: &mut Vec<TextRange>, modifier: Option<AnyTwModifier>) {
+    if let Some(AnyTwModifier::TwModifier(modifier)) = modifier {
+        push_arbitrary_value_range(results, modifier.value().ok());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use biome_tailwind_parser::parse_tailwind;
+
+    use super::analyze_tailwind_arbitrary_values;
+
+    #[test]
+    fn finds_arbitrary_values_and_properties() {
+        let parse = parse_tailwind("w-[400px] text-[#555] [color:red] text-red-500/[0.31]");
+        let ranges = analyze_tailwind_arbitrary_values(&parse.tree().candidates());
+
+        assert_eq!(ranges.len(), 4);
+    }
+
+    #[test]
+    fn ignores_arbitrary_variants() {
+        let parse = parse_tailwind("[&:nth-child(3)]:px-2 has-[:checked]:bg-red-500");
+        let ranges = analyze_tailwind_arbitrary_values(&parse.tree().candidates());
+
+        assert!(ranges.is_empty());
+    }
+}
diff --git a/crates/biome_tailwind_logic/src/syntax_service.rs b/crates/biome_tailwind_logic/src/syntax_service.rs
index 12fd4c2639e5..8681bb834de0 100644
--- a/crates/biome_tailwind_logic/src/syntax_service.rs
+++ b/crates/biome_tailwind_logic/src/syntax_service.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 use biome_analyze::{
     AddVisitor, DiagnosticSignal, FromServices, Phase, Phases, QueryMatch, Queryable, RuleCategory,
     RuleKey, RuleMetadata, ServiceBag, ServicesDiagnostic, SignalEntry, SignalRuleKey, Visitor,
-    VisitorContext,
+    VisitorContext, options::TailwindOptions,
 };
 use biome_console::markup;
 use biome_diagnostics::{Diagnostic, MessageAndDescription, panic::catch_unwind};
@@ -168,7 +168,7 @@ fn parse_with_inner(
 }
 
 pub trait TailwindClassStringHost: AstNode {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString>;
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString>;
 }
 
 #[derive(Clone)]
@@ -177,11 +177,14 @@ pub struct TailwindSyntax<N> {
     parse: Rc<TailwindParse>,
 }
 
-pub struct TailwindSyntaxMatch<L: Language>(SyntaxNode<L>);
+pub struct TailwindSyntaxMatch<L: Language> {
+    node: SyntaxNode<L>,
+    class_string: TailwindClassString,
+}
 
 impl<L: Language + 'static> QueryMatch for TailwindSyntaxMatch<L> {
     fn text_range(&self) -> TextRange {
-        self.0.text_trimmed_range()
+        self.node.text_trimmed_range()
     }
 }
 
@@ -254,18 +257,17 @@ where
     }
 
     fn unwrap_match(services: &ServiceBag, node: &Self::Input) -> Self::Output {
-        let node = N::unwrap_cast(node.0.clone());
-        let class_string = node
-            .tailwind_class_string()
-            // SAFETY: The visitor emits matches only for nodes that host a Tailwind class string.
-            .expect("TailwindSyntaxVisitor only emits Tailwind class strings");
+        let ast_node = N::unwrap_cast(node.node.clone());
         let parse = services
             .get_service::<TwSyntaxService>()
             // SAFETY: TailwindSyntaxServices requires this service before the rule can run.
             .expect("TwSyntaxService service is not registered")
-            .parse_for_query(&class_string);
+            .parse_for_query(&node.class_string);
 
-        Self { node, parse }
+        Self {
+            node: ast_node,
+            parse,
+        }
     }
 }
 
@@ -320,7 +322,7 @@ where
         let Some(ast_node) = N::cast_ref(node) else {
             return;
         };
-        let Some(class_string) = ast_node.tailwind_class_string() else {
+        let Some(class_string) = ast_node.tailwind_class_string(ctx.options.tailwind()) else {
             return;
         };
         let Some(service) = ctx.services.get_service::<TwSyntaxService>() else {
@@ -340,7 +342,10 @@ where
         if parsed.should_emit_diagnostics {
             emit_parse_diagnostics(&mut ctx, &class_string, parsed.parse.diagnostics());
         }
-        ctx.match_query(TailwindSyntaxMatch(node.clone()));
+        ctx.match_query(TailwindSyntaxMatch {
+            node: node.clone(),
+            class_string,
+        });
     }
 }
 
@@ -368,12 +373,113 @@ fn emit_parse_diagnostics<L: Language>(
     }
 }
 
+fn matches_function_pattern(pattern: &str, name: &str) -> bool {
+    let mut pattern_parts = pattern.split('.');
+    let mut name_parts = name.split('.');
+    let all_parts_match = pattern_parts
+        .by_ref()
+        .zip(name_parts.by_ref())
+        .all(|(pattern, name)| pattern == "*" || pattern == name);
+    all_parts_match && pattern_parts.next().is_none() && name_parts.next().is_none()
+}
+
 const DEFAULT_FUNCTIONS: [&str; 10] = [
     "clsx", "tw", "twMerge", "twJoin", "cva", "tv", "cn", "cc", "cnb", "ctl",
 ];
 
-fn is_default_function(name: &str) -> bool {
-    DEFAULT_FUNCTIONS.contains(&name)
+fn is_tailwind_function(options: &TailwindOptions, name: &str) -> bool {
+    if let Some(functions) = options.functions() {
+        functions
+            .iter()
+            .any(|pattern| matches_function_pattern(pattern, name))
+    } else {
+        DEFAULT_FUNCTIONS
+            .iter()
+            .any(|pattern| matches_function_pattern(pattern, name))
+    }
+}
+
+fn matches_static_member_function_pattern(
+    pattern: &str,
+    static_member_expression: &JsStaticMemberExpression,
+) -> bool {
+    let mut current = static_member_expression.clone();
+
+    if !pattern.contains('.') {
+        loop {
+            let Ok(object) = current.object() else {
+                return false;
+            };
+            if let Some(identifier) = object.as_js_identifier_expression() {
+                let Ok(name) = identifier.name() else {
+                    return false;
+                };
+                let Ok(name) = name.name() else {
+                    return false;
+                };
+                return pattern == "*" || pattern == name.text();
+            }
+            let Some(static_member) = object.as_js_static_member_expression() else {
+                return false;
+            };
+            current = static_member.clone();
+        }
+    }
+
+    let mut pattern_parts = pattern.rsplit('.');
+    loop {
+        let Some(pattern_part) = pattern_parts.next() else {
+            return false;
+        };
+        let Ok(member) = current.member() else {
+            return false;
+        };
+        let Some(member) = member.as_js_name() else {
+            return false;
+        };
+        let Ok(member) = member.value_token() else {
+            return false;
+        };
+        if pattern_part != "*" && pattern_part != member.text_trimmed() {
+            return false;
+        }
+
+        let Ok(object) = current.object() else {
+            return false;
+        };
+        if let Some(identifier) = object.as_js_identifier_expression() {
+            let Ok(name) = identifier.name() else {
+                return false;
+            };
+            let Ok(name) = name.name() else {
+                return false;
+            };
+            let Some(pattern_part) = pattern_parts.next() else {
+                return false;
+            };
+            return (pattern_part == "*" || pattern_part == name.text())
+                && pattern_parts.next().is_none();
+        }
+        let Some(static_member) = object.as_js_static_member_expression() else {
+            return false;
+        };
+        current = static_member.clone();
+    }
+}
+
+fn is_tailwind_static_member_function(
+    options: &TailwindOptions,
+    static_member_expression: &JsStaticMemberExpression,
+) -> bool {
+    if let Some(functions) = options.functions() {
+        functions.iter().any(|pattern| {
+            matches_static_member_function_pattern(pattern, static_member_expression)
+        })
+    } else {
+        DEFAULT_FUNCTIONS.iter().any(|pattern| {
+            matches_static_member_function_pattern(pattern, static_member_expression)
+        })
+    }
 }
 
 fn get_callee_name(call_expression: &JsCallExpression) -> Option<TokenText> {
@@ -387,25 +493,28 @@ fn get_callee_name(call_expression: &JsCallExpression) -> Option<TokenText> {
         .ok()
 }
 
-fn is_call_expression_of_default_function(call_expression: &JsCallExpression) -> bool {
-    get_callee_name(call_expression).is_some_and(|name| is_default_function(name.text()))
+fn is_call_expression_of_configured_function(
+    call_expression: &JsCallExpression,
+    options: &TailwindOptions,
+) -> bool {
+    if let Some(name) = get_callee_name(call_expression) {
+        return is_tailwind_function(options, name.text());
+    }
+
+    let Ok(callee) = call_expression.callee() else {
+        return false;
+    };
+    let Some(callee) = callee.as_js_static_member_expression() else {
+        return false;
+    };
+    is_tailwind_static_member_function(options, callee)
 }
 
-fn is_static_member_expression_of_default_function(
+fn is_static_member_expression_of_configured_function(
     static_member_expression: &JsStaticMemberExpression,
-) -> Option<bool> {
-    let mut current = static_member_expression.object().ok()?;
-    loop {
-        if let Some(identifier) = current.as_js_identifier_expression() {
-            let name = identifier.name().ok()?.name().ok()?;
-            return Some(is_default_function(name.text()));
-        }
-        if let Some(static_member) = current.as_js_static_member_expression() {
-            current = static_member.object().ok()?;
-            continue;
-        }
-        return Some(false);
-    }
+    options: &TailwindOptions,
+) -> bool {
+    is_tailwind_static_member_function(options, static_member_expression)
 }
 
 fn get_jsx_attribute_name(attribute: &JsxAttribute) -> Option<TokenText> {
@@ -420,24 +529,35 @@ fn get_jsx_attribute_name(attribute: &JsxAttribute) -> Option<TokenText> {
     )
 }
 
-fn is_class_attribute_name(name: &str) -> bool {
-    matches!(name, "class" | "className")
+fn is_configured_attribute(options: &TailwindOptions, name: &str) -> bool {
+    options.attributes().map_or_else(
+        || matches!(name, "class" | "className"),
+        |attributes| {
+            attributes
+                .iter()
+                .any(|attribute| attribute.as_ref() == name)
+        },
+    )
 }
 
-fn inspect_string_literal(node: &SyntaxNode<JsLanguage>) -> Option<bool> {
+fn inspect_string_literal(
+    node: &SyntaxNode<JsLanguage>,
+    options: &TailwindOptions,
+) -> Option<bool> {
     let mut in_arguments = false;
     for ancestor in node.ancestors().skip(1) {
         if let Some(jsx_attribute) = JsxAttribute::cast_ref(&ancestor) {
             let Some(attribute_name) = get_jsx_attribute_name(&jsx_attribute) else {
                 continue;
             };
-            if is_class_attribute_name(attribute_name.text()) {
+            if is_configured_attribute(options, attribute_name.text()) {
                 return Some(true);
             }
         }
 
         if let Some(call_expression) = JsCallExpression::cast_ref(&ancestor) {
-            return in_arguments.then(|| is_call_expression_of_default_function(&call_expression));
+            return in_arguments
+                .then(|| is_call_expression_of_configured_function(&call_expression, options));
         }
 
         if JsCallArguments::can_cast(ancestor.kind()) {
@@ -462,8 +582,8 @@ fn tailwind_class_string(
 }
 
 impl TailwindClassStringHost for JsStringLiteralExpression {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
-        if !inspect_string_literal(self.syntax()).unwrap_or(false) {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
+        if !inspect_string_literal(self.syntax(), options).unwrap_or(false) {
             return None;
         }
         tailwind_class_string(
@@ -476,8 +596,8 @@ impl TailwindClassStringHost for JsStringLiteralExpression {
 }
 
 impl TailwindClassStringHost for JsLiteralMemberName {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
-        if !inspect_string_literal(self.syntax()).unwrap_or(false) {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
+        if !inspect_string_literal(self.syntax(), options).unwrap_or(false) {
             return None;
         }
         tailwind_class_string(
@@ -490,14 +610,14 @@ impl TailwindClassStringHost for JsLiteralMemberName {
 }
 
 impl TailwindClassStringHost for JsxString {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
         let jsx_attribute = self
             .syntax()
             .ancestors()
             .skip(1)
             .find_map(JsxAttribute::cast)?;
         let name = get_jsx_attribute_name(&jsx_attribute)?;
-        if !is_class_attribute_name(name.text()) {
+        if !is_configured_attribute(options, name.text()) {
             return None;
         }
         tailwind_class_string(
@@ -510,14 +630,14 @@ impl TailwindClassStringHost for JsxString {
 }
 
 impl TailwindClassStringHost for JsTemplateChunkElement {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
         for ancestor in self.syntax().ancestors().skip(1) {
             if let Some(template_expression) = JsTemplateExpression::cast_ref(&ancestor) {
                 if let Some(AnyJsExpression::JsIdentifierExpression(tag)) =
                     template_expression.tag()
                 {
                     let name = tag.name().ok()?.name().ok()?;
-                    if is_default_function(name.text()) {
+                    if is_tailwind_function(options, name.text()) {
                         return Some(tailwind_class_string(
                             self.template_chunk_token().ok()?.token_text(),
                             self.template_chunk_token()
@@ -530,7 +650,7 @@ impl TailwindClassStringHost for JsTemplateChunkElement {
                 }
                 if let Some(AnyJsExpression::JsStaticMemberExpression(tag)) =
                     template_expression.tag()
-                    && is_static_member_expression_of_default_function(&tag).unwrap_or(false)
+                    && is_static_member_expression_of_configured_function(&tag, options)
                 {
                     return Some(tailwind_class_string(
                         self.template_chunk_token().ok()?.token_text(),
@@ -545,7 +665,7 @@ impl TailwindClassStringHost for JsTemplateChunkElement {
                 let Some(attribute_name) = get_jsx_attribute_name(&jsx_attribute) else {
                     continue;
                 };
-                if is_class_attribute_name(attribute_name.text()) {
+                if is_configured_attribute(options, attribute_name.text()) {
                     return Some(tailwind_class_string(
                         self.template_chunk_token().ok()?.token_text(),
                         self.template_chunk_token()
@@ -563,9 +683,17 @@ impl TailwindClassStringHost for JsTemplateChunkElement {
 }
 
 impl TailwindClassStringHost for HtmlAttribute {
-    fn tailwind_class_string(&self) -> Option<TailwindClassString> {
+    fn tailwind_class_string(&self, options: &TailwindOptions) -> Option<TailwindClassString> {
         let name = self.name().ok()?.value_token().ok()?;
-        if !name.text_trimmed().eq_ignore_ascii_case("class") {
+        let is_tailwind_attribute = options.attributes().map_or_else(
+            || name.text_trimmed().eq_ignore_ascii_case("class"),
+            |attributes| {
+                attributes
+                    .iter()
+                    .any(|attribute| attribute.as_ref().eq_ignore_ascii_case(name.text_trimmed()))
+            },
+        );
+        if !is_tailwind_attribute {
             return None;
         }
         let html_string = self.html_string()?;
diff --git a/crates/biome_tailwind_syntax/src/lib.rs b/crates/biome_tailwind_syntax/src/lib.rs
index d62ccda774c7..c46a623d73f0 100644
--- a/crates/biome_tailwind_syntax/src/lib.rs
+++ b/crates/biome_tailwind_syntax/src/lib.rs
@@ -2,7 +2,6 @@
 
 #[macro_use]
 mod generated;
-pub mod lint_utils;
 pub mod metadata;
 mod syntax_node;
 mod util;
diff --git a/crates/biome_tailwind_syntax/src/lint_utils.rs b/crates/biome_tailwind_syntax/src/lint_utils.rs
deleted file mode 100644
index 7ed57a620ad3..000000000000
--- a/crates/biome_tailwind_syntax/src/lint_utils.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use biome_rowan::{AstNode, AstNodeList, TextRange, TextSize};
-
-use crate::{AnyTwCandidate, AnyTwFullCandidate, AnyTwModifier, AnyTwValue, TwCandidateList};
-
-/// Core business logic of the `noTailwindArbitraryValue` rule - collects text ranges
-/// of all arbitrary values and arbitrary properties in the given candidate list.
-///
-/// `content_start` is the source offset of the first character of the parsed
-/// string, used to translate parse-relative ranges into source ranges.
-pub fn arbitrary_ranges(candidates: &TwCandidateList, content_start: TextSize) -> Vec<TextRange> {
-    let mut results = Vec::new();
-
-    for candidate in candidates.iter() {
-        let AnyTwFullCandidate::TwFullCandidate(candidate) = candidate else {
-            continue;
-        };
-
-        match candidate.candidate() {
-            Ok(AnyTwCandidate::TwArbitraryCandidate(candidate)) => {
-                let range = candidate.syntax().text_trimmed_range();
-                results.push(range + content_start);
-            }
-            Ok(AnyTwCandidate::TwFunctionalCandidate(candidate)) => {
-                push_arbitrary_value_range(&mut results, content_start, candidate.value().ok());
-                push_modifier_range(&mut results, content_start, candidate.modifier());
-            }
-            _ => {}
-        }
-    }
-
-    results
-}
-
-fn push_arbitrary_value_range(
-    results: &mut Vec<TextRange>,
-    content_start: TextSize,
-    value: Option<AnyTwValue>,
-) {
-    if let Some(AnyTwValue::TwArbitraryValue(value)) = value {
-        let range = value.syntax().text_trimmed_range();
-        results.push(range + content_start);
-    }
-}
-
-fn push_modifier_range(
-    results: &mut Vec<TextRange>,
-    content_start: TextSize,
-    modifier: Option<AnyTwModifier>,
-) {
-    if let Some(AnyTwModifier::TwModifier(modifier)) = modifier {
-        push_arbitrary_value_range(results, content_start, modifier.value().ok());
-    }
-}
diff --git a/crates/biome_yaml_formatter/src/yaml/auxiliary/flow_yaml_node.rs b/crates/biome_yaml_formatter/src/yaml/auxiliary/flow_yaml_node.rs
index 0b018ba90815..86ffb1215be2 100644
--- a/crates/biome_yaml_formatter/src/yaml/auxiliary/flow_yaml_node.rs
+++ b/crates/biome_yaml_formatter/src/yaml/auxiliary/flow_yaml_node.rs
@@ -44,6 +44,15 @@ impl FormatNodeRule<YamlFlowYamlNode> for FormatYamlFlowYamlNode {
             // Without comments the content joins the properties' line even
             // when the source had a line break between them: `!!str\nfoo`
             // becomes `!!str foo`
+            // A line break between the properties and the content is
+            // kept: the parser attaches the properties of a following
+            // block collection to its first key, so joining the lines
+            // would move them onto the key for real:
+            //
+            // ```yaml
+            // - !circle
+            //   center: 1
+            // ```
             if has_middle_comments {
                 write!(
                     f,
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index a8aa809a05cc..fc5ff923fd81 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -77,6 +77,10 @@ export interface Configuration {
 project. By default, this is `true`. 
 	 */
 	root?: Bool;
+	/**
+	 * Configures how Biome recognizes Tailwind class strings.
+	 */
+	tailwind?: TailwindConfiguration;
 	/**
 	 * The version control integration configuration.
 	 */
@@ -376,6 +380,24 @@ match these patterns.
 export type Overrides = OverridePattern[];
 export type Plugins = PluginConfiguration[];
 export type Bool = boolean;
+/**
+ * Configures how Biome recognizes Tailwind class strings.
+ */
+export interface TailwindConfiguration {
+	/**
+	* Attribute names whose values contain Tailwind classes.
+
+Defaults to `class` for HTML and to `class` and `className` for JSX. 
+	 */
+	attributes?: string[];
+	/**
+	* Function and tagged-template names whose arguments contain Tailwind classes.
+
+Defaults to `clsx`, `tw`, `twMerge`, `twJoin`, `cva`, `tv`, `cn`, `cc`,
+`cnb`, and `ctl`. 
+	 */
+	functions?: string[];
+}
 /**
  * Settings for integrating Biome with version control.
  */
@@ -1073,7 +1095,8 @@ Can be either a plain path string or an object with path and options:
 {
   "plugins": [
     "simple-plugin.grit",
-    { "path": "scoped-plugin.grit", "includes": ["src/**\/*.ts"] }
+    { "path": "scoped-plugin.grit", "includes": ["src/**\/*.ts"] },
+    { "path": "./local-plugin.grit", "includes": ["src/**\/*.ts"], "resolutionKind": "config" }
   ]
 }
 ``` 
@@ -1346,6 +1369,16 @@ these patterns. Use negated globs (e.g., `!**\/*.test.ts`) for exclusions.
 	 * The path to the plugin.
 	 */
 	path: string;
+	/**
+	* Controls how the plugin is resolved.
+
+This only affects plugin resolution. It does not change how `includes`
+are interpreted.
+
+When omitted, relative plugin paths are resolved from the consuming
+project. 
+	 */
+	resolutionKind?: PluginResolvePath;
 }
 export type NoDuplicateClassesConfiguration =
 	| RuleAssistPlainConfiguration
@@ -4083,6 +4116,7 @@ See https://biomejs.dev/linter/rules/use-strict-mode
 	useStrictMode?: UseStrictModeConfiguration;
 }
 export type Glob = string;
+export type PluginResolvePath = "project" | "config";
 export type RuleAssistPlainConfiguration = "off" | "on";
 export interface RuleAssistWithNoDuplicateClassesOptions {
 	level: RuleAssistPlainConfiguration;
@@ -5709,10 +5743,25 @@ Default: `natural`.
 	sortBareImports?: boolean;
 }
 export interface UseSortedAttributesOptions {
+	/**
+	* A list of attribute names that should be sorted before all other
+attributes, in the order they appear in this list. The remaining
+attributes are sorted after the listed ones.
+
+This is useful to keep attributes such as `key` first. 
+	 */
+	sortFirst?: string[];
 	sortOrder?: SortOrder;
 }
 export type UseSortedEnumMembersOptions = {};
-export type UseSortedInterfaceMembersOptions = {};
+export interface UseSortedInterfaceMembersOptions {
+	/**
+	* When enabled, members separated by a blank line are kept in their own
+section and sorted only within that section. This preserves logical
+groupings the author intentionally introduced with empty lines. 
+	 */
+	partitionByNewLine?: boolean;
+}
 export interface UseSortedKeysOptions {
 	/**
 	* When enabled, groups object keys by their value's nesting depth before sorting.
@@ -8487,20 +8536,9 @@ export interface NoSvelteUnnecessaryStateWrapOptions {
 	allowReassign?: boolean;
 }
 /**
-	* Options for the `noTailwindArbitraryValue` rule.
-
-Controls which attributes and utility functions are checked for arbitrary values. 
-	 */
-export interface NoTailwindArbitraryValueOptions {
-	/**
-	 * Additional attributes that will be checked.
-	 */
-	attributes?: string[];
-	/**
-	 * Names of the functions or tagged templates that will be checked.
-	 */
-	functions?: string[];
-}
+ * Options for the `noTailwindArbitraryValue` rule.
+ */
+export type NoTailwindArbitraryValueOptions = {};
 export type NoTopLevelLiteralsOptions = {};
 /**
  * Options for the `noUndeclaredClasses` rule.
@@ -10295,6 +10333,7 @@ export type Category =
 	| "reporter/parse"
 	| "reporter/format"
 	| "reporter/violations"
+	| "reporter/profiler"
 	| "parse"
 	| "lint"
 	| "lint/a11y"
diff --git a/packages/@biomejs/biome/configuration_schema.json b/packages/@biomejs/biome/configuration_schema.json
index 523f0eacd8c6..4ac1c660feb7 100644
--- a/packages/@biomejs/biome/configuration_schema.json
+++ b/packages/@biomejs/biome/configuration_schema.json
@@ -67,6 +67,10 @@
 			"description": "Indicates whether this configuration file is at the root of a Biome\nproject. By default, this is `true`.",
 			"anyOf": [{ "$ref": "#/$defs/Bool" }, { "type": "null" }]
 		},
+		"tailwind": {
+			"description": "Configures how Biome recognizes Tailwind class strings.",
+			"anyOf": [{ "$ref": "#/$defs/TailwindConfiguration" }, { "type": "null" }]
+		},
 		"vcs": {
 			"description": "The version control integration configuration.",
 			"anyOf": [{ "$ref": "#/$defs/VcsConfiguration" }, { "type": "null" }]
@@ -5683,20 +5687,8 @@
 			]
 		},
 		"NoTailwindArbitraryValueOptions": {
-			"description": "Options for the `noTailwindArbitraryValue` rule.\n\nControls which attributes and utility functions are checked for arbitrary values.",
+			"description": "Options for the `noTailwindArbitraryValue` rule.",
 			"type": "object",
-			"properties": {
-				"attributes": {
-					"description": "Additional attributes that will be checked.",
-					"type": ["array", "null"],
-					"items": { "type": "string" }
-				},
-				"functions": {
-					"description": "Names of the functions or tagged templates that will be checked.",
-					"type": ["array", "null"],
-					"items": { "type": "string" }
-				}
-			},
 			"additionalProperties": false
 		},
 		"NoTemplateCurlyInStringConfiguration": {
@@ -7777,7 +7769,7 @@
 			"additionalProperties": false
 		},
 		"PluginConfiguration": {
-			"description": "Configuration for a single plugin entry.\n\nCan be either a plain path string or an object with path and options:\n\n```json\n{\n  \"plugins\": [\n    \"simple-plugin.grit\",\n    { \"path\": \"scoped-plugin.grit\", \"includes\": [\"src/**/*.ts\"] }\n  ]\n}\n```",
+			"description": "Configuration for a single plugin entry.\n\nCan be either a plain path string or an object with path and options:\n\n```json\n{\n  \"plugins\": [\n    \"simple-plugin.grit\",\n    { \"path\": \"scoped-plugin.grit\", \"includes\": [\"src/**/*.ts\"] },\n    { \"path\": \"./local-plugin.grit\", \"includes\": [\"src/**/*.ts\"], \"resolutionKind\": \"config\" }\n  ]\n}\n```",
 			"anyOf": [
 				{ "description": "A plain path to the plugin.", "type": "string" },
 				{
@@ -7786,6 +7778,20 @@
 				}
 			]
 		},
+		"PluginResolvePath": {
+			"oneOf": [
+				{
+					"description": "Resolve relative paths from the consuming project.",
+					"type": "string",
+					"const": "project"
+				},
+				{
+					"description": "Resolve relative paths from the configuration file that declared the plugin.",
+					"type": "string",
+					"const": "config"
+				}
+			]
+		},
 		"PluginWithOptions": {
 			"description": "Plugin path with additional options.",
 			"type": "object",
@@ -7795,7 +7801,11 @@
 					"type": ["array", "null"],
 					"items": { "$ref": "#/$defs/NormalizedGlob" }
 				},
-				"path": { "description": "The path to the plugin.", "type": "string" }
+				"path": { "description": "The path to the plugin.", "type": "string" },
+				"resolutionKind": {
+					"description": "Controls how the plugin is resolved.\n\nThis only affects plugin resolution. It does not change how `includes`\nare interpreted.\n\nWhen omitted, relative plugin paths are resolved from the consuming\nproject.",
+					"anyOf": [{ "$ref": "#/$defs/PluginResolvePath" }, { "type": "null" }]
+				}
 			},
 			"additionalProperties": false,
 			"required": ["path"]
@@ -14846,6 +14856,23 @@
 			},
 			"additionalProperties": false
 		},
+		"TailwindConfiguration": {
+			"description": "Configures how Biome recognizes Tailwind class strings.",
+			"type": "object",
+			"properties": {
+				"attributes": {
+					"description": "Attribute names whose values contain Tailwind classes.\n\nDefaults to `class` for HTML and to `class` and `className` for JSX.",
+					"type": ["array", "null"],
+					"items": { "type": "string" }
+				},
+				"functions": {
+					"description": "Function and tagged-template names whose arguments contain Tailwind classes.\n\nDefaults to `clsx`, `tw`, `twMerge`, `twJoin`, `cva`, `tv`, `cn`, `cc`,\n`cnb`, and `ctl`.",
+					"type": ["array", "null"],
+					"items": { "type": "string" }
+				}
+			},
+			"additionalProperties": false
+		},
 		"TestFunctionKind": {
 			"description": "The function to use for tests",
 			"oneOf": [
@@ -16604,6 +16631,11 @@
 		"UseSortedAttributesOptions": {
 			"type": "object",
 			"properties": {
+				"sortFirst": {
+					"description": "A list of attribute names that should be sorted before all other\nattributes, in the order they appear in this list. The remaining\nattributes are sorted after the listed ones.\n\nThis is useful to keep attributes such as `key` first.",
+					"type": ["array", "null"],
+					"items": { "type": "string" }
+				},
 				"sortOrder": {
 					"anyOf": [{ "$ref": "#/$defs/SortOrder" }, { "type": "null" }]
 				}
@@ -16650,6 +16682,12 @@
 		},
 		"UseSortedInterfaceMembersOptions": {
 			"type": "object",
+			"properties": {
+				"partitionByNewLine": {
+					"description": "When enabled, members separated by a blank line are kept in their own\nsection and sorted only within that section. This preserves logical\ngroupings the author intentionally introduced with empty lines.",
+					"type": ["boolean", "null"]
+				}
+			},
 			"additionalProperties": false
 		},
 		"UseSortedKeysConfiguration": {
diff --git a/packages/@biomejs/js-api/README.md b/packages/@biomejs/js-api/README.md
index 7aab21cdd90b..d9306d4a9719 100644
--- a/packages/@biomejs/js-api/README.md
+++ b/packages/@biomejs/js-api/README.md
@@ -22,8 +22,8 @@ You need to install one of the `@biomejs/wasm-*` package as a **peer dependency*
 ```js
 import { Biome } from "@biomejs/js-api/nodejs";
 // Or:
-// import { Biome, Distribution } from "@biomejs/js-api/bundler";
-// import { Biome, Distribution } from "@biomejs/js-api/web";
+// import { Biome } from "@biomejs/js-api/bundler";
+// import { Biome } from "@biomejs/js-api/web";
 
 const biome = new Biome();
 const { projectKey } = biome.openProject("path/to/project/dir");
@@ -53,6 +53,21 @@ const html = biome.printDiagnostics(result.diagnostics, {
 console.log("Lint diagnostics: ", html);
 ```
 
+If you want to work with diagnostics in your program, you can use the `spanInBytesToSpanInCodeUnits` helper function to convert byte-based segments from Biome diagnostics into UTF-16 code unit segments (used in JavaScript).
+
+```js
+import { Biome, spanInBytesToSpanInCodeUnits } from "@biomejs/js-api/nodejs";
+
+for (const diagnostic of result.diagnostics) {
+  const [start, end] = spanInBytesToSpanInCodeUnits(
+    diagnostic.location.span,
+    formatted.content,
+  );
+  // Correctly extracts the text
+  const text = formatted.content.slice(start, end);
+}
+```
+
 ## Philosophy
 
 The project philosophy can be found on our [website](https://biomejs.dev/internals/philosophy/).
diff --git a/packages/@biomejs/js-api/src/bundler.ts b/packages/@biomejs/js-api/src/bundler.ts
index 315aa41ebc77..12447126c2c5 100644
--- a/packages/@biomejs/js-api/src/bundler.ts
+++ b/packages/@biomejs/js-api/src/bundler.ts
@@ -3,6 +3,7 @@ import * as moduleBundler from "@biomejs/wasm-bundler";
 import { BiomeCommon } from "./common";
 
 export type * from "./common";
+export { spanInBytesToSpanInCodeUnits } from "./common";
 export type { Configuration, Diagnostic };
 
 export class Biome extends BiomeCommon<Configuration, Diagnostic> {
diff --git a/packages/@biomejs/js-api/src/nodejs.ts b/packages/@biomejs/js-api/src/nodejs.ts
index 90d5c6fbe2db..8e8a859dfb7e 100644
--- a/packages/@biomejs/js-api/src/nodejs.ts
+++ b/packages/@biomejs/js-api/src/nodejs.ts
@@ -3,6 +3,7 @@ import * as moduleNodeJs from "@biomejs/wasm-nodejs";
 import { BiomeCommon } from "./common";
 
 export type * from "./common";
+export { spanInBytesToSpanInCodeUnits } from "./common";
 export type { Configuration, Diagnostic };
 
 export class Biome extends BiomeCommon<Configuration, Diagnostic> {
diff --git a/packages/@biomejs/js-api/src/web.ts b/packages/@biomejs/js-api/src/web.ts
index 058b54524a8c..4483eb573834 100644
--- a/packages/@biomejs/js-api/src/web.ts
+++ b/packages/@biomejs/js-api/src/web.ts
@@ -3,6 +3,7 @@ import * as moduleWeb from "@biomejs/wasm-web";
 import { BiomeCommon } from "./common";
 
 export type * from "./common";
+export { spanInBytesToSpanInCodeUnits } from "./common";
 export type { Configuration, Diagnostic };
 
 export class Biome extends BiomeCommon<Configuration, Diagnostic> {
diff --git a/packages/tailwindcss-config-analyzer/src/generate-tailwind-preset.ts b/packages/tailwindcss-config-analyzer/src/generate-tailwind-preset.ts
index bb07b103fe2f..086d49d72611 100644
--- a/packages/tailwindcss-config-analyzer/src/generate-tailwind-preset.ts
+++ b/packages/tailwindcss-config-analyzer/src/generate-tailwind-preset.ts
@@ -9,7 +9,7 @@ import { type SortConfig, sortConfigFromSpec } from "./sort-config.js";
 
 const ROOT_PACKAGE_NAME = "@biomejs/monorepo";
 const OUTPUT_PATH =
-	"crates/biome_js_analyze/src/lint/nursery/use_sorted_classes/tailwind_preset.rs";
+	"crates/biome_analyze/src/shared/sorted_classes/tailwind_preset.rs";
 
 const EXCLUDED_LAYERS = ["defaults", "base"];
 const LAYER_ORDER = ["components", "utilities"];
@@ -17,7 +17,7 @@ const LAYER_ORDER = ["components", "utilities"];
 const LINE_LIMIT = 100;
 const INDENT = "    ";
 const FILE_HEADER = `//! DO NOT EDIT MANUALLY - this file is autogenerated from the default Tailwind CSS config.
-//! To update, run \`pnpm gen:tailwind-preset\` from \`packages/@biomejs/tailwindcss-config-analyzer\`.
+//! To update, run \`just gen-tw\` from the repository root.
 
 use super::sort_config::UtilityLayer;
 `;