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

517-529: DRY up: have Display delegate to as_str.

Avoid duplicating the string mapping in two places.

You can simplify the Display impl (lines 438–452) to:

impl Display for RuleDomain {
    fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {
        fmt.write_str(self.as_str())
    }
}

Also consider a tiny round‑trip test ensuring from_str(x).unwrap().as_str() == x for all domains.

Happy to draft the tests if useful.

---

531-547: Make parsing case-insensitive and trim input; unify error text.

This will reduce CLI foot‑guns (e.g. -->

Apply:

 impl FromStr for RuleDomain {
     type Err = &'static str;

     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
+        let s = s.trim().to_ascii_lowercase();
+        match s.as_str() {
             "react" => Ok(Self::React),
             "test" => Ok(Self::Test),
             "solid" => Ok(Self::Solid),
             "next" => Ok(Self::Next),
             "qwik" => Ok(Self::Qwik),
             "vue" => Ok(Self::Vue),
             "project" => Ok(Self::Project),
             "tailwind" => Ok(Self::Tailwind),
-
-            _ => Err("Invalid rule domain"),
+            _ => Err("This domain doesn't exist."),
         }
     }
 }

The error message now matches crates/biome_configuration/src/analyzer/mod.rs for consistency.

.changeset/wet-results-talk.md (1)

5-19: Polish the changeset: punctuation + link the issue.

Keeps to the project’s “end sentences with a period” rule and references the issue.

