.github/workflows/main.yml (1)

95-95: Also test the default feature set (optional).

Running only --features=js_plugin means we no longer exercise the default build on main. Consider running both to catch regressions early.

Minimal tweak:

-        run: cargo test --workspace --features=js_plugin
+        run: |
+          cargo test --workspace
+          cargo test --workspace --features=js_plugin

If runtime is a concern, a small matrix over features is another tidy option.

.github/workflows/pull_request.yml (1)

88-88: Exercise both default and js_plugin paths on PRs (optional).

Same story here: only testing the feature build may hide default-config breakage. Suggest running both.

Quick win:

-        run: cargo test --workspace --features=js_plugin
+        run: |
+          cargo test --workspace
+          cargo test --workspace --features=js_plugin

Bonus: you may want to include packages/** and plugins/** in paths: so JS-only changes still trigger CI.

crates/biome_js_runtime/Cargo.toml (2)

1-11: Consider inheriting the crate version from the workspace.

To keep versions consistent during releases, consider switching to workspace-inherited package metadata if the root defines workspace.package.

Proposed change:

 [package]
@@
-name                 = "biome_js_runtime"
+name                 = "biome_js_runtime"
@@
-version              = "0.0.1"
+version.workspace    = true

If the workspace doesn’t yet define workspace.package.version, keep 0.0.1 but ensure your release tooling bumps this crate in lockstep with the others.

---

1-11: Decide whether this crate is publishable now.

If biome_js_runtime isn’t meant to be published during the preview, add publish = false to avoid accidental publication; if it is, ignore this note.

Example:

 [package]
@@
 license.workspace    = true
 name                 = "biome_js_runtime"
 repository.workspace = true
-version              = "0.0.1"
+version              = "0.0.1"
+publish              = false

packages/@biomejs/plugin-api/LICENSE-APACHE (1)

189-201: Year range nit: align copyright year.

Optional: update the copyright year (currently 2023) to either the current year or a range (e.g., 2023–2025) for consistency across packages.

packages/@biomejs/plugin-api/index.d.ts (1)

1-3: Tighten typings and document severity mapping.

Two small improvements:

• Add JSDoc to clarify how severities map to Biome/LSP severities and how they’re handled at runtime.
• Consider a const enum or exported union object to help editors with completions; alternatively, keep the union but validate unknown values at runtime on the Rust side.

Example (non-breaking):

-export type Severity = "fatal" | "error" | "warning" | "information" | "hint";
+/**
+ * Diagnostic severity recognised by Biome’s JS plugin runtime.
+ * Unknown values should be rejected at runtime.
+ */
+export type Severity = "fatal" | "error" | "warning" | "information" | "hint";
 
-export function addDiagnostic(severity: Severity, message: string): void;
+/**
+ * Push a diagnostic from a JS plugin.
+ * @param severity Diagnostic severity.
+ * @param message Human-readable message to show to users.
+ */
+export function addDiagnostic(severity: Severity, message: string): void;

Runtime action item: ensure boa-side implementation rejects/normalises unexpected severities and adds tests for each variant.

packages/@biomejs/plugin-api/package.json (3)

1-11: Include index.js in files (now or before publish).

exports.default and main point to ./index.js, but it isn’t listed under "files". It’s fine while "private": true, but will bite later if you flip this to publish. Safer to include it now.

   "files": [
     "README.md",
     "LICENSE-APACHE",
     "LICENSE-MIT",
-    "index.d.ts"
+    "index.d.ts",
+    "index.js"
   ],

---

12-19: index.js throwing at import is deliberate — add a hint in package metadata.

Because the runtime provides a virtual module, index.js throws when loaded outside Biome. Consider adding a short note in README to explain this to plugin authors.

Happy to draft the README snippet explaining resolution via the Biome runtime vs Node.

---

30-32: Peer dependency on @biomejs/biome — is it required?

Given this package is types-only and the runtime injects the module, the peer dep on @biomejs/biome may not add value. If kept, please document the rationale; otherwise, consider removing to reduce noise for plugin authors later.

crates/biome_plugin_loader/src/thread_local.rs (4)

28-33: Minor: use a direct cast for pointer type

Not a bug, but we can avoid the const pointer and Some() verbosity. The API accepts a pointer; a simple cast keeps it tidy and avoids questions about mutability.

