crates/biome_service/src/file_handlers/javascript.rs (1)

991-1004: Make conflicting-rule list deterministic

HashSet::into_iter() gives us an arbitrary order, so the diagnostic message will reshuffle between runs. Sorting (or using BTreeSet) before formatting keeps the output stable.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-10-02T12:56:59.418Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : When deriving Diagnostic for an enum, ensure each variant contains a type that is itself a diagnostic

crates/biome_service/src/file_handlers/javascript.rs (1)

874-874: Solid infinite loop detection!

The implementation correctly detects pathological fix cycles by tracking iterations and collecting the likely culprits. The logic flow is sound: the counter increments only after successful fix application, and the loop naturally exits before incrementing if no fixes remain.

The collection of the last 10 fixes and HashSet deduplication is a pragmatic approach to identifying conflicting rules.

Optionally, consider extracting 50 as a named constant (e.g., MAX_FIX_ITERATIONS) to make the threshold more discoverable and easier to adjust if needed:

+const MAX_FIX_ITERATIONS: usize = 50;
+
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
     // ...
     loop {
         // ...
         loops += 1;
-        if loops > 50 {
+        if loops > MAX_FIX_ITERATIONS {

Also applies to: 983-1006

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/file_handlers/javascript.rs (1)

988-990: Maybe soften the comment tone

The detection logic is lovely, but the comment’s swear jar moment might age poorly in the repo. Fancy rephrasing it without the profanity so future readers don’t get a jump-scare?

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/file_handlers/javascript.rs (3)

874-884: Heuristic is good; add a cycle fallback to catch “ping‑pong” loops

Stable-size oscillations won’t trip growth/accel streaks. Consider a lightweight cycle detector (e.g. repeat of the same (rule, range.start, range.end) sequence K times) or a generous hard ceiling with telemetry before bailing with the same error.

Can you confirm if you’ve observed ping‑pong loops in #7711 reproduction? If yes, I can sketch a minimal range‑based cycle check.

---

969-986: Guard growth on empty baseline

When prev_len == 0, every change counts as “growth” and will build a streak from an empty file. Gate the check on prev_len > 0.

Apply this small tweak:

-                    if curr_len.saturating_mul(RATIO_Q) >= prev_len.saturating_mul(RATIO_GROWTH) {
+                    if prev_len > 0
+                        && curr_len.saturating_mul(RATIO_Q) >= prev_len.saturating_mul(RATIO_GROWTH)
+                    {

---

875-876: Tiny tidy‑up

initial_len is only used to seed prev_len. Inline it to reduce locals.

-    let initial_len: u32 = tree.syntax().text_range_with_trivia().len().into();
-    let mut prev_len = initial_len;
+    let mut prev_len: u32 = tree.syntax().text_range_with_trivia().len().into();

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/file_handlers/javascript.rs (1)

962-984: Own the rule IDs and make output deterministic (and tweak comment)

• Storing &Cow then cloning yields &Cow, not Cow — mismatches the error’s expected type.
• Sort for stable diagnostics.
• Fix typo/wording.

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conclicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).
 
-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
-                                seen_rules.insert((group, rule));
+                                seen_rules.insert(((*group).clone(), (*rule).clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules
-                                    .into_iter()
-                                    .map(|(g, r)| (g.clone(), r.clone()))
-                                    .collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

Also consider extracting a small helper to DRY this across handlers.

crates/biome_analyze/src/diagnostics.rs (1)

249-279: Improve message readability: add paragraph breaks

The three write_markup calls currently run together. Insert explicit separators between them.

Apply:

         fmt.write_markup(markup! {
             "An internal error occurred when analyzing this file."
         })?;
+        fmt.write_markup(markup! { "\n\n" })?;
         fmt.write_markup(markup! {
             {self}
         })?;
+        fmt.write_markup(markup! { "\n\n" })?;
         fmt.write_markup(markup! {
             "This is likely a bug in Biome, not an error in your code. Please consider filing an issue on "<Hyperlink href="https://github.com/biomejs/biome/issues/new/choose">"GitHub"</Hyperlink>" with a reproduction of this error."
         })?;

crates/biome_service/src/utils/mod.rs (1)

1-1: Scope the module to the crate

Make the module pub(crate) to avoid exposing an otherwise crate‑private utility in the public API surface.

-pub mod growth_guard;
+pub(crate) mod growth_guard;

crates/biome_service/src/file_handlers/json.rs (2)

46-46: Make diagnostics deterministic: prefer BTreeSet over HashSet

Stable ordering avoids flaky messages/tests and eases triage.

Apply:

-use std::collections::HashSet;
+use std::collections::BTreeSet;

---

719-741: Deterministic rule list + tidy comment

• Use BTreeSet (or sort) so listed rules are consistently ordered.
• Fix typo and tone in the comment (“conclicting” → “conflicting”; avoid profanity).

Apply:

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules = BTreeSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
                                 seen_rules.insert((group, rule));
                             }
                         }

                         return Err(WorkspaceError::RuleError(
                             RuleError::ConflictingRuleFixesError {
                                 rules: seen_rules
                                     .into_iter()
                                     .map(|(g, r)| (g.clone(), r.clone()))
                                     .collect(),
                             },
                         ));

And reword the preceding comment:

-                        // We limit it to the last 10 fixes. If there is a chain of conclicting fixes longer than that, something is **really** fucked up.
+                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is severely broken.

crates/biome_analyze/src/diagnostics.rs (2)

299-301: Consistent capitalisation

Match console Display and other branches.

Apply:

-                    return std::write!(fmt, "conflicting rule fixes detected");
+                    return std::write!(fmt, "Conflicting rule fixes detected.");

---

303-311: Optional: sort rule names for stable output

Helps avoid flaky snapshots and eases scanning.

Example change:

-                let rules_list = rules
-                    .iter()
-                    .map(|(group, rule)| format!("'{group}/{rule}'"))
-                    .collect::<Vec<_>>()
-                    .join(", ");
+                let mut items = rules
+                    .iter()
+                    .map(|(group, rule)| format!("'{group}/{rule}'"))
+                    .collect::<Vec<_>>();
+                items.sort_unstable();
+                let rules_list = items.join(", ");

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/file_handlers/css.rs (1)

715-737: Own the Cows and sort; fix comment wording.

The current code has several issues already flagged in a previous review:

• Line 725 inserts borrowed &Cow references, then lines 731-734 clone them, yielding borrowed Cows instead of owned ones.
• HashSet iteration is non-deterministic, producing unstable output.
• Line 720 contains unprofessional language.

Apply this diff:

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conclicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
-                                seen_rules.insert((group, rule));
+                                seen_rules.insert(((*group).clone(), (*rule).clone()));
                             }
                         }

-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules
-                                    .into_iter()
-                                    .map(|(g, r)| (g.clone(), r.clone()))
-                                    .collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

crates/biome_service/src/file_handlers/javascript.rs (1)

962-984: Own the Cows and sort; fix comment wording.

The current code has the same issues as in css.rs:

• Line 972 inserts borrowed &Cow references, then lines 978-981 clone them, yielding borrowed Cows instead of owned ones.
• HashSet iteration is non-deterministic.
• Line 967 contains unprofessional language.

Apply the same diff as in css.rs:

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conclicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
-                                seen_rules.insert((group, rule));
+                                seen_rules.insert(((*group).clone(), (*rule).clone()));
                             }
                         }