-For example, the following command will only run the rules that belong to the [next](https://biomejs.dev/linter/domains/#next) domain:
+For example, run the following command to only run rules in the [next](https://biomejs.dev/linter/domains/#next) domain.
 
 ```shell
 biome lint -->

-Another example, the following command will skip the rules that belong to the project domain:
+For example, run the following command to skip rules in the project domain.

biome lint --skip=project

+Closes #6880.

</blockquote></details>
<details>
<summary>crates/biome_cli/tests/cases/linter_domains.rs (1)</summary><blockquote>

`359-414`: **Strengthen the “enable via CLI” test by disabling the domain in config**

To prove `-- truly enables the domain irrespective of config, set the domain to `"none"` in `biome.json`. That avoids the config already enabling it.


Apply this minimal diff to the embedded JSON:

```diff
-        "domains": {
-            "test": "all"
-        }
+        "domains": {
+            "test": "none"
+        }

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

519-526: Rename local var to ‘selectors’ for clarity (avoids confusion with rule lists).

The field is still named enabled_rules, but you’re now passing selectors. Renaming the local binding improves readability.

-        enabled_rules: rules,
+        enabled_rules: selectors,
...
-            .with_enabled_selectors(&rules)
+            .with_enabled_selectors(&selectors)

Also applies to: 578-586, 624-631

crates/biome_service/src/configuration.rs (1)

904-912: Nice coverage, but add a domain‑selector case.

Please add a test proving that --skip=project avoids project scans even when the project domain is enabled via config.

Proposed test to add under this module’s tests:

#[test]
fn should_not_scan_project_when_project_domain_is_skipped_via_cli() {
    let configuration = Configuration {
        linter: Some(LinterConfiguration {
            // Simulate config that would otherwise require project analysis
            domains: {
                let mut d = FxHashMap::default();
                d.insert(RuleDomain::Project, RuleDomainValue::Recommended);
                Some(RuleDomains(d))
            },
            ..Default::default()
        }),
        ..Default::default()
    };

    // Skip the entire project domain via CLI
    let scan = ProjectScanComputer::new(&configuration)
        .with_rule_selectors(
            // Any Domain(Project) selector here
            &[
                // Replace with the actual constructor once available, e.g.:
                // AnalyzerSelector::from(DomainSelector::Project)
            ],
            &[],
        )
        .compute();

    assert_ne!(scan, ScanKind::Project, "skip=project should prevent project scan");
}

Once AnalyzerSelector domain construction is confirmed, I can wire the exact selector.

Also applies to: 933-941

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

765-769: Same naming nit as CSS: prefer ‘selectors’ over ‘rules’.

Avoids mixing the old “rules” wording with the new selector API.

-        enabled_rules: rules,
+        enabled_rules: selectors,
...
-            .with_enabled_selectors(&rules)
+            .with_enabled_selectors(&selectors)

Also applies to: 776-783

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

576-576: Minor naming mismatch: rules are selectors here.

enabled_rules: rules is now passed to with_enabled_selectors. Consider renaming the binding to selectors for clarity.

-        enabled_rules: rules,
+        enabled_rules: selectors,
...
-            .with_enabled_selectors(&rules)
+            .with_enabled_selectors(&selectors)

---

625-625: Consistent terminology in fix-all.

Same nit as above: params.enabled_rules now carries selectors. Consider renaming the field or local binding when you touch the API next to avoid cognitive load.

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

487-487: Rename the local for readability.

enabled_rules: rules → used as selectors. Renaming to selectors improves intent.

-        enabled_rules: rules,
+        enabled_rules: selectors,
...
-            .with_enabled_selectors(&rules)
+            .with_enabled_selectors(&selectors)

---

533-533: Same terminology nit in fix-all.

params.enabled_rules now represents selectors; consider harmonising names across handlers when feasible.

xtask/codegen/src/generate_configuration.rs (5)

22-25: Great addition: domain → rules index.

Nice choice of BTreeMap/BTreeSet for stable, deterministic output. Note: the doc says (<group>/<rule>, ...) but the type is actually (group, rule); tweak wording for precision when you’re nearby.

-    /// e.g next => (<group>/<rule>, <group>/<rule>)
+    /// e.g. next => ((<group>, <rule>), (<group>, <rule>))

---

43-48: Domain collection is JS-only; intentional?

You populate domains in the JS visitor only. If non-JS languages ever tag rules with domains, we’ll miss them. Low-effort future-proofing would be to mirror this loop in the JSON/CSS/GraphQL visitors.

 impl RegistryVisitor<JsonLanguage> for LintRulesVisitor {
@@
     fn record_rule<R>(&mut self)
     where
         R: Rule<Options: Default, Query: Queryable<Language = JsonLanguage, Output: Clone>>
             + 'static,
     {
         self.groups
             .entry(<R::Group as RuleGroup>::NAME)
             .or_default()
             .insert(R::METADATA.name, R::METADATA);
+        for domain in R::METADATA.domains.iter() {
+            self.domains
+                .entry(domain.as_str())
+                .or_default()
+                .insert((<R::Group as RuleGroup>::NAME, R::METADATA.name));
+        }
     }
 }

---

1143-1149: Prefer static slices over LazyLock<Vec<...>> for zero-allocation access.

The generated contents are compile-time known. You can emit &'static [RuleFilter] and avoid the runtime LazyLock and later clone.

-        lazy_locks.push(quote! {
-            static #domain_filters: LazyLock<Vec<RuleFilter<'static>>> = LazyLock::new(|| {
-                vec![
-                    #( #vector ),*
-                ]
-            });
-        });
+        lazy_locks.push(quote! {
+            static #domain_filters: &[RuleFilter<'static>] = &[
+                #( #vector ),*
+            ];
+        });

And then adjust call sites accordingly:

-            #domain_as_string => #domain_filters.clone()
+            #domain_as_string => #domain_filters.to_vec()

---

1160-1176: Nit: error message mentions DomainFilter.

The type here is DomainSelector. Minor copy edit.

-                    _ => unreachable!(
-                        "DomainFilter::as_rule_filters: domain {} not found",
+                    _ => unreachable!(
+                        "DomainSelector::as_rule_filters: domain {} not found",
                         self.0
                     )

---

1178-1187: Consistency: unknown domain branch.

Here it returns false, above it panics. Consider aligning behaviours (both unreachable! or both graceful), depending on how DomainSelector is constructed. If it’s validated on construction, unreachable! is fine.

-                    _ => false,
+                    _ => unreachable!("DomainSelector::match_rule: domain {} not found", self.0),

crates/biome_service/src/workspace.rs (2)

921-927: Prefer “selectors” terminology (rules or domains) in docs and names.

Fields now accept domains, but still read “enabled_rules”. Consider renaming to enabled_selectors in the public API on the next breaking bump; at minimum, update the docstrings now to avoid confusion.

Apply docstring tweak:

--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@
-    /// Rules to apply on top of the configuration
+    /// Selectors (rules or domains) to apply on top of the configuration
@@
-    /// Rules to apply to the file
+    /// Selectors (rules or domains) to apply to the file

Also applies to: 949-956, 1022-1028

---

1637-1651: Expose enabled_selectors in FileGuard::pull_diagnostics.

You added enabled_rules to PullDiagnosticsParams but the FileGuard wrapper drops it. Mirror pull_actions and thread it through.

Apply this diff:

@@ pub fn pull_diagnostics(
-    pub fn pull_diagnostics(
+    pub fn pull_diagnostics(
         &self,
         categories: RuleCategories,
         only: Vec<AnalyzerSelector>,
         skip: Vec<AnalyzerSelector>,
+        enabled_rules: Vec<AnalyzerSelector>,
         pull_code_actions: bool,
     ) -> Result<PullDiagnosticsResult, WorkspaceError> {
         self.workspace.pull_diagnostics(PullDiagnosticsParams {
             project_key: self.project_key,
             path: self.path.clone(),
             categories,
             only,
             skip,
-            enabled_rules: vec![],
+            enabled_rules,
             pull_code_actions,
         })
     }

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

1465-1486: Nit: parameter name mismatch.

with_enabled_selectors takes enabled_rules. Rename the argument for clarity.

Apply:

-    pub(crate) fn with_enabled_selectors(mut self, enabled_rules: &'b [AnalyzerSelector]) -> Self {
-        self.enabled_selectors = Some(enabled_rules);
+    pub(crate) fn with_enabled_selectors(mut self, enabled_selectors: &'b [AnalyzerSelector]) -> Self {
+        self.enabled_selectors = Some(enabled_selectors);
         self
     }

crates/biome_configuration/src/analyzer/mod.rs (1)

699-748: DomainSelector serde is fine; tiny micro-optimisation available.

You can avoid format! in serialisation.

Apply:

-        serializer.serialize_str(&format!("{self}"))
+        serializer.serialize_str(self.0)

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : When porting from other linters, declare `sources: &[RuleSource::<...>]` in `declare_lint_rule!` using `.same()` or `.inspired()` as appropriate

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/lib/src/lint/nursery/*.rs : For new JavaScript lint rules generated by `just new-js-lintrule`, implement the rule in the generated file under `biome_js_analyze/lib/src/lint/nursery/`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : If a rule is deprecated, set the `deprecated:` field in `declare_lint_rule!` with a reason and alternative

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : In `declare_lint_rule!` declarations, set `version: "next"`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Choose an appropriate `severity` in `declare_lint_rule!` (default is info); use `Severity::Error` for hard errors, `Warning` for potential issues, `Information` for style

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : Define per-rule options in the `biome_rule_options` crate under `lib/`, with serde- and schemars-compatible derives and `#[serde(rename_all = "camelCase", deny_unknown_fields, default)]`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/tests/quick_test.rs : Use `biome_js_analyze/tests/quick_test.rs` for quick, ad-hoc testing; un-ignore the test and adjust the rule filter as needed

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : If a rule provides a code action, add `fix_kind` in `declare_lint_rule!` and use `ctx.action_category(ctx.category(), ctx.group())` and `ctx.metadata().applicability()` when constructing actions

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/tests/spec_test.rs : Create tests/spec_test.rs implementing the run(spec_input_file, _expected_file, test_directory, _file_type) function as shown and include!("language.rs")

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_service/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:53:15.299Z
Learning: Applies to crates/biome_service/../biome_lsp/src/server.tests.rs : Keep end-to-end LSP tests in biome_lsp’s server.tests.rs

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use the local `rule_category!()` macro in diagnostics for the rule’s category, not string-parsed categories

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Use helper advice types from biome_diagnostics::v2 (CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice) when suitable

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Specify category and severity using #[diagnostic(...)] on the type or derive them from fields

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Types implementing Diagnostic must also implement Debug (e.g., use #[derive(Debug, Diagnostic)])

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/crates/biome_diagnostics_categories/src/categories.rs : When declaring a new diagnostic category, register it in crates/biome_diagnostics_categories/src/categories.rs

crates/biome_configuration/src/analyzer/mod.rs (1)

530-541: Doctests reference the wrong type (should use RuleSelector).

This will fail doctests; same note as earlier review.

-    /// use biome_configuration::analyzer::{AnalyzerSelector, RuleSelector};
+    /// use biome_configuration::analyzer::RuleSelector;
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("source", "useSortedKeys").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("source", "useSortedKeys"));
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("style", "useConst").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("style", "useConst"));
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("a11y", "useAltText").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("a11y", "useAltText"));

