crates/biome_json_analyze/src/lint/suspicious/no_duplicate_object_keys.rs (1)

86-86: Prefer “duplicate key”; drop the redundant “again”.

Reads more naturally and matches the rule name. “Duplicate” implies repetition.

-                    "This is where a duplicated key was declared again."
+                    "This is where a duplicate key was declared."

crates/biome_css_analyze/tests/specs/correctness/noUnknownProperty/valid.css (1)

71-74: Nit: use the at-rule form for spec accuracy

The descriptor lives under the @view-transition at-rule. Using the at-rule keeps the example self-documenting.

-/* View Transition navigation property (should not be flagged) */
-view-transition {
+/* View Transition navigation descriptor (should not be flagged) */
+@view-transition {
   navigation: auto;
 }

crates/biome_js_analyze/src/lint/style/use_exponentiation_operator.rs (2)

174-191: Function now returns only Some(true) or None; consider simplifying.

does_exponentiation_expression_need_parens never returns Some(false). You can simplify the API to return bool and treat indeterminate cases as false. Not blocking, but it trims a little noise.

Suggested refactor within this hunk:

- fn does_exponentiation_expression_need_parens(node: &JsCallExpression) -> Option<bool> {
+ fn does_exponentiation_expression_need_parens(node: &JsCallExpression) -> bool {
-    if let Some(parent) = node.parent::<AnyJsExpression>() {
-        if does_expression_need_parens(node, &parent)? {
-            return Some(true);
-        }
-    } else if let Some(extends_clause) = node.parent::<JsExtendsClause>() {
+    if let Some(parent) = node.parent::<AnyJsExpression>() {
+        if does_expression_need_parens(node, &parent).unwrap_or(false) {
+            return true;
+        }
+    } else if let Some(extends_clause) = node.parent::<JsExtendsClause>() {
         if extends_clause.parent::<JsClassDeclaration>().is_some() {
-            return Some(true);
+            return true;
         }
         if let Some(class_expr) = extends_clause.parent::<JsClassExpression>() {
             let class_expr = AnyJsExpression::from(class_expr);
-            if does_expression_need_parens(node, &class_expr)? {
-                return Some(true);
+            if does_expression_need_parens(node, &class_expr).unwrap_or(false) {
+                return true;
             }
         }
     }
-    None
+    false
 }

And the corresponding call site (shown here for context outside this hunk):

- if let Some(true) = does_exponentiation_expression_need_parens(node) {
+ if does_exponentiation_expression_need_parens(node) {

---

131-134: Potential trivia mix‑up (duplicated leading trivia).

You append separator.leading_trivia() twice; the second one likely wants the trailing trivia. This looks like a tiny copy‑paste slip.

-            .append_trivia_pieces(chain_trivia_pieces(
-                separator.leading_trivia().pieces(),
-                separator.leading_trivia().pieces(),
-            ))?;
+            .append_trivia_pieces(chain_trivia_pieces(
+                separator.leading_trivia().pieces(),
+                separator.trailing_trivia().pieces(),
+            ))?;

.changeset/use_readonly_class_properties_nested_assignment_fix.md (1)

1-3: Rename the changeset file to reflect the actual change.

Current name references useReadonlyClassProperties. Suggest something like: fix-css-no-unknown-property-navigation.md.

crates/biome_js_analyze/tests/specs/style/useReadonlyClassProperties/valid.ts (2)

677-687: Typo in class name.

If you keep this test elsewhere, rename TesAssignmentInNestedCallback → TestAssignmentInNestedCallback.

-class TesAssignmentInNestedCallback {
+class TestAssignmentInNestedCallback {

---

681-685: Guard against potential type-check hiccups in tests.

If the harness type-checks, declare ambient ui/x to avoid errors, or replace with a self-contained example.

-  ui.showText("example", {
+  declare const ui: { showText(msg: string, opts: { callback: () => void }): void };
+  declare const x: unknown;
+  ui.showText("example", {

biome.json (1)

27-27: Include pattern may miss nested plugin files

If the intent is to lint all plugin JS files, prefer a recursive glob. Also, confirm this inclusion is intended in a PR aimed at CSS property recognition.

-      "plugins/*.js",
+      "plugins/**/*.js",

Would you like this broadened, or should we drop the plugin include from this CSS-focused PR?

.github/workflows/pull_request.yml (1)

88-88: Running tests with js_plugin only—consider a no-feature job too

Enabling features in CI can mask regressions in the default build. Suggest adding a second test step/job without features.

-      - name: Run tests
-        run: cargo test --workspace --features=js_plugin
+      - name: Run tests (js_plugin)
+        run: cargo test --workspace --features=js_plugin
+      - name: Run tests (default features)
+        run: cargo test --workspace

.github/workflows/main.yml (1)

95-95: Parity check: tests run with js_plugin—consider also testing without

Mirroring PR workflow advice: add a default-features test to catch cfg-gated gaps. Optionally align cargo check/clippy invocations to also include js_plugin.

-      - name: Run tests on ${{ matrix.os }}
-        run: cargo test --workspace --features=js_plugin
+      - name: Run tests on ${{ matrix.os }} (js_plugin)
+        run: cargo test --workspace --features=js_plugin
+      - name: Run tests on ${{ matrix.os }} (default features)
+        run: cargo test --workspace

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

1-3: Make the runtime guard message crisper and actionable

Clarify that this package is type-only, and guide users to import types vs runtime.

-throw new Error(
-	"This package is intended to be used in Biome JS plugins, did you mean `@biomejs/js-api`?",
-);
+throw new Error(
+	"This package only provides TypeScript types and has no runtime. If you need the runtime API, use '@biomejs/js-api'. For types only, write: import type { ... } from '@biomejs/plugin-api'.",
+);

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

1-1: Severity union looks fine; consider exposing constants for ergonomics.

Exporting string constants alongside the union reduces typos for plugin authors and improves autocomplete.

Apply:

+/** String constants for valid severities. */
+export const Severities = {
+  fatal: "fatal",
+  error: "error",
+  warning: "warning",
+  information: "information",
+  hint: "hint",
+} as const;
+
 export type Severity = "fatal" | "error" | "warning" | "information" | "hint";

---

3-3: Document and future‑proof the API surface.

Add minimal JSDoc now; if you expect codes/locations later, call that out to avoid churn.

-export function registerDiagnostic(severity: Severity, message: string): void;
+/**
+ * Emit a diagnostic from a JS plugin.
+ * @param severity - Diagnostic severity.
+ * @param message  - Human-readable message.
+ */
+export function registerDiagnostic(severity: Severity, message: string): void;

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

6-17: Include index.js in published files (or drop files field).

Even if private today, it avoids surprises if this is ever published.

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

---

18-21: Mark as side‑effect free.

This helps bundlers and tree‑shaking; the entry just throws.

   "main": "./index.js",
   "types": "./index.d.ts",
+  "sideEffects": false,
   "license": "MIT OR Apache-2.0",

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

93-101: Document the leak explicitly and provide a way to opt-out.

Per the docs, values aren’t dropped on thread exit. That can surprise tests or long-lived services creating many threads. Consider an explicit “clear for this thread” hook.

I can sketch a safe “clear_current_thread” that drops when no outstanding borrows.

---

112-126: Avoid unwrap chain after set; handle the impossible explicitly.

If set ever fails (see above), unwrap will panic. Replace with expect carrying context or restructure to return an error.

-                    self.set(value);
-                    Ok(self.get_mut().unwrap())
+                    self.set(value);
+                    Ok(self.get_mut().expect("TLS set succeeded, value must be present"))

---

128-136: Minor safety/readability touch.

Cache the deref once and add a debug assert to make intent clear.

-            let ptr = self.key.get();
-            if ptr.is_null() {
+            let ptr = self.key.get();
+            debug_assert!(!ptr.is_null());
+            if ptr.is_null() {
                 None
             } else {
-                Some((&*ptr).borrow_mut())
+                let cell: &RefCell<T> = &*ptr;
+                Some(cell.borrow_mut())
             }

---

139-145: Provide an explicit per-thread teardown to aid tests.

Optional helper to free the current thread’s value when needed (e.g. in tests or thread pools).

     fn set(&self, value: T) {
         let cell = Box::into_raw(Box::new(RefCell::new(value)));
         unsafe {
             self.key.set(cell);
         }
     }
+
+    /// Drops the current thread's value, if any.
+    /// Call only when no outstanding borrows exist.
+    #[allow(dead_code)]
+    fn clear_current_thread(&self) {
+        unsafe {
+            let ptr = self.key.get();
+            if !ptr.is_null() {
+                // Clear first to avoid stale pointer if drop panics.
+                self.key.set(std::ptr::null_mut());
+                drop(Box::from_raw(ptr));
+            }
+        }
+    }

---

15-24: Is Key::new really unsafe to call?

You already encapsulate the unsafe calls and assert on errors. Consider making Key::new safe and keep the unsafety internal.

Also applies to: 57-66

---

1-12: Trait auto-impls: confirm intended Send/Sync story.

Using PhantomData<fn() -> T> typically keeps Key Send/Sync regardless of T. That’s desirable for TLS of !Send types. Please confirm this is intentional and add a brief note.

plugins/plugin.js (1)

3-8: Defensive guard on input type.

Tiny safety net so plugins don’t blow up if a non-string sneaks in.

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

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

308-323: JSX-everywhere may affect .cjs unintentionally—gate on .js or confirm intent.

Current check flips any non-TS, non-JSX JS source to JSX. If .cjs should stay non-JSX, gate by extension.

-            if !js.is_typescript() && !js.is_jsx() {
+            if path.extension().is_some_and(|ext| ext == "js")
+                && !js.is_typescript()
+                && !js.is_jsx()
+            {
                 let settings = self
                     .projects
                     .get_settings_based_on_path(project_key, &biome_path)
                     .ok_or_else(WorkspaceError::no_project)?;
                 let jsx_everywhere = settings
                     .languages
                     .javascript
                     .parser
                     .jsx_everywhere
                     .unwrap_or_default()
                     .into();
                 if jsx_everywhere {
                     js.set_variant(LanguageVariant::Jsx);
                 }
             }

If .cjs is meant to honour the flag too, ignore this suggestion and we’re golden.

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

29-33: Tighten the argument validation error to include the expected signature.

Small UX win: spell out the exact signature and accepted severities.

-                        .with_message("registerDiagnostic() expects two string arguments")
+                        .with_message(
+                            "registerDiagnostic(severity, message) expects two string arguments; \
+severity must be one of: fatal, error, warning, information, hint",
+                        )

---

27-33: Document the unsafe more explicitly.

The closure captures only an Rc<RefCell<_>> (Rust-managed) and no GC-managed Boa values. Add that to the SAFETY note to avoid future refactors breaking the invariant.

---

49-55: Plan for spans sooner rather than later.

You’re emitting diagnostics with None::. Consider a follow-up API (e.g. registerDiagnosticWithSpan(start, end, message, severity)) so JS plugins can attach precise ranges.

Happy to draft the API and a matching d.ts update if you want.

Cargo.toml (1)

190-244: Workspace deps add-up: avoid pulling heavy crates unless needed.

Adding boa_engine, windows, and libc at the workspace level is OK, but keep them effectively gated by per-crate optional deps so they don’t inflate builds unintentionally.

If any non-plugin crates start depending on these indirectly, consider moving them out of [workspace.dependencies] into only the crates that need them.

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

58-72: Clarify sync-only contract (or detect Promises).

Boa doesn’t run async tasks; if a plugin returns a Promise nothing happens. Either document “entrypoint must be synchronous” or detect Promise returns and surface a diagnostic.

I can add a Promise check via value.as_object().is_some_and(|o| o.is_promise()) and emit a friendly diagnostic.

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

62-67: Nit: “analyser” → “analyzer”.

Minor spelling tidy in the TODO comment.

-        // TODO: plugin can have multiple analyser rules
+        // TODO: plugin can have multiple analyzer rules

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

32-35: Avoid magic string for plugin API specifier

Lift the specifier into a shared constant to prevent typos and ease reuse.

-        module_loader.register_module(
-            js_string!("@biomejs/plugin-api"),
+        const PLUGIN_API_SPEC: &str = "@biomejs/plugin-api";
+        module_loader.register_module(
+            js_string!(PLUGIN_API_SPEC),
             api.create_module(&mut ctx),
         );

---

82-87: Guard against endless job-queue spins

If the promise never settles (plugin bug), this tight loop can hot-spin the CPU. Add a soft cap/yield to be kinder to threads and humans.

-        loop {
+        let mut spins = 0u32;
+        loop {
             match promise_result.state() {
                 PromiseState::Pending => {
-                    // Drive the job queue until the promise settles.
-                    ctx.run_jobs();
+                    // Drive the job queue until the promise settles.
+                    ctx.run_jobs();
+                    spins += 1;
+                    if spins % 1024 == 0 {
+                        std::thread::yield_now();
+                    }
                 }
                 PromiseState::Fulfilled(_) => break Ok(module),

Please confirm Boa's guidance here; if there's a built-in “drain jobs until settled” helper, use that instead.

---

100-105: Fail fast when no default export

Today this returns undefined, which is easy to misuse downstream. Prefer a typed error if the module has no default.

-    pub fn get_default_export(&mut self, module: &Module) -> JsResult<JsValue> {
-        let ctx = &mut self.ctx;
-        let namespace = module.namespace(ctx);
-
-        namespace.get(js_string!("default"), ctx)
-    }
+    pub fn get_default_export(&mut self, module: &Module) -> JsResult<JsValue> {
+        let ctx = &mut self.ctx;
+        let namespace = module.namespace(ctx);
+        let value = namespace.get(js_string!("default"), ctx)?;
+        if value.is_undefined() {
+            return Err(JsNativeError::typ()
+                .with_message("Module has no default export")
+                .into());
+        }
+        Ok(value)
+    }

If callers intentionally accept missing defaults, ignore this and keep returning undefined.

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

54-64: Avoid allocating with to_string() inside markup

markup! supports Display; pass the error directly to avoid an extra allocation.

-            message: MessageAndDescription::from(
-                markup! {"Failed to compile the JS plugin: "{value.to_string()}}.to_owned(),
-            ),
+            message: MessageAndDescription::from(
+                markup! {"Failed to compile the JS plugin: " {value}}.to_owned(),
+            ),

---

148-151: Struct-level diagnostic message: looks right—update snapshots

Switching to MessageAndDescription will change output text. Ensure snapshot tests are refreshed and cover JS plugin compile failures too.

Would you like a new test that constructs a boa_engine::JsError (behind js_plugin) and snapshots the resulting PluginDiagnostic?

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

50-52: Minor: use Default directly

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

---

61-67: Shadowed source hurts readability

Rename the inner binding to avoid reusing source for both contents and Source.

-                let source = self.fs.read_file_from_path(&path);
-                match source {
-                    Ok(source) => {
-                        let source = source.as_bytes();
-                        let source = Source::from_bytes(source).with_path(path.as_std_path());
+                let contents = self.fs.read_file_from_path(&path);
+                match contents {
+                    Ok(contents) => {
+                        let bytes = contents.as_bytes();
+                        let source = Source::from_bytes(bytes).with_path(path.as_std_path());
                         let module = Module::parse(source, None, context);

---

11-15: Consider cache invalidation

The loader caches by absolute path without eviction. If used in long-lived processes or with hot-reloads, expose a clear() or LRU. Optional for now.

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_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 : Most diagnostic attributes may be specified only once (either on the type or a single field); #[advice] and #[verbose_advice] may appear multiple times and are recorded in declaration order

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: 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: 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 Cargo.toml : Centralize shared dependencies in the root Cargo.toml using workspace 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: 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_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/tests/specs/**/{invalid*,valid*}.{js,jsx,ts,tsx,css,graphql,jsonc} : Place snapshot test cases under `tests/specs/<group>/<ruleName>/` using files prefixed with `invalid` and `valid`

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_service/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:53:15.299Z
Learning: Applies to crates/biome_service/src/workspace/watcher.tests.rs : Place watcher tests for workspace methods in src/workspace/watcher.tests.rs

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

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_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_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_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: CLAUDE.md:0-0
Timestamp: 2025-08-17T08:55:30.118Z
Learning: Applies to crates/biome_html_formatter/benches/html_formatter.rs : Maintain the HTML formatter benchmark at benches/html_formatter.rs within the biome_html_formatter crate

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 : For non-mandatory tokens, use the formatter helper functions (e.g., token, space_token) instead of hardcoding

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: 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/src/**/*.rs : Use TypeData::Unknown for unimplemented inference and TypeData::UnknownKeyword for the explicit TypeScript unknown keyword; treat them semantically the same but keep them distinct for measurement

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_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_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: CLAUDE.md:0-0
Timestamp: 2025-08-17T08:55:30.118Z
Learning: Applies to **/tests/** : Place test files under a tests/ directory in each crate

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/language.rs : Create tests/language.rs defining HtmlTestFormatLanguage and implement TestFormatLanguage for it

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 : 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 : #[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_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_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_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/lib.rs : Expose a documented public function format_node(options: HtmlFormatOptions, root: &HtmlSyntaxNode) -> FormatResult<Formatted<HtmlFormatContext>> delegating to biome_formatter::format_node

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 : Do not attempt to fix code: if a mandatory token/node is missing, return None instead