-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules
-                                    .into_iter()
-                                    .map(|(g, r)| (g.clone(), r.clone()))
-                                    .collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

Note: As ematipico suggested, consider extracting this detection logic into a shared helper function to eliminate duplication across file handlers.

crates/biome_analyze/src/diagnostics.rs (1)

249-279: Add paragraph breaks between messages.

Lines 268-276 concatenate three messages without spacing, producing run-on text (…file.The…This…).

Apply this diff:

         fmt.write_markup(markup! {
             "An internal error occurred when analyzing this file."
         })?;
+        fmt.write_markup(markup! {
+            "\n\n"
+        })?;
         fmt.write_markup(markup! {
             {self}
         })?;
+        fmt.write_markup(markup! {
+            "\n\n"
+        })?;
         fmt.write_markup(markup! {
             "This is likely a bug in Biome, not an error in your code. Please consider filing an issue on "<Hyperlink href="https://github.com/biomejs/biome/issues/new/choose">"GitHub"</Hyperlink>" with a reproduction of this error."
         })?;

crates/biome_analyze/src/diagnostics.rs (1)

281-314: Capitalisation inconsistency across error types.

Lines 289 and 295 capitalise differently ("The rule" vs "A code action"), whilst line 300 uses lowercase ("conflicting") but line 335 uses uppercase ("Conflicting"). Consider harmonising the style.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/file_handlers/graphql.rs (1)