crates/biome_configuration/src/analyzer/mod.rs (2)

416-497: AnalyzerSelector design looks solid; make FromStr return more helpful errors.

Currently returns a generic message, losing RuleSelector’s detailed errors. Prefer bubbling up the specific rule error if domain parsing also fails.

 impl FromStr for AnalyzerSelector {
     type Err = &'static str;

     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        RuleSelector::from_str(s)
-            .map(Self::Rule)
-            .or(DomainSelector::from_str(s).map(Self::Domain))
-            .or(Err("The rule, group or domain doesn't exist."))
+        match RuleSelector::from_str(s) {
+            Ok(rule) => Ok(Self::Rule(rule)),
+            Err(rule_err) => match DomainSelector::from_str(s) {
+                Ok(domain) => Ok(Self::Domain(domain)),
+                Err(_) => Err(rule_err),
+            },
+        }
     }
 }

---

699-748: DomainSelector looks good; tiny serialisation nit.

Avoid allocating via format! during serialisation.

 impl serde::Serialize for DomainSelector {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(&format!("{self}"))
+        serializer.serialize_str(self.0)
     }
 }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : Define per-rule options in the `biome_rule_options` crate under `lib/`, with serde- and schemars-compatible derives and `#[serde(rename_all = "camelCase", deny_unknown_fields, default)]`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/tests/quick_test.rs : Use `biome_js_analyze/tests/quick_test.rs` for quick, ad-hoc testing; un-ignore the test and adjust the rule filter as needed

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : If a rule provides a code action, add `fix_kind` in `declare_lint_rule!` and use `ctx.action_category(ctx.category(), ctx.group())` and `ctx.metadata().applicability()` when constructing actions

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Use helper advice types from biome_diagnostics::v2 (CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice) when suitable