-            let result = unsafe { win32::FlsSetValue(self.inner, Some(value as *const c_void)) };
+            let result = unsafe { win32::FlsSetValue(self.inner, value as *const c_void) };

---

76-80: Promote failure checks to hard errors on Unix

pthread_setspecific can fail (EINVAL/ENOMEN). A debug_assert risks dropping failures in release. Prefer assert with a message to surface issues early.

-            let result = unsafe { libc::pthread_setspecific(self.inner, value as *mut c_void) };
-
-            debug_assert_eq!(result, 0);
+            let result = unsafe { libc::pthread_setspecific(self.inner, value as *mut c_void) };
+            assert_eq!(result, 0, "pthread_setspecific failed: {}", result);

---

124-140: Intentional per-thread leak: document trade-offs and provide an escape hatch

The comment calls out that values aren’t dropped on thread exit, which implies a per-thread leak. That’s likely fine for long-lived worker threads, but can surprise test code and short-lived threads.

• Please expand the doc comment to state the leak explicitly and why it’s chosen.
• Consider exposing a cfg(test) only clear() to drop the current thread’s value safely.

Example (outside the shown range):

#[cfg(test)]
impl<T> ThreadLocalCell<T> {
    /// Drops the current thread's value (tests only).
    pub fn clear(&self) {
        unsafe {
            let ptr = self.key.get();
            if !ptr.is_null() {
                drop(Box::from_raw(ptr)); // drop RefCell<T>
                self.key.set(std::ptr::null_mut());
            }
        }
    }
}

---

101-107: Make ThreadLocalCell Sync so it can be shared across threads

Analyzer plugins are typically shared (Arc) across worker threads. The TLS key is process-wide and operations are thread-safe-by-design; marking Sync enables ergonomic sharing.

Add this (outside the shown range):

// Safe: all access is per-thread via TLS; no cross-thread aliasing of the inner RefCell<T>.
unsafe impl<T> Sync for ThreadLocalCell<T> {}

If you prefer belt-and-braces, gate it with T: 'static to mirror the no-destructor design.

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

43-51: Parity between Grit and JS compile diagnostics

Grit compile errors preserve the original error as source, whereas JS errors currently don’t (see below). Keeping behaviour consistent improves downstream reporting.

If biome_diagnostics::Error can’t wrap boa_engine::JsError directly, consider storing a stringified version as a source via a lightweight error wrapper type, or attach it as advice.

---

54-64: Preserve underlying Boa error for richer reporting

Message is helpful, but we lose stack/location by dropping the source. Either wrap the js error as a source or add advice (e.g. LogAdvice) with value.to_string().

For example:

 #[cfg(feature = "js_plugin")]
 impl From<boa_engine::JsError> for PluginDiagnostic {
     fn from(value: boa_engine::JsError) -> Self {
         Self::Compile(CompileDiagnostic {
             message: MessageAndDescription::from(
                 markup! {"Failed to compile the JS plugin: "{value.to_string()}}.to_owned(),
             ),
-            source: None,
+            // If Error::from(value) isn’t available, consider wrapping value.to_string()
+            // into a structured error wrapper or attach it as advice instead.
+            source: None,
         })
     }
 }

Happy to draft a tiny wrapper error if you’d like.

biome.json (1)

27-27: Including plugins/*.js is sensible; watch for noUndeclaredDependencies

With this file now linted, imports like "@biomejs/plugin-api" inside plugins/*.js may trigger correctness/noUndeclaredDependencies since plugins/ isn’t a package. Two options:

• Add an override to disable that rule for plugins/*.js, or
• Add a minimal package.json in plugins/ declaring @biomejs/plugin-api as a devDependency.

Example override (outside the shown range):

{
  "overrides": [
    {
      "include": ["plugins/*.js"],
      "linter": {
        "rules": { "correctness": { "noUndeclaredDependencies": "off" } }
      }
    }
  ]
}

plugins/plugin.js (1)

3-8: Tighten sample logic and avoid name shadowing.

Minor polish: use early-return to reduce nesting and rename the parameter to filePath to avoid confusion with Node’s path module.

Apply:

-/** @param {string} path */
-export default function useMyPlugin(path) {
-	if (path.endsWith("plugin.js")) {
-		addDiagnostic("warning", "Hello, world!");
-	}
-}
+/** @param {string} filePath */
+export default function useMyPlugin(filePath) {
+	if (!filePath.endsWith("plugin.js")) return;
+	addDiagnostic("warning", "Hello, world!");
+}