619-638: Make diagnostics deterministic and tidy the comment

Own the Cows (you already do), but sort the collected pairs for stable output; also tweak the comment wording.

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
-                                seen_rules.insert((group.clone(), rule.clone()));
+                                seen_rules.insert((group.clone(), rule.clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules.into_iter().collect(),
-                            },
-                        ));
+                        // Deterministic output
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

Optional: extract this “collect last N rule pairs” into a small helper (e.g. utils) to reuse across handlers.

crates/biome_service/src/file_handlers/css.rs (1)

715-734: Stable error output and comment tone

Sort the collected pairs for deterministic diagnostics; soften the wording.

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
                                 seen_rules.insert((group.clone(), rule.clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules.into_iter().collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

crates/biome_service/src/file_handlers/javascript.rs (1)

962-981: Deterministic rule list and tidy comment

Same story: sort the deduped pairs; adjust the comment.

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
                                 seen_rules.insert((group.clone(), rule.clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules.into_iter().collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

If you fancy DRYness, extract this into a small helper under utils and reuse across handlers.

crates/biome_analyze/src/diagnostics.rs (1)

268-276: Mind the missing paragraph breaks

Right now the three write_markup calls concatenate straight on, so the rendered copy comes out as “file.The…This…”. Please drop a "\n\n" (or similar separator) between the sections to keep the paragraphs readable.

         fmt.write_markup(markup! {
             "An internal error occurred when analyzing this file."
         })?;
+        fmt.write_markup(markup! {
+            "\n\n"
+        })?;
         fmt.write_markup(markup! {
             {self}
         })?;
+        fmt.write_markup(markup! {
+            "\n\n"
+        })?;
         fmt.write_markup(markup! {
             "This is likely a bug in Biome, not an error in your code. Please consider filing an issue on "<Hyperlink href="https://github.com/biomejs/biome/issues/new/choose">"GitHub"</Hyperlink>" with a reproduction of this error."
         })?;

crates/biome_service/src/utils/growth_guard.rs (1)

43-55: Prefer widened maths over saturating for ratio checks

Saturating mul can skew comparisons near the upper range. Cast to u64 for products; keep saturating_add for streaks.

-        // Check for multiplicative growth
-        if new.saturating_mul(RATIO_Q) >= self.previous.saturating_mul(RATIO_GROWTH) {
+        // Check for multiplicative growth (avoid overflow by widening)
+        if (new as u64) * (RATIO_Q as u64)
+            >= (self.previous as u64) * (RATIO_GROWTH as u64)
+        {
             self.growth_streak = self.growth_streak.saturating_add(1);
         } else {
             self.growth_streak = 0;
         }

-        // Check for delta acceleration
-        if diff.saturating_mul(RATIO_Q) >= self.previous_diff.saturating_mul(RATIO_ACCEL)
-            && self.previous_diff > 0
+        // Check for delta acceleration (guard first, then compare widened products)
+        if self.previous_diff > 0
+            && (diff as u64) * (RATIO_Q as u64)
+                >= (self.previous_diff as u64) * (RATIO_ACCEL as u64)
         {
             self.accel_streak = self.accel_streak.saturating_add(1);
         } else {
             self.accel_streak = 0;
         }

crates/biome_service/src/file_handlers/json.rs (1)

719-738: Deterministic diagnostic ordering and cleaner wording

Sort the deduped rule pairs before returning to keep output stable; adjust comment to be professional.

-                    // Check for runaway edit growth
+                    // Check for runaway edit growth
                     let curr_len: u32 = tree.syntax().text_range_with_trivia().len().into();
                     if !growth_guard.check(curr_len) {
-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
                                 seen_rules.insert((group.clone(), rule.clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules.into_iter().collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));
                     }

Bonus: consider a shared helper to avoid repetition across handlers.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.126Z
Learning: Applies to crates/biome_analyze/**/lib/src/{lint,assist}/**/*.rs : Mark code blocks in documentation with a language and required properties (e.g., expect_diagnostic for invalid snippets; options/full_options/use_options as needed). Each invalid snippet must emit exactly one diagnostic

crates/biome_analyze/src/diagnostics.rs (1)

268-276: Add paragraph breaks to the diagnostic message

The three consecutive write_markup calls run together, producing text like "…file.The…This…". Insert separators between them for readability.

crates/biome_service/src/file_handlers/css.rs (1)

715-734: Own the Cows, sort for stability, and clean up the comment

Same issues as flagged for GraphQL:

• group.clone() and rule.clone() on &Cow refs produce refs, not owned values.
• HashSet iteration order is arbitrary; sort the vec before returning.
• Line 720 comment needs wording cleanup (remove profanity, fix typo if present).

Apply this diff to fix ownership and ordering:

-                        let mut seen_rules = HashSet::new();
+                        let mut seen_rules: HashSet<(Cow<'static, str>, Cow<'static, str>)> =
+                            HashSet::new();
                         for action in actions.iter().rev().take(10) {
                             if let Some((group, rule)) = action.rule_name.as_ref() {
-                                seen_rules.insert((group.clone(), rule.clone()));
+                                seen_rules.insert(((*group).clone(), (*rule).clone()));
                             }
                         }
 
-                        return Err(WorkspaceError::RuleError(
-                            RuleError::ConflictingRuleFixesError {
-                                rules: seen_rules.into_iter().collect(),
-                            },
-                        ));
+                        let mut rules: Vec<_> = seen_rules.into_iter().collect();
+                        rules.sort_unstable();
+                        return Err(WorkspaceError::RuleError(
+                            RuleError::ConflictingRuleFixesError { rules },
+                        ));

Update the comment to remove profanity and clarify intent:

-                        // In order to provide a useful diagnostic, we want to flag the rules that caused the conflict.
-                        // We can do this by inspecting the last few fixes that were applied.
-                        // We limit it to the last 10 fixes. If there is a chain of conflicting fixes longer than that, something is **really** fucked up.
+                        // Provide a useful diagnostic by flagging rules implicated in the conflict.
+                        // Inspect the last few fixes that were applied (limit to the last 10).

crates/biome_service/src/file_handlers/graphql.rs (1)

619-638: Own the Cows, sort for stability, and clean up the comment

Identical issues as CSS:

• group.clone() and rule.clone() on &Cow refs produce refs, not owned values.
• HashSet iteration order is arbitrary; sort the vec before returning.
• Comment wording needs cleanup (remove profanity, fix typo).

Apply the same diff as in CSS to fix ownership and ordering, then update the comment text for clarity.

crates/biome_service/src/file_handlers/css.rs (1)

715-734: Consider extracting a helper to reduce duplication

This growth‑check‑and‑collect‑rules pattern appears in CSS, GraphQL, and JSON handlers. Extracting it to a small helper in utils would avoid repetition.

crates/biome_service/src/utils/growth_guard.rs (1)

1-70: LGTM! Consider monitoring threshold effectiveness

The implementation is solid: saturating operations prevent overflow, and the dual‑streak tracking (multiplicative growth + delta acceleration) provides robust runaway detection.

The constants (RATIO_GROWTH = 150, RATIO_ACCEL = 180, STREAK_LIMIT = 10) are heuristic choices. Monitor real‑world behaviour to confirm they strike the right balance between catching genuine runaways and avoiding false positives.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.126Z
Learning: Applies to crates/biome_analyze/**/lib/src/{lint,assist}/**/*.rs : Mark code blocks in documentation with a language and required properties (e.g., expect_diagnostic for invalid snippets; options/full_options/use_options as needed). Each invalid snippet must emit exactly one diagnostic