crates/biome_configuration/src/analyzer/mod.rs (1)

543-554: Doctest still references the wrong type here.

These examples sit under RuleSelector::from_lsp_filter but call AnalyzerSelector::from_lsp_filter. Unless that function definitely exists and is preferred here, this will fail or confuse readers. Use RuleSelector in the examples.

-    /// use biome_configuration::analyzer::{AnalyzerSelector, RuleSelector};
+    /// use biome_configuration::analyzer::RuleSelector;
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("source", "useSortedKeys").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("source", "useSortedKeys"));
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("style", "useConst").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("style", "useConst"));
@@
-    /// let selector = AnalyzerSelector::from_lsp_filter(filter).unwrap();
-    /// assert_eq!(selector, RuleSelector::Rule("a11y", "useAltText").into());
+    /// let selector = RuleSelector::from_lsp_filter(filter).unwrap();
+    /// assert_eq!(selector, RuleSelector::Rule("a11y", "useAltText"));

crates/biome_service/src/configuration.rs (2)

720-722: API change is fine; consider minor ergonomics.

Accepting &[AnalyzerSelector] works. Optionally accept impl IntoIterator<Item = AnalyzerSelector> to avoid callers needing temporary vecs.

-    pub fn with_rule_selectors(
-        mut self,
-        skip: &'a [AnalyzerSelector],
-        only: &'a [AnalyzerSelector],
-    ) -> Self {
+    pub fn with_rule_selectors<I1, I2>(mut self, skip: I1, only: I2) -> Self
+    where
+        I1: IntoIterator<Item = AnalyzerSelector>,
+        I2: IntoIterator<Item = AnalyzerSelector>,
+    {
-        self.skip = skip;
-        self.>
+        // store into owned Vecs if you go this route; adjust struct fields accordingly
+        // self.skip = skip.into_iter().collect();
+        // self.>
         self
     }

---

949-971: Domain “only” tests are great; add a skip-domain case too?

Consider adding --skip=project coverage to show we avoid project scans when all project-domain rules are excluded.

+    #[test]
+    fn should_not_return_project_if_project_domain_is_skipped() {
+        let configuration = Configuration::default();
+        assert_eq!(
+            ProjectScanComputer::new(&configuration)
+                .with_rule_selectors(&[DomainSelector("project").into()], &[])
+                .compute(),
+            ScanKind::NoScanner
+        );
+    }

crates/biome_configuration/src/analyzer/mod.rs (1)

752-756: Avoid alloc in DomainSelector serialisation.

Use the inner &'static str directly.

 impl serde::Serialize for DomainSelector {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(&format!("{self}"))
+        serializer.serialize_str(self.0)
     }
 }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use `domains` in `declare_lint_rule!` when applicable; recommended rules with domains enable only when the domain is active

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : Define per-rule options in the `biome_rule_options` crate under `lib/`, with serde- and schemars-compatible derives and `#[serde(rename_all = "camelCase", deny_unknown_fields, default)]`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/tests/quick_test.rs : Use `biome_js_analyze/tests/quick_test.rs` for quick, ad-hoc testing; un-ignore the test and adjust the rule filter as needed

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_service/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:53:15.299Z
Learning: Applies to crates/biome_service/../biome_lsp/src/server.tests.rs : Keep end-to-end LSP tests in biome_lsp’s server.tests.rs

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/tests/spec_test.rs : Create tests/spec_test.rs implementing the run(spec_input_file, _expected_file, test_directory, _file_type) function as shown and include!("language.rs")

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/tests/spec_tests.rs : Create tests/spec_tests.rs in the biome_html_formatter crate that generates tests via tests_macros::gen_tests! for all HTML files at tests/specs/html/**/*.html

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Choose an appropriate `severity` in `declare_lint_rule!` (default is info); use `Severity::Error` for hard errors, `Warning` for potential issues, `Information` for style

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : If a rule provides a code action, add `fix_kind` in `declare_lint_rule!` and use `ctx.action_category(ctx.category(), ctx.group())` and `ctx.metadata().applicability()` when constructing actions

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Use helper advice types from biome_diagnostics::v2 (CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice) when suitable