crates/biome_js_runtime/src/lib.rs (1)

1-6: Public re-exports look tidy.

Clear surface area via pub use with private modules. Consider a short crate-level doc to explain the Boa-based runtime and how modules are loaded; future-you will thank you.

crates/biome_service/src/workspace/server.rs (1)

491-496: Arc handoff looks correct; tiny style nit

Passing self.fs.clone() to the new BiomePlugin::load(Arc<dyn FsWithResolverProxy>, …) is spot on. If you want to make the intent extra explicit, consider Arc::clone(&self.fs) (purely stylistic).

crates/biome_js_runtime/src/plugin_api.rs (1)

40-47: Consider including a stable category and optional code for plugin diagnostics

Right now every diagnostic is category!("plugin"). That’s fine for a POC, but you may want category!("plugin/{name}") or a rule code (e.g. with_category/with_code) so users can target-suppress per-plugin in future.

Would you like me to sketch a minimal plugin “name” plumbed from the loader to prefix the category?

crates/biome_js_runtime/src/module_loader.rs (2)

56-60: Enhance diagnostics by naming the module in Module::parse

If Module::parse accepts an optional identifier/source name, pass the specifier (or resolved path) so stack traces and error messages show the module name.

---

40-47: Base dir fallback

unwrap_or_default() gives an empty path; resolution libraries sometimes treat that oddly. Consider defaulting to the process working directory or / explicitly if working_directory() is None.

crates/biome_plugin_loader/src/lib.rs (2)

62-75: JS plugin detection: consider .mts (and explicitly not .cjs)

You accept .js/.mjs. If you anticipate TS-in-JS plugin transpilation or ESM variants, you might add .mts later. Deliberately skipping .cjs makes sense given ESM-only loader.

Do we want to document the accepted extensions now to avoid plugin author confusion?

---

97-115: Manifest rule extension check

Using ends_with(b".grit") works but is a tad brittle. rule.extension() == Some("grit") reads clearer and is platform-neutral.

Apply this small refactor?

