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

1636-1643: Typo in method name (“doublet”) — align with existing naming

HtmlParseOptions uses with_double_text_expression elsewhere; the new setter is named set_doublet_text_expression. Let’s rename to set_double_text_expression for consistency and future discoverability, and update call sites.

Apply this change in this file after renaming the method in the parser crate:

-            options.set_doublet_text_expression(interpolation.value());
+            options.set_double_text_expression(interpolation.value());

crates/biome_html_formatter/src/html/lists/element_list.rs (1)

63-65: Tiny grammar nit

“call it’s formatter” → “call its formatter”.

-        // we know the parser will only emit one of these. We can simply call it's formatter and be done.
+        // we know the parser will only emit one of these. We can simply call its formatter and be done.

crates/biome_html_parser/src/parser.rs (1)

121-126: Rename set_doublet_text_expression → set_double_text_expression

Typo in public API; best to correct now for consistency with with_double_text_expression and HtmlTextExpressions::Double.

Minimal change:

-    pub fn set_doublet_text_expression(&mut self, value: bool) {
+    pub fn set_double_text_expression(&mut self, value: bool) {
         match value {
             true => self.text_expression = Some(TextExpressionKind::Double),
             false => self.text_expression = None,
         }
     }

Then update call sites (e.g., settings.rs).

crates/biome_html_formatter/src/html/auxiliary/element.rs (1)

17-19: Update the comment to reflect embedded formatting now exists

The note about “script/style not yet implemented” is stale after this PR. Please align the docs with the new embedded pathway.

-/// `pre` tags are "preformatted", so we should not format the content inside them. <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre>
-/// We ignore the `script` and `style` tags as well, since embedded language parsing/formatting is not yet implemented.
+/// `pre` tags are "preformatted", so we do not format their content. <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre>
+/// `script` and `style` are handled via embedded-language formatting, not as verbatim here.
 const HTML_VERBATIM_TAGS: &[&str] = &["pre"];

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

103-104: Nit: prefer a valid CSS property in the sample

Consider using text-align over align to avoid future confusion if CSS validation ever tightens in tests. No behaviour change implied.

-<style>#id .class div > p { background-color: red; align: center; padding: 0; } </style>
+<style>#id .class div > p { background-color: red; text-align: center; padding: 0; } </style>

Also applies to: 146-148

crates/biome_html_syntax/src/element_ext.rs (1)

16-18: Nit: binary_search requires sorted input; add a guard or simplify

VOID_ELEMENTS is sorted today. To avoid accidental reordering regressions, either add a debug_assert!(is_sorted) in tests/build.rs or use contains() for clarity (perf impact is negligible at this size).

-        Ok(VOID_ELEMENTS
-            .binary_search(&name.value_token()?.text_trimmed())
-            .is_ok())
+        Ok(VOID_ELEMENTS.contains(&name.value_token()?.text_trimmed()))

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

209-221: Tiny allocation nit

If Formatter exposes write_element, you can avoid allocating a Vec here. If not, feel free to ignore.

-            f.write_elements(vec![
-                FormatElement::Tag(StartEmbedded(range)),
-                FormatElement::Tag(EndEmbedded),
-            ])?;
+            // If available:
+            // f.write_element(FormatElement::Tag(StartEmbedded(range)))?;
+            // f.write_element(FormatElement::Tag(EndEmbedded))?;

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

110-172: Solid E2E formatting test; add an idempotency check.

Ensures the embedded second pass is stable. Also, consider using valid CSS (e.g. .cls {}) to avoid parser noise later.

Apply this diff to assert idempotency:

@@
     let result = workspace
         .format_file(FormatFileParams {
             path: Utf8PathBuf::from("/project/file.html").into(),
             project_key,
         })
         .unwrap();
 
+    // Formatting should be idempotent
+    let result2 = workspace
+        .format_file(FormatFileParams {
+            path: Utf8PathBuf::from("/project/file.html").into(),
+            project_key,
+        })
+        .unwrap();
+    assert_eq!(result2.as_code(), result.as_code(), "Formatting must be idempotent");
+
     insta::assert_snapshot!(result.as_code(), @r#"

crates/biome_formatter/src/format_element/tag.rs (1)

72-76: Polish the docs for the new tag.

Tiny wording tweak for clarity.

Apply this diff:

-    /// A content will be formatted later by another formatter.
-    /// These tags must be removed during the second pass.
+    /// Marks content to be formatted later by another formatter.
+    /// These tags are replaced during the second pass.

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

646-653: Document the embedded-format callback (and consider &[T]).

Add brief docs; optionally accept a slice to avoid forcing allocations.

Apply this diff to document the callback:

-type FormatEmbedded = fn(
+/// Callback used to format embedded segments collected during the first pass.
+/// The implementor formats each segment and returns the final `Printed`.
+type FormatEmbedded = fn(
     &BiomePath,
     &DocumentFileSource,
     AnyParse,
     &Settings,
     Vec<FormatEmbedNode>,
 ) -> Result<Printed, WorkspaceError>;

If you want the zero-copy variant later:

• Change the fifth parameter to &[FormatEmbedNode].
• Update implementors accordingly.

---

654-659: Add field-level docs to FormatEmbedNode.

Clarifies intent for future readers.

Apply this diff:

-pub(crate) struct FormatEmbedNode {
-    pub(crate) range: TextRange,
-    pub(crate) node: SendEmbeddedParse,
-    pub(crate) source: DocumentFileSource,
-}
+/// Describes one embedded region to be formatted on the second pass.
+pub(crate) struct FormatEmbedNode {
+    /// The absolute range in the host document for this embedded content.
+    pub(crate) range: TextRange,
+    /// The parsed subtree (offset parse) of the embedded language.
+    pub(crate) node: SendEmbeddedParse,
+    /// The language/file-source of the embedded content (e.g. JS, CSS).
+    pub(crate) source: DocumentFileSource,
+}

crates/biome_formatter/src/lib.rs (3)

24-24: Drop extern crate core; it's redundant in 2021+.

Rust injects core automatically; this line just adds noise.

-extern crate core;

---

894-939: Embedded formatting API: avoid cloning and the follow-up swap.

The visitor approach is solid. Returning a cloned Document and also mutating self.document forces callsites into a needless copy + swap_document. Make it mutate in place and return () (or &mut Self for chaining).

-    #[must_use]
-    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> Document
+    pub fn format_embedded<F>(&mut self, fn_format_embedded: F)
     where
         F: Fn(TextRange) -> Option<Document>,
     {
         let document = &mut self.document;
@@
-        ElementTransformer::transform_document(
+        ElementTransformer::transform_document(
             document,
             &mut EmbeddedVisitor { fn_format_embedded },
         );
-
-        document.clone()
     }

Outside this file (example in crates/biome_service/src/file_handlers/html.rs):

-    let new_document = formatted.format_embedded(move |range| { /* ... */ });
-    formatted.swap_document(new_document);
+    formatted.format_embedded(move |range| { /* ... */ });

NB: unconditionally replacing EndEmbedded with a hard line may double-insert newlines in some layouts; consider deferring end-tag handling to the caller or making it configurable in a follow-up.

---

950-953: swap_document becomes unnecessary if the above refactor lands.

Keep for now, but mark as deprecated later once callsites are updated.

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

150-169: Parser option resolution LGTM.

Overrides applied; future: consider whether DocumentFileSource should influence defaults.

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

349-375: Second pass for HTML: solid integration; consider DRYing it up

The script/style extraction here mirrors the logic in change_file(). A small helper (e.g. compute_embedded_nodes(project_key, &path, &file_source, &html_root)) would remove duplication and keep behaviour in lockstep.

Example sketch (outside this hunk):

fn compute_embedded_nodes<FsIdx>(
  &self,
  project_key: ProjectKey,
  biome_path: &BiomePath,
  file_source: &DocumentFileSource,
  html_root: &HtmlRoot,
  cache: &mut NodeCache,
  source_index_fn: FsIdx,
) -> Result<(Vec<EmbeddedJsContent>, Vec<EmbeddedCssContent>), WorkspaceError>
where
  FsIdx: Fn(DocumentFileSource) -> usize + Copy
{ ... }

---

463-501: Build once, use fast: minor tidy

You could reserve capacity to avoid a couple of reallocations.

-            .map(|doc| {
-                doc.embedded_scripts
+            .map(|doc| {
+                let mut out = Vec::with_capacity(doc.embedded_scripts.len() + doc.embedded_styles.len());
+                out.extend(
+                  doc.embedded_scripts
                     .clone()
                     .iter()
                     .map(|node| {
                        // ...
                     })
-                    .chain(doc.embedded_styles.clone().iter().map(|node| {
+                );
+                out.extend(doc.embedded_styles.clone().iter().map(|node| {
                       // ...
-                    }))
-                    .collect::<Vec<_>>()
+                }));
+                out
             })

---

510-543: JS extraction path: looks right

Deriving JsParserOptions from project settings and walking descendants is fine. Consider iterating only HtmlElement nodes if performance ever bites, but this is OK for now.

---

545-579: CSS options move semantics: avoid relying on Copy

parse_embedded_style takes CssParserOptions by value and uses it multiple times internally. At the call site you pass options (by move) on each loop iteration; this compiles only if CssParserOptions is Copy. Be explicit to future‑proof.

-            let Some(list) = crate::file_handlers::html::parse_embedded_style(
+            let Some(list) = crate::file_handlers::html::parse_embedded_style(
                 element.clone(),
                 cache,
-                options,
+                options.clone(),
                 &source_index_fn,
             ) else {

If CssParserOptions isn’t Clone, change parse_embedded_style to accept &CssParserOptions.

---

1281-1306: Second pass on change_file(): keep in sync with open_file_internal

Same note as above: a shared helper would prevent drift between these two nearly identical blocks.

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

379-424: CSS extraction helper: looks fine

Reads cleanly and mirrors the JS path. One tiny nit: pass a cloned options (or take &CssParserOptions) to avoid relying on Copy in closures.

---

468-534: format_embedded: avoid O(n) lookup per embedded region

Each callback invocation linearly searches embedded_nodes. Build a map keyed by TextRange once, then lookups are O(1). Also, double hard lines before content may introduce an extra blank line; confirm intended spacing.

-    let new_document = formatted.format_embedded(move |range| {
-        let mut iter = embedded_nodes.iter();
-        let node = iter.find(|node| node.range == range)?;
+    use rustc_hash::FxHashMap;
+    let by_range: FxHashMap<_, _> = embedded_nodes
+        .iter()
+        .map(|n| (n.range, n))
+        .collect();
+    let new_document = formatted.format_embedded(move |range| {
+        let node = by_range.get(&range)?;

If spacing should be a single preceding hard line when indenting, consider:

-                    let elements = vec![
-                        FormatElement::Line(LineMode::Hard),
-                        FormatElement::Tag(Tag::StartIndent),
-                        FormatElement::Line(LineMode::Hard),
+                    let elements = vec![
+                        FormatElement::Line(LineMode::Hard),
+                        FormatElement::Tag(Tag::StartIndent),

crates/biome_formatter/src/format_element/document.rs (4)

175-184: Avoid cloning the whole document during transform

We can dodge an O(n) clone by moving the vec out and transforming it in one pass.

-    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
-        document.elements = Self::transform_elements(
-            document.elements.clone(),
-            visitor,
-            &ElementPath::new(Vec::new()),
-        );
-    }
+    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
+        let elements = std::mem::take(&mut document.elements);
+        document.elements = Self::transform_elements(
+            elements,
+            visitor,
+            &ElementPath::new(Vec::new()),
+        );
+    }

---

200-206: Preserve interning identity where possible

Rebuilding Interned unconditionally drops sharing/identity, which can increase memory and alter IR refs (<ref interned *>). Consider reusing the original Interned when children are unchanged.

Would you like a follow-up patch that tracks a “changed” flag to conditionally rebuild the Interned?

---

194-197: Trim path allocations

current_path.clone() per node/variant is a lot of small Vec clones. A small stack (SmallVec<[usize; 8]>) or push/pop on a shared Vec passed by &mut would reduce churn.

Also applies to: 212-215

---

207-224: Guard the unsafe best-fitting rebuild

You rely on from_vec_unchecked’s internal assert. Add a local debug_assert!(variants.len() >= 2) before the call to make the invariant obvious at the callsite.

                         let variants: Vec<Box<[FormatElement]>> = best_fitting
                             .variants()
                             .iter()
                             .enumerate()
                             .map(|(variant_index, variant)| {
                                 let mut variant_path = current_path.clone();
                                 variant_path.push(variant_index);
                                 let variant_path = ElementPath::new(variant_path);
                                 Self::transform_elements(variant.to_vec(), visitor, &variant_path)
                                     .into_boxed_slice()
                             })
                             .collect();
+                        debug_assert!(variants.len() >= 2, "BestFitting requires at least two variants");
                         unsafe {
                             FormatElement::BestFitting(BestFittingElement::from_vec_unchecked(
                                 variants,
                             ))
                         }

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

93-104: Explicitly return unit for clarity (optional)

The empty body returns (), which is fine given ParserOptions = (). Returning it explicitly can make the intent clearer to readers.

-    ) -> Self::ParserOptions {
-    }
+    ) -> Self::ParserOptions { () }

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

186-207: Parse options: confirm hard-coded grit metavariables

grit_metavariables is forced to false. If the JsParserSettings.grit_metavariables knob is meant to be honoured here (like other per-language parsers), thread it through; otherwise, a brief comment would help.

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

112-119: Be explicit about returning unit in resolve_parse_options
Add an explicit () return to this function. ParserSettings and ParserOptions are both (), and there are no GraphQL-specific parser options or overrides to propagate.

 fn resolve_parse_options(
     _overrides: &OverrideSettings,
     _language: &Self::ParserSettings,
     _path: &BiomePath,
     _file_source: &DocumentFileSource,
 ) -> Self::ParserOptions {
-}
+    ()
+}

crates/biome_html_formatter/src/html/auxiliary/embedded_content.rs (1)

1-3: Correct import; previous mismatch resolved

Using biome_rowan::TextRange is the right type here. Cheers for fixing the earlier slip.

crates/biome_formatter/src/format_element/document.rs (1)

607-610: Start/EndEmbedded IR printing now correct – cheers

StartEmbedded(_) prints an opening arm and isn’t grouped with end-tags; EndEmbedded closes. Matches the earlier suggestion.

Also applies to: 624-626

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

283-297: Excellent consistency improvement!

The parse function now correctly uses settings.parse_options::<HtmlLanguage>() instead of manually constructing options, ensuring proper override handling and consistency with other language handlers.

---

299-362: Consider using node indices instead of range comparison for performance.

The current approach requires iterating through all nodes to match ranges. Using indices would be more efficient.

Would you like me to generate a verification script to measure the performance impact of range-based lookups in embedded content extraction?

---

462-464: Performance concern with linear search.

Finding the matching embedded node via linear search through embedded_nodes.iter().find() could be inefficient for documents with many embedded elements. Consider using a HashMap for O(1) lookups.

- let mut iter = embedded_nodes.iter();
- let node = iter.find(|node| node.range == range)?;
+ // Consider preprocessing embedded_nodes into a HashMap<TextRange, FormatEmbedNode>
+ // for O(1) lookups instead of O(n) linear search

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

68-73: Fixed: CSS node() now returns CssLanguage.

This addresses the earlier bug report. Nice one.

crates/biome_html_formatter/src/html/auxiliary/embedded_content.rs (2)

11-13: Confirm range semantics for embedded content

Returning Some(node.range()) assumes the range is exactly the inner script/style text. If it includes the tag wrappers or surrounding indentation, the second pass may parse the wrong slice and misalign mappings. Please verify this returns the pure embedded source range; if not, use the inner content/token range instead and add a regression test.

I can draft a focused test case asserting the range covers only the inner text for <script> and <style>.

---

4-5: Tiny win: derive Copy on the unit struct

Unit-like formatter types are trivially copyable; adding Copy can reduce noise in generic code.

-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Copy, Default)]
 pub(crate) struct FormatHtmlEmbeddedContent;

crates/biome_js_syntax/src/syntax_node.rs (1)

29-29: Public alias looks good; add a doc comment for discoverability

Expose a short rustdoc explaining when to use this vs JsSyntaxNode.

crates/biome_css_syntax/src/syntax_node.rs (1)

25-25: CSS offset alias approved; consider rustdoc

Mirror the JS alias doc so users find this entrypoint easily.

crates/biome_formatter/src/lib.rs (3)

24-24: Drop extern crate core;

Not needed in Rust 2018+; avoid churn and warnings.

---

894-935: Avoid cloning the document and redundant swap

format_embedded mutates self.document and then returns a clone, which the caller swaps back in. Return a reference instead and drop the swap call downstream.

-    #[must_use]
-    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> Document
+    #[must_use]
+    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> &Document
     where
         F: Fn(TextRange) -> Option<Document>,
     {
         let document = &mut self.document;
         …
-        document.clone()
+        document
     }

Then remove the swap_document usage at the call site.

Happy to push a follow-up diff across biome_service to remove the now-unnecessary swap_document.

---

946-949: swap_document likely unnecessary with the above change

If format_embedded returns &Document, this can be deleted.

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

14-15: Prefer allow over expect for unused diagnostics.

#[expect(unused)] will fail the build once the field becomes used. If you just want to silence the lint, use allow (or narrower dead_code) at field scope.

-    #[expect(unused)]
+    #[allow(dead_code)]

---

121-124: Doc wording for Option/Result is ambiguous.

Clarify when None, Ok and Err occur.

-    /// - `Option`: if the file can be read
-    /// - `Result`: if the file is read, but the file is too large
+    /// - `Option`: `None` if the file cannot be read; `Some(..)` otherwise.
+    /// - `Result`: `Ok(AnyParse)` when parsed; `Err(FileTooLarge)` when rejected due to size.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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 : 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/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

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/cst.rs : Provide the FormatNodeRule trait wiring (fmt, fmt_fields, is_suppressed, fmt_leading_comments, fmt_dangling_comments, fmt_trailing_comments) used to start node formatting

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/context.rs : Define HtmlFormatContext in context.rs with fields comments: Rc<HtmlComments> and source_map: Option<TransformSourceMap>, and implement FormatContext and CstFormatContext

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: 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 : Build an intermediate IR via the provided helper APIs when formatting

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/comments.rs : Define HtmlComments alias and HtmlCommentStyle in comments.rs, and implement CommentStyle for the language

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

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_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : When a token is mandatory and present in the AST, use the AST-provided token (e.g., node.l_paren_token().format()) instead of hardcoded tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-09-10T08:05:22.867Z
Learning: Applies to crates/biome_analyze/**/src/{lint,assist}/**/*.rs : Code blocks in rule docs must specify language; invalid snippets require `expect_diagnostic`; use `options`/`full_options`/`use_options` markers as appropriate

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_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/lib.rs : Create the type alias: type HtmlFormatter<'buf> = Formatter<'buf, HtmlFormatContext>

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_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_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/{src,biome_module_graph/src}/**/*.rs : When pattern-matching on ResolvedTypeData via as_raw_data(), ensure any nested TypeReferences are subsequently resolved using the correct ResolverId; never use the raw data with a resolver without applying the right ResolverId to avoid panics

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Implement FormatLanguage for HtmlFormatLanguage binding SyntaxLanguage = HtmlLanguage, Context = HtmlFormatContext, and FormatRule = FormatHtmlSyntaxNode

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/**/*.rs : Use dbg_write! to debug and inspect the written IR elements during formatter development

crates/biome_html_parser/src/parser.rs (1)

121-126: Good addition; this matches the earlier suggestion.

Implements the exact setter signature previously requested and the logic is sound (true → Double, false → None).

crates/biome_formatter/src/format_element/document.rs (2)

155-162: Avoid cloning the whole elements vec during transform

Use mem::take to move elements out, transform, and put them back. Zero-copy win.

-    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
-        document.elements = Self::transform_elements(document.elements.clone(), visitor);
-    }
+    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
+        let elements = std::mem::take(&mut document.elements);
+        document.elements = Self::transform_elements(elements, visitor);
+    }

---

187-193: Strengthen unsafe invariants doc for from_vec_unchecked

The current SAFETY note only mentions count preservation. Please spell out all invariants (len ≥ 2; ordering from least to most expanded preserved; variants content remains valid post-visit), and consider a debug_assert on len ≥ 2 here for belt-and-braces.

Example:

// SAFETY: `variants` preserves original variant ordering (least..most expanded),
// contains at least two entries, and each transformed variant remains a valid
// sequence of FormatElement. Length is unchanged from input.
debug_assert!(variants.len() >= 2);
unsafe {
    FormatElement::BestFitting(BestFittingElement::from_vec_unchecked(variants))
}

crates/biome_html_parser/src/parser.rs (2)

121-126: Document the “false resets to None” semantics.

A brief rustdoc will avoid readers assuming “false” switches to Single rather than disabling expressions.

-    pub fn set_double_text_expression(&mut self, value: bool) {
+    /// Toggle parsing of double-quoted text expressions.
+    ///
+    /// When `value` is `true`, enables [`TextExpressionKind::Double`].
+    /// When `false`, disables text expressions entirely (`None`).
+    /// Use [`HtmlParseOptions::with_single_text_expression`] to enable single-quoted mode.
+    pub fn set_double_text_expression(&mut self, value: bool) {

---

121-126: Consider a more general setter (optional).

If more toggles are added, a single set_text_expression(Option<TextExpressionKind>) could reduce API surface while covering this case.

+    /// Set the text expression mode explicitly.
+    pub fn set_text_expression(&mut self, kind: Option<TextExpressionKind>) {
+        self.text_expression = kind;
+    }

crates/biome_formatter/src/lib.rs (4)

53-56: Prefer consistent import path for DocumentVisitor

Minor consistency nit: you import Document/ElementTransformer from format_element::document but DocumentVisitor from prelude::document. Import all three from the same module to keep things tidy.

Apply:

- use crate::format_element::document::{Document, ElementTransformer};
- use crate::prelude::document::DocumentVisitor;
+ use crate::format_element::document::{Document, ElementTransformer, DocumentVisitor};

---

893-934: Avoid in-place mutate + clone; return a reference or build-and-swap (not both)

format_embedded mutates self.document and then returns a clone, forcing callers to swap an already-updated document. Pick one model to avoid extra allocation.

Option A (mutate, return &Document; update callers to drop swap):

-    #[must_use]
-    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> Document
+    #[must_use]
+    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> &Document
     where
         F: Fn(TextRange) -> Option<Document>,
 {
     let document = &mut self.document;
     ...
-    document.clone()
+    &self.document
 }

And in biome_service/src/file_handlers/html.rs:

-    let new_document = formatted.format_embedded(move |range| { /* ... */ });
-    formatted.swap_document(new_document);
+    formatted.format_embedded(move |range| { /* ... */ });

Option B (don’t mutate; return a new Document and let callers swap):

• Build a fresh Document and return it; remove the in-place transform.

---

917-922: Unconditional hard line after EndEmbedded may over-break

Replacing EndEmbedded with Line(Hard) can double-insert blank lines depending on the embedded formatter’s trailing whitespace. Consider omitting the replacement (return None) and letting the inserted Document control spacing, or make it conditional.

Minimal change:

-    FormatElement::Tag(Tag::EndEmbedded) => {
-        // FIXME: this might not play well for all cases, so we need to figure out
-        // a nicer way to replace the tag
-        Some(FormatElement::Line(LineMode::Hard))
-    }
+    FormatElement::Tag(Tag::EndEmbedded) => None

Please add/confirm tests for:

• Adjacent <script> and <style> blocks.
• Embedded block at EOF and at BOF.
• indent_script_and_style on/off.

---

1543-1615: format_node_with_offset duplicates format_node; consider a shared helper

The body largely mirrors format_node. Extract a private helper to reduce drift and ease maintenance.

Sketch:

fn format_node_impl<L: FormatLanguage>(
    root: SyntaxNode<L::SyntaxLanguage>,
    language: L,
) -> FormatResult<Formatted<L::Context>> { /* current shared body */ }

pub fn format_node<L: FormatLanguage>(root: &SyntaxNode<L::SyntaxLanguage>, language: L) -> ... {
    format_node_impl(root.clone(), language)
}

pub fn format_node_with_offset<L: FormatLanguage>(
    root: &SyntaxNodeWithOffset<L::SyntaxLanguage>,
    language: L,
) -> ... {
    // resolve transformed SyntaxNode, then:
    format_node_impl(resolved_root, language)
}

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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

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_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_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

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/context.rs : Define HtmlFormatContext in context.rs with fields comments: Rc<HtmlComments> and source_map: Option<TransformSourceMap>, and implement FormatContext and CstFormatContext

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/cst.rs : Provide the FormatNodeRule trait wiring (fmt, fmt_fields, is_suppressed, fmt_leading_comments, fmt_dangling_comments, fmt_trailing_comments) used to start node 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: 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 : Do not attempt to fix code: if a mandatory token/node is missing, return None instead

crates/biome_formatter/src/format_element/document.rs (2)

160-163: Avoid cloning the entire element vector during transform

Use std::mem::take to move elements out, transform, and put them back. Cuts a full clone.

-    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
-        document.elements = Self::transform_elements(document.elements.clone(), visitor);
-    }
+    pub fn transform_document<V: DocumentVisitor>(document: &mut Document, visitor: &mut V) {
+        let elements = std::mem::take(&mut document.elements);
+        document.elements = Self::transform_elements(elements, visitor);
+    }

---

187-192: Add explicit safety invariants for from_vec_unchecked

The unsafe is fine, but please document the upheld invariants (and keep them true).

-                        // SAFETY: Safe because the number of variants is the same after the transformation
+                        // SAFETY:
+                        // - The number of variants is unchanged (>= 2).
+                        // - The ordering (least→most expanded) is preserved.
+                        // - Each element remains valid after visiting.
                         unsafe {

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

53-56: Unify import path for DocumentVisitor

Import it from the same module as Document/ElementTransformer for consistency (and fewer surprises if prelude re-exports change).

-use crate::prelude::document::DocumentVisitor;
+use crate::format_element::document::DocumentVisitor;

---

893-934: Don’t clone the whole Document; make format_embedded mutate-and-return a reference (also allow FnMut)

You already mutate self.document via ElementTransformer; returning a clone then swapping it back is redundant. Returning &Document avoids the extra allocation and lets call-sites drop swap_document. Allowing FnMut gives callers room to cache/look up state.

-    #[must_use]
-    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> Document
+    #[must_use]
+    pub fn format_embedded<F>(&mut self, fn_format_embedded: F) -> &Document
     where
-        F: Fn(TextRange) -> Option<Document>,
+        F: FnMut(TextRange) -> Option<Document>,
     {
         let document = &mut self.document;

         struct EmbeddedVisitor<F> {
             fn_format_embedded: F,
         }

-        impl<F> DocumentVisitor for EmbeddedVisitor<F>
+        impl<F> DocumentVisitor for EmbeddedVisitor<F>
         where
-            F: Fn(TextRange) -> Option<Document>,
+            F: FnMut(TextRange) -> Option<Document>,
         {
             fn visit_element(&mut self, element: &FormatElement) -> Option<FormatElement> {
                 match element {
                     FormatElement::Tag(Tag::StartEmbedded(range)) => {
                         (self.fn_format_embedded)(*range).map(|document| {
                             FormatElement::Interned(Interned::new(document.into_elements()))
                         })
                     }
                     FormatElement::Tag(Tag::EndEmbedded) => {
                         // FIXME: this might not play well for all cases, so we need to figure out
                         // a nicer way to replace the tag
                         Some(FormatElement::Line(LineMode::Hard))
                     }
                     _ => None,
                 }
             }
         }

         ElementTransformer::transform_document(
             document,
             &mut EmbeddedVisitor { fn_format_embedded },
         );

-        document.clone()
+        &self.document
     }

Follow-up: update call-sites (e.g. html handler) to drop the swap:

-    let new_document = formatted.format_embedded(move |range| { /* ... */ });
-    formatted.swap_document(new_document);
+    formatted.format_embedded(move |range| { /* ... */ });

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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_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_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

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/context.rs : Define HtmlFormatContext in context.rs with fields comments: Rc<HtmlComments> and source_map: Option<TransformSourceMap>, and implement FormatContext and CstFormatContext

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/cst.rs : Provide the FormatNodeRule trait wiring (fmt, fmt_fields, is_suppressed, fmt_leading_comments, fmt_dangling_comments, fmt_trailing_comments) used to start node 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: 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 : Do not attempt to fix code: if a mandatory token/node is missing, return None instead

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

283-290: Good to see the parse function now uses resolve_parse_options!

The implementation properly delegates to settings.parse_options::<HtmlLanguage>() which respects overrides and language-specific settings.

---

464-464: Performance concern: Linear search through all embedded nodes

Finding nodes by comparing ranges requires iterating through potentially many embedded nodes. As mentioned in previous reviews, using an index would be more efficient.

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

468-519: Consider extracting common formatting logic

Both JS and CSS branches contain nearly identical logic for applying indentation. This duplication could be reduced.

Extract the common pattern into a helper function:

+fn format_embedded_with_indent(
+    formatted: Document,
+    indent: bool,
+) -> Document {
+    let elements = if indent {
+        vec![
+            FormatElement::Line(LineMode::Hard),
+            FormatElement::Tag(Tag::StartIndent),
+            FormatElement::Line(LineMode::Hard),
+            FormatElement::Interned(Interned::new(formatted.into_elements())),
+            FormatElement::Tag(Tag::EndIndent),
+        ]
+    } else {
+        vec![
+            FormatElement::Line(LineMode::Hard),
+            FormatElement::Interned(Interned::new(formatted.into_elements())),
+        ]
+    };
+    Document::new(elements)
+}

 match node.source {
     DocumentFileSource::Js(_) => {
         let js_options = settings.format_options::<JsLanguage>(biome_path, &node.source);
         let node = node.node.clone().root.into_node::<JsLanguage>();
         let formatted =
             biome_js_formatter::format_node_with_offset(js_options, &node).ok()?;
-        if indent_script_and_style {
-            let elements = vec![
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Tag(Tag::StartIndent),
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Interned(Interned::new(
-                    formatted.into_document().into_elements(),
-                )),
-                FormatElement::Tag(Tag::EndIndent),
-            ];
-
-            Some(Document::new(elements))
-        } else {
-            let elements = vec![
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Interned(Interned::new(
-                    formatted.into_document().into_elements(),
-                )),
-            ];
-            Some(Document::new(elements))
-        }
+        Some(format_embedded_with_indent(
+            formatted.into_document(),
+            indent_script_and_style,
+        ))
     }
     DocumentFileSource::Css(_) => {
         let css_options = settings.format_options::<CssLanguage>(biome_path, &node.source);
         let node = node.node.clone().root.into_node::<CssLanguage>();
         let formatted =
             biome_css_formatter::format_node_with_offset(css_options, &node).ok()?;
-        if indent_script_and_style {
-            let elements = vec![
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Tag(Tag::StartIndent),
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Interned(Interned::new(
-                    formatted.into_document().into_elements(),
-                )),
-                FormatElement::Tag(Tag::EndIndent),
-            ];
-            let document = Document::new(elements);
-            Some(document)
-        } else {
-            let elements = vec![
-                FormatElement::Line(LineMode::Hard),
-                FormatElement::Interned(Interned::new(
-                    formatted.into_document().into_elements(),
-                )),
-            ];
-            Some(Document::new(elements))
-        }
+        Some(format_embedded_with_indent(
+            formatted.into_document(),
+            indent_script_and_style,
+        ))
     }
     _ => None,
 }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

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/context.rs : Define HtmlFormatContext in context.rs with fields comments: Rc<HtmlComments> and source_map: Option<TransformSourceMap>, and implement FormatContext and CstFormatContext

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_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: 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_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/comments.rs : Define HtmlComments alias and HtmlCommentStyle in comments.rs, and implement CommentStyle for the language

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 : Import the FormatNode trait and implement it for your Node

crates/biome_html_syntax/Cargo.toml (2)

16-16: Avoid duplicating feature gating for biome_rowan/serde.

You’re enabling biome_rowan’s serde unconditionally and also listing it under the schema feature. Pick one. Recommend gating via schema only.

-biome_rowan = { workspace = true, features = ["serde"] }
+biome_rowan = { workspace = true }

---

4-4: Tweak description to avoid layering leak.

Referencing the parser from the syntax crate blurs boundaries. Suggest a neutral phrasing.

-description = "SyntaxKind and common rowan definitions for biome_html_parser"
+description = "Syntax kinds and common Rowan definitions for the HTML language"

crates/biome_html_formatter/tests/quick_test.rs (1)

34-34: Exercise both code paths for embedded formatting

Nice API update. Consider toggling the delegation via a local var so it’s trivial to run both paths during ad‑hoc checks.

-    let doc = format_node(options.clone(), &tree.syntax(), false).unwrap();
+    let delegate_fmt_embedded_nodes = false; // flip to true to try delegated embedded formatting
+    let doc = format_node(options.clone(), &tree.syntax(), delegate_fmt_embedded_nodes).unwrap();

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

374-376: Rename/docs nit: clarify what “delegate embedded” means

Field and methods look good. A tiny doc pass would help future readers (“delegating embedded nodes” = allow script/style to be formatted by their own formatters). No behaviour change.

 pub struct HtmlFormatContext {
     options: HtmlFormatOptions,
     /// The comments of the nodes and tokens in the document.
     comments: Rc<HtmlComments>,
     source_map: Option<TransformSourceMap>,
-    should_delegate_fmt_embedded_nodes: bool,
+    /// When true, HTML formatting may delegate embedded content (e.g. <script>/<style>)
+    /// to the respective language formatter.
+    should_delegate_fmt_embedded_nodes: bool,
 }

 impl HtmlFormatContext {
     pub fn new(options: HtmlFormatOptions, comments: HtmlComments) -> Self {
         Self {
             options,
             comments: Rc::new(comments),
             source_map: None,
             should_delegate_fmt_embedded_nodes: false,
         }
     }

-    pub fn with_fmt_embedded_nodes(mut self) -> Self {
+    /// Enable delegation of embedded content formatting.
+    pub fn with_fmt_embedded_nodes(mut self) -> Self {
         self.should_delegate_fmt_embedded_nodes = true;
         self
     }

-    pub fn should_delegate_fmt_embedded_nodes(&self) -> bool {
+    /// Returns whether embedded content formatting is delegated.
+    pub fn should_delegate_fmt_embedded_nodes(&self) -> bool {
         self.should_delegate_fmt_embedded_nodes
     }

Also applies to: 384-385, 393-396, 398-400

crates/biome_html_syntax/src/element_ext.rs (1)

86-88: Fill the test stub with real cases.

Add assertions for: no type, type="text/javascript", type="module", and a non‑JS MIME type. Happy to draft if you like.

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

462-465: Drop the temp iterator.

Slight tidy to avoid an unused mutable:

-        let mut iter = embedded_nodes.iter();
-        let node = iter.find(|node| node.range == range)?;
+        let node = embedded_nodes.iter().find(|n| n.range == range)?;

---

472-493: Avoid extra blank lines around embedded content.

You add a hard line before StartIndent and another hard line immediately after, plus an extra hard line from EndEmbedded replacement. This can yield double spacing. Suggest keeping a single leading hard line and relying on EndEmbedded’s hard line for the trailing break:

-                    let elements = vec![
-                        FormatElement::Line(LineMode::Hard),
-                        FormatElement::Tag(Tag::StartIndent),
-                        FormatElement::Line(LineMode::Hard),
-                        FormatElement::Interned(Interned::new(
-                            formatted.into_document().into_elements(),
-                        )),
-                        FormatElement::Tag(Tag::EndIndent),
-                    ];
+                    let elements = vec![
+                        FormatElement::Tag(Tag::StartIndent),
+                        FormatElement::Line(LineMode::Hard),
+                        FormatElement::Interned(Interned::new(
+                            formatted.into_document().into_elements(),
+                        )),
+                        FormatElement::Tag(Tag::EndIndent),
+                    ];

Apply the same to the CSS branch.

Also applies to: 500-519

---

471-474: Don’t silently swallow formatter errors for embedded nodes.

.ok()? will drop errors and leave StartEmbedded unreplaced, risking a broken print. Consider logging and substituting the original text, or accumulating an error and returning WorkspaceError from format_embedded. I can sketch a small error collector if helpful.

Also applies to: 497-499

crates/biome_formatter/src/lib.rs (6)

46-46: Remove unused import TagKind.

It’s not referenced; drop it to avoid warnings.

- use crate::prelude::{Tag, TagKind};
+ use crate::prelude::Tag;

---

893-931: Avoid unconditional EndEmbedded hard line; track only when a StartEmbedded was replaced.

Today, if the closure returns None, EndEmbedded still becomes a hard line, producing stray newlines. Track whether a start tag was transformed before emitting the trailing line. Also consider re-propagating expand after transformation.

-        struct EmbeddedVisitor<F> {
-            fn_format_embedded: F,
-        }
+        struct EmbeddedVisitor<F> {
+            fn_format_embedded: F,
+            should_replace_end: bool,
+        }

         impl<F> DocumentVisitor for EmbeddedVisitor<F>
         where
             F: FnMut(TextRange) -> Option<Document>,
         {
             fn visit_element(&mut self, element: &FormatElement) -> Option<FormatElement> {
                 match element {
                     FormatElement::Tag(Tag::StartEmbedded(range)) => {
-                        (self.fn_format_embedded)(*range).map(|document| {
-                            FormatElement::Interned(Interned::new(document.into_elements()))
-                        })
+                        if let Some(document) = (self.fn_format_embedded)(*range) {
+                            self.should_replace_end = true;
+                            Some(FormatElement::Interned(Interned::new(
+                                document.into_elements(),
+                            )))
+                        } else {
+                            None
+                        }
                     }
                     FormatElement::Tag(Tag::EndEmbedded) => {
-                        // FIXME: this might not play well for all cases, so we need to figure out
-                        // a nicer way to replace the tag
-                        Some(FormatElement::Line(LineMode::Hard))
+                        if self.should_replace_end {
+                            self.should_replace_end = false;
+                            Some(FormatElement::Line(LineMode::Hard))
+                        } else {
+                            None
+                        }
                     }
                     _ => None,
                 }
             }
         }

         ElementTransformer::transform_document(
             document,
-            &mut EmbeddedVisitor { fn_format_embedded },
+            &mut EmbeddedVisitor { fn_format_embedded, should_replace_end: false },
         );
+        // Re-run expansion propagation to account for injected elements.
+        document.propagate_expand();

Verification: please add a test where the closure returns None for an embedded range to ensure no extra blank line is introduced.

---

1472-1474: Fix parameter name and wording in docs.

The comment mentions skip_embedded_nodes and has a stray backtick; the parameter is delegate_fmt_embedded_nodes.

-/// When `skip_embedded_nodes` is `true`, the content of `<script>` and `<style` is formatted
-/// verbatim.
+/// When `delegate_fmt_embedded_nodes` is true, the language emits embedded markers for content
+/// such as `<script>` and `<style>`; callers should then run a second pass via
+/// `Formatted::format_embedded` to format that content. Otherwise, embedded content is treated verbatim.

---

1479-1481: Remove needless clone when calling transform.

Borrow the parameter directly; the clone is redundant.

-    let (root, source_map) = match language.transform(&root.clone()) {
+    let (root, source_map) = match language.transform(root) {

---

1482-1482: Drop needless reference in equality.

One more ampersand bites the dust; keeps Clippy happy.

-            if &transformed == root {
+            if transformed == root {

---

1549-1618: Nit: avoid clone in offset variant too.

Mirror the non-offset fix.

-    let (root, source_map) = match language.transform(&root.node.clone()) {
+    let (root, source_map) = match language.transform(&root.node) {