.changeset/upset-impalas-grab.md (1)

8-8: Minor wording improvement for clarity.

Consider using "can" instead of "able to" for a more concise phrasing.

-This means that now Biome is able to lint and format the JavaScript (TypeScript), HTML and CSS code that is contained in these files.
+This means that now Biome can lint and format the JavaScript (TypeScript), HTML and CSS code that is contained in these files.

.changeset/upset-apes-reply.md (1)

5-5: Simplify redundant phrasing.

"support is now supported" is slightly redundant. Consider using just "is now available in Biome" or similar.

-React 19.2 support is now supported in Biome.
+React 19.2 is now supported in Biome.

.changeset/breezy-suns-leave.md (1)

5-5: Consider enhancing the changeset with documentation link and code example.

Per coding guidelines, when referencing a rule in a changeset, include a link to its page on the website. Additionally, including a code example would help illustrate the change.

Apply this diff:

-Added `ignore` option to `noUnknownAtRules`. If an unknown at-rule matches any of the items provided in `ignore`, a diagnostic won't be emitted.
+Added `ignore` option to [noUnknownAtRules](https://biomejs.dev/linter/rules/no-unknown-at-rules). If an unknown at-rule matches any of the items provided in `ignore`, a diagnostic won't be emitted.
+
+```json
+{
+  "linter": {
+    "rules": {
+      "suspicious": {
+        "noUnknownAtRules": {
+          "options": {
+            "ignore": ["custom-at-rule"]
+          }
+        }
+      }
+    }
+  }
+}
+```

Based on coding guidelines.

crates/biome_cli/tests/commands/format.rs (1)

3542-3575: Nice test coverage for the new format-with-errors flag!

The test correctly validates that formatting proceeds and writes output even with syntax errors, whilst still returning an error code. This is sensible behaviour for CI/CD workflows.

Optional: Consider adding a brief comment at line 3564 explaining why is_err() is expected when using --format-with-errors=true. Whilst the behaviour makes sense (signal failure but still write formatted output), a comment would help future maintainers understand the intentional error return.

+    assert!(result.is_err(), "run_cli returned {result:?}");

Could optionally become:

+    // Still returns an error to signal syntax issues exist, even though formatting proceeds
+    assert!(result.is_err(), "run_cli returned {result:?}");

.changeset/max-managers-mandate.md (1)

5-5: Consider adding an issue link.

Per the coding guidelines, when fixing a bug in a changeset, start with an issue link (e.g., "Fixed #1234: …").

As per coding guidelines.

.changeset/stupid-groups-grow.md (1)

1-9: Consider linking the rule name.

As per coding guidelines, "when referencing a rule or assist in a changeset, include a link to its page on the website." Consider linking noHeaderScope to its documentation page if available.

Otherwise, the changeset correctly documents the new HTML linting and assist configurations using proper tense and formatting.

Based on coding guidelines.

crates/biome_css_parser/src/syntax/property/mod.rs (1)

175-184: Defensive guard: check for ‘*’ before rewriting to TW_VALUE_THEME_REFERENCE

Even if upstream lookahead is fixed, add a local star check to prevent creating a TW_VALUE_THEME_REFERENCE when only “-” is present.

-        if let Some(ident) = ident
-            && p.options().is_tailwind_directives_enabled()
-            && p.at(T![-])
-        {
+        if let Some(ident) = ident
+            && p.options().is_tailwind_directives_enabled()
+            && p.at(T![-])
+            && p.nth_at(1, T![*])
+        {
             let m = ident.precede(p);
             p.expect(T![-]);
             p.expect(T![*]);
             m.complete(p, TW_VALUE_THEME_REFERENCE);
         }

crates/biome_cli/src/execute/std_in.rs (1)

81-90: DRY the HTML wrapper selection

Logic’s sound; it’s triplicated. Extract a tiny helper to keep it consistent and future‑proof (and make reviewers slightly less cross‑eyed).

Example:

fn maybe_wrap_html_output(ext: Option<&str>, input: &str, code: String, full_html: bool) -> String {
    if full_html {
        code
    } else {
        match ext {
            Some("astro") => AstroFileHandler::output(input, &code),
            Some("vue") => VueFileHandler::output(input, &code),
            Some("svelte") => SvelteFileHandler::output(input, &code),
            _ => code,
        }
    }
}

Then replace each block with:

- let output = if !file_features.supports_full_html_support() { /* match ... */ } else { code };
+ let output = maybe_wrap_html_output(biome_path.extension(), /* input */, code, file_features.supports_full_html_support());

Use content or &new_content as appropriate for the input argument.

Also applies to: 181-190, 209-218

crates/biome_cli/tests/cases/reporter_checkstyle.rs (1)

8-26: Consider consolidating duplicate constants.

MAIN_1 and MAIN_2 are identical. If the intent is to test multiple files with the same content, a single constant would suffice. If different content was intended to improve test coverage, they should be differentiated.

Apply this diff to consolidate:

-const MAIN_1: &str = r#"import { z} from "z"
-import { z, b , a} from "lodash"
-
-a ==b
-
-debugger
-
-let f;
-		let f;"#;
-
-const MAIN_2: &str = r#"import { z} from "z"
+const TEST_FILE_CONTENT: &str = r#"import { z} from "z"
 import { z, b , a} from "lodash"
 
 a ==b
@@ -33,7 +26,7 @@
 let f;
 		let f;"#;

Then replace usages of MAIN_1 and MAIN_2 with TEST_FILE_CONTENT.

crates/biome_cli/tests/cases/json_parsing.rs (6)

214-243: Add an explicit success assertion to stabilise the test

Formatting with trailing commas allowed should succeed; assert it so snapshots don’t carry exit‑code ambiguity.

     let (fs, result) = run_cli(
         fs,
         &mut console,
         Args::from(
             [
                 "format",
                 "--json-parse-allow-trailing-commas=true",
                 file_path.as_str(),
             ]
             .as_slice(),
         ),
     );
 
-    assert_cli_snapshot(SnapshotPayload::new(
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "format_json_parse_allow_trailing_commas_true",
         fs,
         console,
         result,
     ));

---

247-280: Lock in expected OK exit for combined flags

Both flags enabled on valid input should return success.

     let (fs, result) = run_cli(
         fs,
         &mut console,
         Args::from(
             [
                 "check",
                 "--json-parse-allow-comments=true",
                 "--json-parse-allow-trailing-commas=true",
                 file_path.as_str(),
             ]
             .as_slice(),
         ),
     );
 
-    assert_cli_snapshot(SnapshotPayload::new(
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "check_combined_json_parser_flags",
         fs,
         console,
         result,
     ));

---

311-356: Assert config precedence over CLI

Config disallows comments; even with the CLI flag set, parsing should fail if config wins. Assert the error to codify precedence.

     let (fs, result) = run_cli(
         fs,
         &mut console,
         Args::from(
             [
                 "check",
                 "--json-parse-allow-comments=true",
                 file_path.as_str(),
             ]
             .as_slice(),
         ),
     );
 
-    assert_cli_snapshot(SnapshotPayload::new(
+    assert!(result.is_err(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "check_json_parser_flags_override_config",
         fs,
         console,
         result,
     ));

---

358-396: Assert OK when config allows comments

With allowComments: true in config, this should succeed; add an assertion.

     let (fs, result) = run_cli(
         fs,
         &mut console,
         Args::from(["check", file_path.as_str()].as_slice()),
     );
 
-    assert_cli_snapshot(SnapshotPayload::new(
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "check_json_parse_respects_config_allow_comments",
         fs,
         console,
         result,
     ));

---

398-433: Assert OK when config allows trailing commas

Similarly, guarantee success when allowTrailingCommas: true.

     let (fs, result) = run_cli(
         fs,
         &mut console,
         Args::from(["check", file_path.as_str()].as_slice()),
     );
 
-    assert_cli_snapshot(SnapshotPayload::new(
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+    assert_cli_snapshot(SnapshotPayload::new(
         module_path!(),
         "check_json_parse_respects_config_allow_trailing_commas",
         fs,
         console,
         result,
     ));

---

10-433: Trim duplication with a tiny helper (optional)

There’s repeated setup for MemoryFileSystem, file.json content, and Args. A small local helper would cut noise and make intent pop.

crates/biome_cli/src/commands/check.rs (1)

94-97: Make JSON merge consistent (semicolon)

Style nit: mirror the CSS block and add the missing semicolon; avoids clippy grumbles and keeps symmetry.

-        if self.json_parser.is_some() {
-            json.parser.merge_with(self.json_parser.clone())
-        }
+        if self.json_parser.is_some() {
+            json.parser.merge_with(self.json_parser.clone());
+        }

crates/biome_cli/src/execute/process_file/format.rs (1)

95-118: Verify the capability flag and deduplicate empty-output branches.

• Method name supports_full_html_support() reads a tad tautological; confirm it exists as-is across the workspace API and isn’t a typo (e.g. supports_full_html()).
• The if output.is_empty() { return Ok(Unchanged) } blocks repeat per extension.

Consider:

-    if !features_supported.supports_full_html_support() {
-        match workspace_file.as_extension() {
-            Some("astro") => {
-                if output.is_empty() { return Ok(FileStatus::Unchanged); }
-                output = AstroFileHandler::output(input.as_str(), output.as_str());
-            }
-            Some("vue") => {
-                if output.is_empty() { return Ok(FileStatus::Unchanged); }
-                output = VueFileHandler::output(input.as_str(), output.as_str());
-            }
-            Some("svelte") => {
-                if output.is_empty() { return Ok(FileStatus::Unchanged); }
-                output = SvelteFileHandler::output(input.as_str(), output.as_str());
-            }
-            _ => {}
-        }
-    }
+    if !features_supported.supports_full_html_support() {
+        if output.is_empty() {
+            return Ok(FileStatus::Unchanged);
+        }
+        match workspace_file.as_extension() {
+            Some("astro") => {
+                output = AstroFileHandler::output(input.as_str(), output.as_str());
+            }
+            Some("vue") => {
+                output = VueFileHandler::output(input.as_str(), output.as_str());
+            }
+            Some("svelte") => {
+                output = SvelteFileHandler::output(input.as_str(), output.as_str());
+            }
+            _ => {}
+        }
+    }

Please confirm the intended behaviour when full HTML is supported vs. per‑extension mode with Astro/Vue/Svelte – a quick e2e check over representative fixtures would be great.

crates/biome_css_parser/src/syntax/mod.rs (2)

340-348: Tailwind --tw-* value path: good guard; add tests for both modes.

The -- + -* lookahead is precise. Please add parser tests for:

• with Tailwind enabled: parses --tw-* as TW_VALUE_THEME_REFERENCE;
• with Tailwind disabled: emits tailwind_disabled.

Happy to draft test cases if you want.

---

590-600: Remapping * to an identifier inside bracketed values – double‑check token remap and context.

This is Tailwind‑only and fine conceptually, but consider using the regular lexing context for consistency.

-                    let m = p.start();
-                    p.bump_remap(T![ident]);
+                    let m = p.start();
+                    p.bump_remap_with_context(T![ident], CssLexContext::Regular);
                     Present(m.complete(p, CSS_CUSTOM_IDENTIFIER))

Also add a negative test to ensure * here triggers tailwind_disabled when the flag is off.

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

382-393: Welcome format_node_with_offset for CSS.

Good addition; mirrors core formatter API and unblocks range/offset consumers.

Add a brief rustdoc example showing how to build a CssSyntaxNodeWithOffset and call this function.

crates/biome_cli/src/commands/ci.rs (1)

77-89: Simplify Option assignment.

clone_from works but is noisy; direct assignment is clearer.

-        if self.json_parser.is_some() {
-            json.parser.clone_from(&self.json_parser)
-        }
+        if let Some(p) = self.json_parser.clone() {
+            json.parser = Some(p);
+        }
@@
-        if self.css_parser.is_some() {
-            css.parser.clone_from(&self.css_parser);
-        }
+        if let Some(p) = self.css_parser.clone() {
+            css.parser = Some(p);
+        }

crates/biome_cli/src/execute/process_file/lint_and_assist.rs (1)

100-113: Tiny tidy‑up: extract per‑extension splice to a helper.

Keeps analyse_with_guard lean and reduces repetition.

-        if !features_supported.supports_full_html_support() {
-            match workspace_file.as_extension() {
-                Some("astro") => {
-                    output = AstroFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some("vue") => {
-                    output = VueFileHandler::output(input.as_str(), output.as_str());
-                }
-                Some("svelte") => {
-                    output = SvelteFileHandler::output(input.as_str(), output.as_str());
-                }
-                _ => {}
-            }
-        }
+        if !features_supported.supports_full_html_support() {
+            output = splice_framework_output(workspace_file.as_extension(), &input, &output);
+        }

New helper:

fn splice_framework_output(ext: Option<&str>, input: &str, output: &str) -> String {
    match ext {
        Some("astro") => AstroFileHandler::output(input, output),
        Some("vue") => VueFileHandler::output(input, output),
        Some("svelte") => SvelteFileHandler::output(input, output),
        _ => output.to_string(),
    }
}

crates/biome_cli/src/execute/mod.rs (1)

251-255: Update the RDJSON documentation link to the official reviewdog repository.

Line 253: Replace the deepwiki mirror link with the canonical reviewdog specification at https://github.com/reviewdog/reviewdog/tree/master/proto/rdf to guard against link rot and direct users to the authoritative source.

crates/biome_css_parser/src/syntax/at_rule/mod.rs (1)

117-165: Reduce repetition in Tailwind match arms

Nine near-identical branches differ only by parser fn. Extract a tiny helper to centralise the gating + fallback; keeps the match tidy and harder to get wrong next time.

Example:

+#[inline]
+fn parse_tailwind_exclusive(
+    p: &mut CssParser,
+    f: fn(&mut CssParser) -> ParsedSyntax,
+) -> ParsedSyntax {
+    CssSyntaxFeatures::Tailwind
+        .parse_exclusive_syntax(p, f, |p, m| tailwind_disabled(p, m.range(p)))
+        .or_else(|| parse_unknown_at_rule(p))
+}
@@
-        T![theme] => CssSyntaxFeatures::Tailwind
-            .parse_exclusive_syntax(p, parse_theme_at_rule, |p, m| {
-                tailwind_disabled(p, m.range(p))
-            })
-            .or_else(|| parse_unknown_at_rule(p)),
+        T![theme] => parse_tailwind_exclusive(p, parse_theme_at_rule),
@@
-        T![utility] => CssSyntaxFeatures::Tailwind
-            .parse_exclusive_syntax(p, parse_utility_at_rule, |p, m| {
-                tailwind_disabled(p, m.range(p))
-            })
-            .or_else(|| parse_unknown_at_rule(p)),
+        T![utility] => parse_tailwind_exclusive(p, parse_utility_at_rule),

…and similarly for variant/custom_variant/apply/source/reference/config/plugin.

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

572-639: Custom deserialiser: unknown keys + deprecation handling

Solid field-by-field handling with explicit allowed keys and tailored diagnostics. Small nit: consider storing DEFAULT_SCANNER_IGNORE_ENTRIES as a HashSet<&[u8]> for O(1) membership if this list grows, but it’s fine as-is.

---

641-672: Visitor implementation and key synchronisation verified

The TS interface and Rust ALLOWED_KEYS list are in perfect sync (all four fields present: maxSize, ignoreUnknown, includes, experimentalScannerIgnores). The unknown-key diagnostic handling is sound. The suggested unit test to lock these in sync remains a sensible optional improvement.

crates/biome_configuration/src/html.rs (1)

84-91: Line endings: ‘auto’ doc matches behaviour

Nice addition; aligns with other formatters. Consider adding a short rustdoc example for Windows vs Unix to avoid ambiguity.

crates/biome_cli/src/reporter/rdjson.rs (1)

136-159: Avoid panicking in reporters

expect("Invalid markup") will abort the run on malformed advice. Prefer a graceful fallback to the raw Display text.

Example:

-            markup_to_string(&message).expect("Invalid markup")
+            markup_to_string(&message).unwrap_or_else(|| text.to_string())

crates/biome_cli/src/commands/mod.rs (3)

159-168: Expose --format-with-errors on format for parity

You added the flag for Check/Ci; consider adding it to Format too so users don’t need to craft a formatter config just for this one toggle.

@@
     Format {
         #[bpaf(external(formatter_configuration), optional, hide_usage)]
         formatter_configuration: Option<FormatterConfiguration>,
+        /// Whether formatting should be allowed to proceed if a given file
+        /// has syntax errors
+        #[bpaf(long("format-with-errors"), argument("true|false"))]
+        format_with_errors: Option<FormatWithErrorsEnabled>,

---

263-274: Tweak arg metavariable for clarity

Using argument("SELECTOR") (and explaining it accepts group/rule/domain) reads cleaner than GROUP|RULE|DOMAIN in the metavariable itself.

-        #[bpaf(long("only"), argument("GROUP|RULE|DOMAIN"))]
+        #[bpaf(long("only"), argument("SELECTOR"))]

---

275-285: Same for --skip

Mirror the metavariable change here for consistency.

-        #[bpaf(long("skip"), argument("GROUP|RULE|DOMAIN"))]
+        #[bpaf(long("skip"), argument("SELECTOR"))]

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

719-750: DomainSelector invariants and schema

• Public tuple field allows DomainSelector("bogus") at compile time. If feasible post-release, consider making the field private and exposing as_str(), updating codegen to use that.
• Optional: derive JsonSchema here for symmetry with AnalyzerSelector.

-#[derive(Clone, Copy, Eq, PartialEq, Hash)]
-pub struct DomainSelector(pub &'static str);
+#[derive(Clone, Copy, Eq, PartialEq, Hash)]
+pub struct DomainSelector(&'static str);
+
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 // keep FromStr/Display/Deref as-is; add:
 impl DomainSelector {
     pub const fn as_str(&self) -> &'static str { self.0 }
 }

Note: this requires updating any codegen that currently reads self.0.

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

1265-1283: Diagnostic/advices refactor reads clean

Manual Diagnostic/Advices impls with advice_offset mirror parser behaviour; location handling looks correct.

Consider a builder-style helper for ergonomics:

 impl RuleDiagnostic {
+    pub fn with_advice_offset(mut self, offset: TextSize) -> Self {
+        self.advice_offset = Some(offset);
+        self
+    }
 }

Also applies to: 1285-1313, 1315-1351, 1374-1389

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (1)

33-51: Consider Tailwind lexing for @utility names

If utility names can include extended tokens in future (similar to @apply), parse the name under CssLexContext::TailwindUtility for consistency.

-    // Parse utility name - can be simple or functional
-    if !is_at_identifier(p) {
+    // Parse utility name - can be simple or functional
+    if !is_at_identifier(p) {
         p.error(expected_identifier(p, p.cur_range()));
         return Present(m.complete(p, CSS_BOGUS_AT_RULE));
     }
 
-    parse_utility_name(p).ok();
+    // Use Tailwind context to allow extended identifiers if needed
+    parse_identifier(p, CssLexContext::TailwindUtility).or_else(|| parse_utility_name(p)).ok();

Also applies to: 53-68