-                .map(|rule| {
-                    if rule.as_os_str().as_encoded_bytes().ends_with(b".grit") {
+                .map(|rule| {
+                    if rule.extension().is_some_and(|ext| ext == "grit") {

crates/biome_plugin_loader/src/analyzer_js_plugin.rs (2)

27-39: load_plugin ergonomics

LGTM for the core flow (context → import → default export check). Optional: attach the plugin path/specifier to the TypeError message for better UX.

---

72-108: Good per-thread isolation; consider passing the AST soon

Thread-local context + function entrypoint is a sensible MVP. There’s already a TODO to pass the AST; doing so early will help stabilise the JS API shape.

crates/biome_js_runtime/src/context.rs (3)

1-8: Drop unused import and minor nitpick on Rc cloning

• The ModuleLoader import (Line 5) isn’t used in this file; this will trip clippy -D warnings in CI.
• Style: Rc::clone(&module_loader) (Line 27) can be module_loader.clone().

Apply:

- use boa_engine::module::ModuleLoader;

Optional style tweak:

-            .module_loader(Rc::clone(&module_loader))
+            .module_loader(module_loader.clone())

---

91-96: Default export type is unchecked; consider a function-specific accessor

Downstream code likely expects the default export to be callable. Returning a raw JsValue pushes type errors later and makes crashes more mysterious.

Option A (add a helper, keep current API):

// Add alongside get_default_export
pub fn get_default_export_function(&mut self, module: &Module) -> JsResult<JsFunction> {
    let value = self.get_default_export(module)?;
    let ctx = &mut self.inner;
    let obj = value.as_object().ok_or_else(|| {
        JsNativeError::typ()
            .with_message("Default export is not an object/function")
            .into()
    })?;
    if let Some(func) = obj.as_function() {
        Ok(func.clone())
    } else {
        Err(JsNativeError::typ().with_message("Default export is not a function").into())
    }
}

If Boa’s API differs, adjust to the available “is callable/as function” helpers.

---

98-105: Call surface is fine; optional ergonomics

Passing an explicit this is flexible, but most plugin functions won’t need it. A convenience call_function_undefined_this (or defaulting this internally) can reduce boilerplate for callers.

Example:

pub fn call_function_undefined_this(
    &mut self,
    function: &JsFunction,
    args: &[JsValue],
) -> JsResult<JsValue> {
    function.call(&JsValue::undefined(), args, &mut self.inner)
}

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

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/Cargo.toml : Add the specified dev-dependencies (biome_formatter_test, biome_html_factory, biome_html_parser, biome_parser, biome_service, countme with feature enable, iai 0.1.1, quickcheck, quickcheck_macros, tests_macros) to Cargo.toml under [dev-dependencies]

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: CLAUDE.md:0-0
Timestamp: 2025-08-17T08:55:30.118Z
Learning: Applies to crates/biome_*_{syntax,parser,formatter,analyze,factory,semantic}/** : Maintain the per-language crate structure: biome_{lang}_{syntax,parser,formatter,analyze,factory,semantic}

Learnt from: CR
PR: biomejs/biome#0
File: CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:40:38.097Z
Learning: Applies to crates/**/Cargo.toml : In internal crates, use `workspace = true` for internal dependencies.

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/src/workspace.rs : Implement the Workspace trait in src/workspace.rs

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/crates/biome_*_syntax/** : Create a new crate named biome_<language>_syntax under crates/

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: CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:40:38.097Z
Learning: Applies to Cargo.toml : Centralize shared dependencies in the root Cargo.toml using workspace dependencies.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/crates/biome_*_factory/** : Create a new crate named biome_<language>_factory under crates/

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: dyc3
PR: biomejs/biome#7081
File: packages/@biomejs/biome/configuration_schema.json:7765-7781
Timestamp: 2025-08-05T14:43:29.581Z
Learning: The file `packages/biomejs/biome/configuration_schema.json` is auto-generated and should not be manually edited or reviewed for schema issues; any changes should be made at the code generation source.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_service/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:53:15.299Z
Learning: For debugging: run commands against the daemon (e.g., `cargo run --bin=biome -- lint --use-server <path>`)

Learnt from: CR
PR: biomejs/biome#0
File: CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:40:38.097Z
Learning: Applies to crates/**/Cargo.toml : Use path dependencies for dev-dependencies in internal crates.

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Build an intermediate IR via the provided helper APIs when formatting

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/src/**/*.rs : Represent links between types using TypeReference (not Arc) to avoid cross-module retention and recursive structures; store type data in linear vectors

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/{src,resolver,biome_module_graph/src}/**/*.rs : Implement and use type resolution via the TypeResolver trait; resolvers own TypeStore vectors and provide fast by-id and hashed lookups

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/src/lib.rs : Place the plumbing traits and impls (AsFormat, IntoFormat, FormattedIterExt, and their Iterator adapters) in the biome_html_formatter crate’s lib.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/src/workspace/server.rs : Use WorkspaceServer (src/workspace/server.rs) to maintain workspace state in daemon and CLI daemonless modes

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/src/workspace/client.rs : Use WorkspaceClient (src/workspace/client.rs) to connect to the daemon and communicate with WorkspaceServer

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_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_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_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_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_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : #[derive(Diagnostic)] can be used on enums only if every variant contains a diagnostic type

Learnt from: CR
PR: biomejs/biome#0
File: CLAUDE.md:0-0
Timestamp: 2025-08-17T08:55:30.118Z
Learning: Applies to **/tests/specs/**/*.snap : Use snapshot spec tests stored as .snap files under tests/specs/ (via cargo insta)

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Use dbg_write! to debug and inspect the written IR elements during formatter development

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Use the generic Format trait and FormatNode for AST nodes when implementing the formatter

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Import the FormatNode trait and implement it for your Node

crates/biome_plugin_loader/src/thread_local.rs (1)

15-24: Make Key::new() fallible (don’t panic on FlsAlloc failure).

FlsAlloc may return FLS_OUT_OF_INDEXES (u32::MAX). Panicking in release is unfriendly; return an io::Result and propagate instead. Mirrors the same concern on Unix (see below).

-    impl<T> Key<T> {
-        pub(super) unsafe fn new() -> Self {
-            let inner = unsafe { win32::FlsAlloc(None) };
-            // FlsAlloc returns FLS_OUT_OF_INDEXES (u32::MAX) on failure.
-            assert!(inner != u32::MAX, "FlsAlloc failed: out of FLS indexes");
-
-            Self {
-                inner,
-                _phantom: PhantomData,
-            }
-        }
+    impl<T> Key<T> {
+        pub(super) unsafe fn new() -> std::io::Result<Self> {
+            let inner = win32::FlsAlloc(None);
+            // FlsAlloc returns FLS_OUT_OF_INDEXES (u32::MAX) on failure.
+            if inner == u32::MAX {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "FlsAlloc failed: out of FLS indexes",
+                ));
+            }
+            Ok(Self { inner, _phantom: PhantomData })
+        }

crates/biome_plugin_loader/src/thread_local.rs (2)

93-101: Consider installing TLS destructors to prevent per-thread leaks.

You’re intentionally leaking the per-thread Box to dodge drop-order hazards. If that becomes an issue under high churn threads, add a destructor (FlsAlloc callback / pthread_key_create dtor) that only frees the Box, or provide a clear_current_thread() for deterministic cleanup.

Would you like me to open a follow-up to prototype a safe destructor that avoids the double-free scenario you’ve seen?

---

125-134: Minor: document safety invariants around raw pointer use.

A brief SAFETY: comment stating why casting from TLS pointer and borrowing is sound (one Box per thread, never freed, RefCell borrow discipline) will help future maintainers.

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

crates/biome_plugin_loader/src/analyzer_js_plugin.rs (3)

27-39: Consider adding timeout protection for plugin loading.

Since JS plugins can potentially hang during module loading (infinite loops, blocking operations), you might want to add a timeout mechanism to prevent the loader from hanging indefinitely.

Would you like me to suggest an implementation using a timeout wrapper around the load operation?

---

73-108: Consider adding resource limits for plugin execution.

JS plugins could potentially consume excessive memory or CPU. Consider implementing resource limits (memory usage, execution time) to protect against misbehaving plugins.

You might want to explore Boa's built-in limits API or wrap the execution in a timeout to prevent runaway plugins from affecting the host application's performance.

---

90-90: Track the AST passing TODO.

The TODO indicates AST needs to be passed to the plugin. This is a core feature for plugins to analyse code structure.

Would you like me to create an issue to track implementing the AST serialisation and passing mechanism to JS plugins?

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

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_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_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_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/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_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/**/*.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_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Mark code blocks in docs with a language and required properties: use `expect_diagnostic` for invalid examples (exactly one diagnostic), `options`/`full_options` for config blocks, and `use_options` for subsequent examples

crates/biome_plugin_loader/src/thread_local.rs (6)

15-24: Prefer a fallible constructor for TLS key allocation

Panic on FlsAlloc == u32::MAX isn’t great UX in release. Return io::Result<Self> and propagate.

Example:

-        pub(super) unsafe fn new() -> Self {
+        pub(super) unsafe fn new() -> std::io::Result<Self> {
             let inner = unsafe { win32::FlsAlloc(None) };
-            // FlsAlloc returns FLS_OUT_OF_INDEXES (u32::MAX) on failure.
-            assert!(inner != u32::MAX, "FlsAlloc failed: out of FLS indexes");
+            if inner == u32::MAX {
+                return Err(std::io::Error::new(std::io::ErrorKind::Other, "FlsAlloc: FLS_OUT_OF_INDEXES"));
+            }
-            Self {
+            Ok(Self {
                 inner,
                 _phantom: PhantomData,
-            }
+            })
         }

Follow-up: bubble this through ThreadLocalCell::new().

---

56-71: POSIX: make pthread_key_create path fallible

Mirror Windows: don’t assert, return io::Result.

Apply:

-        pub(super) unsafe fn new() -> Self {
-            let inner = unsafe {
-                let mut inner = MaybeUninit::uninit();
-                let result = libc::pthread_key_create(inner.as_mut_ptr(), None);
-
-                assert_eq!(result, 0);
-
-                inner.assume_init()
-            };
-
-            Self {
-                inner,
-                _phantom: PhantomData,
-            }
-        }
+        pub(super) unsafe fn new() -> std::io::Result<Self> {
+            let mut inner = MaybeUninit::uninit();
+            let rc = libc::pthread_key_create(inner.as_mut_ptr(), None);
+            if rc != 0 {
+                return Err(std::io::Error::from_raw_os_error(rc));
+            }
+            Ok(Self { inner: inner.assume_init(), _phantom: PhantomData })
+        }

---

77-81: POSIX: don’t ignore pthread_setspecific failures

A failed set leads to a later unwrap() panic. Assert or, better, return Result.

Minimal change:

-        pub(super) unsafe fn set(&self, value: *mut T) {
-            let result = unsafe { libc::pthread_setspecific(self.inner, value as *mut c_void) };
-
-            debug_assert_eq!(result, 0);
-        }
+        pub(super) unsafe fn set(&self, value: *mut T) {
+            let rc = libc::pthread_setspecific(self.inner, value as *mut c_void);
+            debug_assert_eq!(rc, 0, "pthread_setspecific failed");
+        }

---

102-110: Remove the panic edge after set(); propagate TLS errors from get_mut_or_try_init

self.set(value); Ok(self.get_mut().unwrap()) will panic if the platform set() fails. Make set() return io::Result<()> and map errors in get_mut_or_try_init.

Sketch:

-    pub(crate) fn new() -> Self {
-        Self { key: unsafe { platform::Key::new() }, }
-    }
+    pub(crate) fn new() -> std::io::Result<Self> {
+        Ok(Self { key: unsafe { platform::Key::new()? } })
+    }

-    pub(crate) fn get_mut_or_try_init<F, E>(&self, default: F) -> Result<RefMut<'_, T>, E>
+    pub(crate) fn get_mut_or_try_init<F, E>(&self, default: F) -> Result<RefMut<'_, T>, E>
     where
         F: FnOnce() -> Result<T, E>,
     {
         match self.get_mut() {
             Some(r) => Ok(r),
             _ => match default() {
-                Ok(value) => {
-                    self.set(value);
-                    Ok(self.get_mut().unwrap())
-                }
+                Ok(value) => {
+                    self.set(value); // now returns io::Result<()>
+                    // map TLS error into E if you prefer a unified error type
+                    Ok(self.get_mut().expect("TLS set succeeded but value missing"))
+                }
                 Err(err) => Err(err),
             },
         }
     }

-    fn set(&self, value: T) {
+    fn set(&self, value: T) {
         let cell = Box::into_raw(Box::new(RefCell::new(value)));
-        unsafe { self.key.set(cell); }
+        unsafe { self.key.set(cell); /* -> io::Result<()> in platform layer */ }
     }

Happy to wire a small TlsInitError<E> enum if you want the full error story.

Also applies to: 112-126, 139-145

---

29-33: Windows: FlsSetValue check is wrong; use .as_bool() and handle failure

windows BOOL doesn’t have .is_ok(). This is a build breaker on Windows targets.

Apply:

-        pub(super) unsafe fn set(&self, value: *mut T) {
-            let result = unsafe { win32::FlsSetValue(self.inner, Some(value as *const c_void)) };
-
-            debug_assert!(result.is_ok());
-        }
+        pub(super) unsafe fn set(&self, value: *mut T) {
+            let ok = win32::FlsSetValue(self.inner, Some(value as *const c_void)).as_bool();
+            debug_assert!(ok, "FlsSetValue failed");
+        }

---

36-41: Windows: FlsFree check is wrong; use .as_bool()

Same issue as above; .is_ok() will not compile.

Apply:

-        fn drop(&mut self) {
-            let result = unsafe { win32::FlsFree(self.inner) };
-
-            debug_assert!(result.is_ok());
-        }
+        fn drop(&mut self) {
+            let ok = unsafe { win32::FlsFree(self.inner) }.as_bool();
+            debug_assert!(ok, "FlsFree failed");
+        }

crates/biome_js_runtime/src/module_loader.rs (2)

57-58: Set source path for better stack traces

Attach the resolved path to Source so errors show correct filenames.

Apply:

-                        let source = Source::from_bytes(source.as_bytes());
+                        let source = Source::from_bytes(source.as_bytes()).with_path(path.as_std_path());

---

33-36: Cache key may collide across different referrers; confirm Boa’s specifier semantics

You key the cache by the raw specifier string. If two modules in different directories import the same relative specifier (e.g. "./config.js"), you may return the wrong cached module. If Boa passes the original (unresolved) specifier into get_module, this is a real hazard.

Options:

• Key by the resolved absolute path (preferred), and in load_imported_module consult this map first.
• Or maintain a secondary map keyed by (referrer_path, specifier).

Would you confirm Boa’s contract for get_module/register_module specifiers? If it’s unresolved, we should switch to a resolved-path cache.

Also applies to: 40-47, 52-59, 86-88

crates/biome_plugin_loader/src/analyzer_js_plugin.rs (3)

50-53: Include plugin path in Debug output

Handy when multiple plugins are loaded.

Apply:

 impl Debug for AnalyzerJsPlugin {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AnalyzerJsPlugin").finish_non_exhaustive()
+        f.debug_struct("AnalyzerJsPlugin")
+            .field("path", &self.path)
+            .finish_non_exhaustive()
     }
 }

---

80-85: Add plugin path to the “could not load” diagnostic

Gives users immediate context.

Apply:

-                return vec![RuleDiagnostic::new(
+                return vec![RuleDiagnostic::new(
                     category!("plugin"),
                     None::<TextRange>,
-                    markup!("Could not load the plugin: "<Error>{err.to_string()}</Error>),
+                    markup!("Could not load the plugin "<Emphasis>{self.path.as_str()}</Emphasis>": "<Error>{err.to_string()}</Error>),
                 )];

---

99-105: Include plugin path in runtime error diagnostic

Same rationale as above.

Apply:

-                    vec![RuleDiagnostic::new(
+                    vec![RuleDiagnostic::new(
                         category!("plugin"),
                         None::<TextRange>,
-                        markup!("Plugin errored: "<Error>{err.to_string()}</Error>),
+                        markup!("Plugin "<Emphasis>{self.path.as_str()}</Emphasis>" errored: "<Error>{err.to_string()}</Error>),
                     )]

crates/biome_js_runtime/src/context.rs (1)

48-53: Enrich I/O error with path

The extra context helps debugging.

Apply:

-        let source = self
-            .fs
-            .read_file_from_path(path)
-            .map_err(|err| JsNativeError::error().with_message(err.to_string()))?;
+        let source = self
+            .fs
+            .read_file_from_path(path)
+            .map_err(|err| JsNativeError::error().with_message(format!("Failed to read {}: {}", path, err)))?;

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/{src,resolver,biome_module_graph/src}/**/*.rs : Implement and use type resolution via the TypeResolver trait; resolvers own TypeStore vectors and provide fast by-id and hashed lookups

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_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_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_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_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_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/**/lib/src/**/nursery/**/*.rs : Mark code blocks in docs with a language and required properties: use `expect_diagnostic` for invalid examples (exactly one diagnostic), `options`/`full_options` for config blocks, and `use_options` for subsequent examples

crates/biome_js_runtime/src/module_loader.rs (1)

68-71: Nice: parsed modules are cached

This addresses redundant parsing; good alignment with Boa’s loader contract and prior feedback.

crates/biome_js_runtime/src/module_loader.rs (1)

50-52: Tiny clean-up: simplify default init

Minor readability win.

-        let options = ResolveOptions {
-            ..Default::default()
-        };
+        let options = ResolveOptions::default();

crates/biome_plugin_loader/src/analyzer_js_plugin.rs (1)

100-109: Optional: include JS stack in error diagnostics

If available, prefer a representation that preserves the JS stack/frames for quicker debugging.

Example (if Boa exposes it):

-            .map_or_else(
-                |err| {
+            .map_or_else(
+                |err| {
                     vec![RuleDiagnostic::new(
                         category!("plugin"),
                         None::<TextRange>,
-                        markup!("Plugin errored: "<Error>{err.to_string()}</Error>),
+                        markup!("Plugin errored: "<Error>{err.display().to_string()}</Error>),
                     )]
                 },

Happy to wire a helper that formats Boa errors consistently across plugin diagnostics.

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/{src,resolver,biome_module_graph/src}/**/*.rs : Implement and use type resolution via the TypeResolver trait; resolvers own TypeStore vectors and provide fast by-id and hashed lookups

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/biome_module_graph/src/js_module_info/scoped_resolver.rs : Full inference resolves TypeReference::Import across modules into TypeReference::Resolved using the module graph; do not cache full-inference results

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_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_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_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_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_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_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_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Mark code blocks in docs with a language and required properties: use `expect_diagnostic` for invalid examples (exactly one diagnostic), `options`/`full_options` for config blocks, and `use_options` for subsequent examples