diff --git a/Cargo.lock b/Cargo.lock
index 8bb4d7c9403d..044d18c49d45 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -493,7 +493,6 @@ dependencies = [
  "rustc-hash 2.1.1",
  "schemars",
  "serde",
- "tracing",
  "unicode-width 0.1.12",
 ]
 
@@ -810,6 +809,8 @@ dependencies = [
 name = "biome_html_syntax"
 version = "0.5.7"
 dependencies = [
+ "biome_html_factory",
+ "biome_html_parser",
  "biome_rowan",
  "biome_string_case",
  "camino",
diff --git a/crates/biome_cli/tests/cases/html.rs b/crates/biome_cli/tests/cases/html.rs
index d7a27a71318e..c82391a7d094 100644
--- a/crates/biome_cli/tests/cases/html.rs
+++ b/crates/biome_cli/tests/cases/html.rs
@@ -90,3 +90,96 @@ fn should_not_error_when_interpolation_is_enabled() {
         result,
     ));
 }
+
+#[test]
+fn should_format_indent_embedded_languages() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let html_file = Utf8Path::new("file.html");
+    fs.insert(
+        html_file.into(),
+        r#"<script>function lorem() { return "ipsum" }</script>
+<style>#id .class div > p { background-color: red; align: center; padding: 0; } </style>
+"#
+        .as_bytes(),
+    );
+
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "formatter": {
+            "enabled": true,
+            "indentScriptAndStyle": true
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["format", "--write", html_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_format_indent_embedded_languages",
+        fs,
+        console,
+        result,
+    ));
+}
+
+#[test]
+fn should_format_indent_embedded_languages_with_language_options() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let html_file = Utf8Path::new("file.html");
+    fs.insert(
+        html_file.into(),
+        r#"<script>function lorem() { return "ipsum" }</script>
+<style>#id .class div > p { background-color: red; align: center; padding: 0; } </style>
+"#
+        .as_bytes(),
+    );
+
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "formatter": {
+            "enabled": true,
+            "indentScriptAndStyle": true
+        }
+    },
+    "javascript": {
+        "formatter": {
+            "quoteStyle": "single"
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["format", "--write", html_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_format_indent_embedded_languages_with_language_options",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages.snap
new file mode 100644
index 000000000000..5908c428fe34
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages.snap
@@ -0,0 +1,40 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "formatter": {
+      "enabled": true,
+      "indentScriptAndStyle": true
+    }
+  }
+}
+```
+
+## `file.html`
+
+```html
+<script>
+	function lorem() {
+		return "ipsum";
+	}
+</script>
+<style>
+	#id .class div > p {
+		background-color: red;
+		align: center;
+		padding: 0;
+	}
+</style>
+
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages_with_language_options.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages_with_language_options.snap
new file mode 100644
index 000000000000..3baa3a0b5242
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_format_indent_embedded_languages_with_language_options.snap
@@ -0,0 +1,45 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "formatter": {
+      "enabled": true,
+      "indentScriptAndStyle": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single"
+    }
+  }
+}
+```
+
+## `file.html`
+
+```html
+<script>
+	function lorem() {
+		return 'ipsum';
+	}
+</script>
+<style>
+	#id .class div > p {
+		background-color: red;
+		align: center;
+		padding: 0;
+	}
+</style>
+
+```
+
+# Emitted Messages
+
+```block
+Formatted 1 file in <TIME>. Fixed 1 file.
+```
diff --git a/crates/biome_css_formatter/src/lib.rs b/crates/biome_css_formatter/src/lib.rs
index 8e1519f2b44b..8d75c1fd044d 100644
--- a/crates/biome_css_formatter/src/lib.rs
+++ b/crates/biome_css_formatter/src/lib.rs
@@ -22,7 +22,7 @@ use crate::prelude::{format_bogus_node, format_suppressed_node};
 pub(crate) use crate::trivia::*;
 use biome_css_syntax::{
     AnyCssDeclarationBlock, AnyCssRule, AnyCssRuleBlock, AnyCssValue, CssLanguage, CssSyntaxKind,
-    CssSyntaxNode, CssSyntaxToken,
+    CssSyntaxNode, CssSyntaxNodeWithOffset, CssSyntaxToken,
 };
 use biome_formatter::comments::Comments;
 use biome_formatter::prelude::*;
@@ -289,6 +289,7 @@ impl FormatLanguage for CssFormatLanguage {
         self,
         root: &CssSyntaxNode,
         source_map: Option<TransformSourceMap>,
+        _delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments = Comments::from_node(root, &CssCommentStyle, source_map.as_ref());
         CssFormatContext::new(self.options, comments).with_source_map(source_map)
@@ -378,7 +379,17 @@ pub fn format_node(
     options: CssFormatOptions,
     root: &CssSyntaxNode,
 ) -> FormatResult<Formatted<CssFormatContext>> {
-    biome_formatter::format_node(root, CssFormatLanguage::new(options))
+    biome_formatter::format_node(root, CssFormatLanguage::new(options), false)
+}
+
+/// Formats a CSS syntax tree.
+///
+/// It returns the [Formatted] document that can be printed to a string.
+pub fn format_node_with_offset(
+    options: CssFormatOptions,
+    root: &CssSyntaxNodeWithOffset,
+) -> FormatResult<Formatted<CssFormatContext>> {
+    biome_formatter::format_node_with_offset(root, CssFormatLanguage::new(options), false)
 }
 
 /// Formats a single node within a file, supported by Biome.
diff --git a/crates/biome_css_syntax/src/syntax_node.rs b/crates/biome_css_syntax/src/syntax_node.rs
index 6d32619b562c..a814ebe4efcb 100644
--- a/crates/biome_css_syntax/src/syntax_node.rs
+++ b/crates/biome_css_syntax/src/syntax_node.rs
@@ -22,3 +22,4 @@ pub type CssSyntaxElement = biome_rowan::SyntaxElement<CssLanguage>;
 pub type CssSyntaxNodeChildren = biome_rowan::SyntaxNodeChildren<CssLanguage>;
 pub type CssSyntaxElementChildren = biome_rowan::SyntaxElementChildren<CssLanguage>;
 pub type CssSyntaxList = biome_rowan::SyntaxList<CssLanguage>;
+pub type CssSyntaxNodeWithOffset = biome_rowan::SyntaxNodeWithOffset<CssLanguage>;
diff --git a/crates/biome_formatter/Cargo.toml b/crates/biome_formatter/Cargo.toml
index 662e664c0f14..7791446d054e 100644
--- a/crates/biome_formatter/Cargo.toml
+++ b/crates/biome_formatter/Cargo.toml
@@ -28,7 +28,6 @@ indexmap                 = { workspace = true }
 rustc-hash               = { workspace = true }
 schemars                 = { workspace = true, optional = true }
 serde                    = { workspace = true, features = ["derive"], optional = true }
-tracing                  = { workspace = true }
 unicode-width            = { workspace = true }
 
 [dev-dependencies]
diff --git a/crates/biome_formatter/src/format_element.rs b/crates/biome_formatter/src/format_element.rs
index 938003ea845c..0c8ae3d13ea3 100644
--- a/crates/biome_formatter/src/format_element.rs
+++ b/crates/biome_formatter/src/format_element.rs
@@ -126,7 +126,7 @@ impl PrintMode {
 pub struct Interned(Rc<[FormatElement]>);
 
 impl Interned {
-    pub(super) fn new(content: Vec<FormatElement>) -> Self {
+    pub fn new(content: Vec<FormatElement>) -> Self {
         Self(content.into())
     }
 }
diff --git a/crates/biome_formatter/src/format_element/document.rs b/crates/biome_formatter/src/format_element/document.rs
index 5569eac969d4..4d124e942957 100644
--- a/crates/biome_formatter/src/format_element/document.rs
+++ b/crates/biome_formatter/src/format_element/document.rs
@@ -1,4 +1,5 @@
 #![expect(clippy::mutable_key_type)]
+
 use super::tag::Tag;
 use crate::format_element::tag::DedentMode;
 use crate::prelude::tag::GroupMode;
@@ -19,6 +20,10 @@ pub struct Document {
 }
 
 impl Document {
+    pub fn new(elements: Vec<FormatElement>) -> Self {
+        Self { elements }
+    }
+
     /// Sets [`expand`](tag::Group::expand) to [`GroupMode::Propagated`] if the group contains any of:
     /// * a group with [`expand`](tag::Group::expand) set to [GroupMode::Propagated] or [GroupMode::Expand].
     /// * a non-soft [line break](FormatElement::Line) with mode [LineMode::Hard], [LineMode::Empty], or [LineMode::Literal].
@@ -132,6 +137,75 @@ impl Document {
         let mut interned = FxHashMap::default();
         propagate_expands(self, &mut enclosing, &mut interned);
     }
+
+    pub fn into_elements(self) -> Vec<FormatElement> {
+        self.elements
+    }
+
+    pub fn as_elements(&self) -> &[FormatElement] {
+        &self.elements
+    }
+}
+
+pub trait DocumentVisitor {
+    /// Visit an element and optionally return a replacement
+    fn visit_element(&mut self, element: &FormatElement) -> Option<FormatElement>;
+}
+
+/// Applies a visitor to transform elements in the document
+pub struct ElementTransformer;
+
+impl ElementTransformer {
+    /// Visits a mutable [Document] and replaces its internal elements.
+    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);
+    }
+
+    /// Iterates over each element of the document and map each element to a new element. The new element is
+    /// optionally crated using [DocumentVisitor::visit_element]. If no element is returned, the original element is kept.
+    ///
+    /// Nested data structures such as [FormatElement::Interned] and [FormatElement::BestFitting] use recursion and call
+    /// [Self::transform_elements] again.
+    fn transform_elements<V: DocumentVisitor>(
+        elements: Vec<FormatElement>,
+        visitor: &mut V,
+    ) -> Vec<FormatElement> {
+        elements
+            .into_iter()
+            .map(|element| {
+                // Transform nested elements first
+                let transformed_element = match element {
+                    FormatElement::Interned(interned) => {
+                        let nested_elements = interned.deref().to_vec();
+                        let transformed_nested = Self::transform_elements(nested_elements, visitor);
+                        FormatElement::Interned(Interned::new(transformed_nested))
+                    }
+                    FormatElement::BestFitting(best_fitting) => {
+                        let variants: Vec<Box<[FormatElement]>> = best_fitting
+                            .variants()
+                            .iter()
+                            .map(|variant| {
+                                Self::transform_elements(variant.to_vec(), visitor)
+                                    .into_boxed_slice()
+                            })
+                            .collect();
+                        // SAFETY: Safe because the number of variants is the same after the transformation
+                        unsafe {
+                            FormatElement::BestFitting(BestFittingElement::from_vec_unchecked(
+                                variants,
+                            ))
+                        }
+                    }
+                    other => other,
+                };
+                // Then apply a visitor to the element itself
+                visitor
+                    .visit_element(&transformed_element)
+                    .unwrap_or(transformed_element)
+            })
+            .collect()
+    }
 }
 
 impl From<Vec<FormatElement>> for Document {
@@ -530,6 +604,9 @@ impl Format<IrFormatContext> for &[FormatElement] {
                             write!(f, [text("fill(")])?;
                         }
 
+                        StartEmbedded(_) => {
+                            write!(f, [text("embedded(")])?;
+                        }
                         StartEntry => {
                             // handled after the match for all start tags
                         }
@@ -544,7 +621,8 @@ impl Format<IrFormatContext> for &[FormatElement] {
                         | EndGroup
                         | EndLineSuffix
                         | EndDedent(_)
-                        | EndVerbatim => {
+                        | EndVerbatim
+                        | EndEmbedded => {
                             write!(f, [ContentArrayEnd, text(")")])?;
                         }
                     };
diff --git a/crates/biome_formatter/src/format_element/tag.rs b/crates/biome_formatter/src/format_element/tag.rs
index 473c515d6f8c..d77f081fdc6d 100644
--- a/crates/biome_formatter/src/format_element/tag.rs
+++ b/crates/biome_formatter/src/format_element/tag.rs
@@ -1,5 +1,6 @@
 use crate::format_element::PrintMode;
 use crate::{GroupId, TextSize};
+use biome_rowan::TextRange;
 use std::cell::Cell;
 use std::num::NonZeroU8;
 
@@ -67,6 +68,11 @@ pub enum Tag {
     /// See [crate::builders::labelled] for documentation.
     StartLabelled(LabelId),
     EndLabelled,
+
+    /// Content that will be formatted later by another formatter.
+    /// These tags must be removed during the second pass.
+    StartEmbedded(TextRange),
+    EndEmbedded,
 }
 
 impl Tag {
@@ -85,6 +91,7 @@ impl Tag {
                 | Self::StartLineSuffix
                 | Self::StartVerbatim(_)
                 | Self::StartLabelled(_)
+                | Self::StartEmbedded(_)
         )
     }
 
@@ -108,13 +115,14 @@ impl Tag {
             StartLineSuffix | EndLineSuffix => TagKind::LineSuffix,
             StartVerbatim(_) | EndVerbatim => TagKind::Verbatim,
             StartLabelled(_) | EndLabelled => TagKind::Labelled,
+            StartEmbedded(_) | EndEmbedded => TagKind::Embedded,
         }
     }
 }
 
-/// The kind of a [Tag].
+/// The kind of [Tag].
 ///
-/// Each start end tag pair has its own [tag kind](TagKind).
+/// Each start-end tag pair has its own [tag kind](TagKind).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum TagKind {
@@ -129,6 +137,7 @@ pub enum TagKind {
     LineSuffix,
     Verbatim,
     Labelled,
+    Embedded,
 }
 
 #[derive(Debug, Copy, Default, Clone, Eq, PartialEq)]
diff --git a/crates/biome_formatter/src/lib.rs b/crates/biome_formatter/src/lib.rs
index 37eb82cbe3a0..b3a85a737f2c 100644
--- a/crates/biome_formatter/src/lib.rs
+++ b/crates/biome_formatter/src/lib.rs
@@ -43,14 +43,16 @@ pub mod trivia;
 
 use crate::formatter::Formatter;
 use crate::group_id::UniqueGroupIdBuilder;
-use crate::prelude::TagKind;
+use crate::prelude::{Tag, TagKind};
 use std::fmt;
 use std::fmt::{Debug, Display};
 
 use crate::builders::syntax_token_cow_slice;
 use crate::comments::{CommentStyle, Comments, SourceComment};
 pub use crate::diagnostics::{ActualStart, FormatError, InvalidDocumentError, PrintError};
-use crate::format_element::document::Document;
+use crate::format_element::document::{Document, ElementTransformer};
+use crate::format_element::{Interned, LineMode};
+use crate::prelude::document::DocumentVisitor;
 #[cfg(debug_assertions)]
 use crate::printed_tokens::PrintedTokens;
 use crate::printer::{Printer, PrinterOptions};
@@ -63,8 +65,8 @@ use biome_deserialize::{
 use biome_deserialize_macros::Deserializable;
 use biome_deserialize_macros::Merge;
 use biome_rowan::{
-    Language, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxResult, SyntaxToken, SyntaxTriviaPiece,
-    TextLen, TextRange, TextSize, TokenAtOffset,
+    Language, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxNodeWithOffset, SyntaxResult,
+    SyntaxToken, SyntaxTriviaPiece, TextLen, TextRange, TextSize, TokenAtOffset,
 };
 pub use buffer::{
     Buffer, BufferExtensions, BufferSnapshot, Inspect, PreambleBuffer, RemoveSoftLinesBuffer,
@@ -888,6 +890,45 @@ impl<Context> Formatted<Context> {
         &self.context
     }
 
+    /// Visits each embedded element and replaces it with elements contained inside the [Document]
+    /// emitted by `fn_format_embedded`
+    pub fn format_embedded<F>(&mut self, fn_format_embedded: F)
+    where
+        F: FnMut(TextRange) -> Option<Document>,
+    {
+        let document = &mut self.document;
+
+        struct EmbeddedVisitor<F> {
+            fn_format_embedded: F,
+        }
+
+        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()))
+                        })
+                    }
+                    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 },
+        );
+    }
+
     /// Returns the formatted document.
     pub fn document(&self) -> &Document {
         &self.document
@@ -897,6 +938,10 @@ impl<Context> Formatted<Context> {
     pub fn into_document(self) -> Document {
         self.document
     }
+
+    pub fn swap_document(&mut self, document: Document) {
+        self.document = document;
+    }
 }
 
 impl<Context> Formatted<Context>
@@ -969,8 +1014,8 @@ impl Printed {
         }
     }
 
-    /// Range of the input source file covered by this formatted code,
-    /// or None if the entire file is covered in this instance
+    /// [TextRange] of the input source file covered by this formatted code,
+    /// or [None] if the entire file is covered in this instance
     pub fn range(&self) -> Option<TextRange> {
         self.range
     }
@@ -1416,17 +1461,21 @@ pub trait FormatLanguage {
         self,
         root: &SyntaxNode<Self::SyntaxLanguage>,
         source_map: Option<TransformSourceMap>,
+        delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context;
 }
 
 /// Formats a syntax node file based on its features.
 ///
 /// It returns a [Formatted] result, which the user can use to override a file.
+///
+/// When `skip_embedded_nodes` is `true`, the content of `<script>` and `<style` is formatted
+/// verbatim.
 pub fn format_node<L: FormatLanguage>(
     root: &SyntaxNode<L::SyntaxLanguage>,
     language: L,
+    delegate_fmt_embedded_nodes: bool,
 ) -> FormatResult<Formatted<L::Context>> {
-    let _ = tracing::trace_span!("format_node").entered();
     let (root, source_map) = match language.transform(&root.clone()) {
         Some((transformed, source_map)) => {
             // we don't need to insert the node back if it has the same offset
@@ -1471,7 +1520,82 @@ pub fn format_node<L: FormatLanguage>(
         None => (root.clone(), None),
     };
 
-    let context = language.create_context(&root, source_map);
+    let context = language.create_context(&root, source_map, delegate_fmt_embedded_nodes);
+    let format_node = FormatRefWithRule::new(&root, L::FormatRule::default());
+
+    let mut state = FormatState::new(context);
+    let mut buffer = VecBuffer::new(&mut state);
+
+    write!(buffer, [format_node])?;
+
+    let mut document = Document::from(buffer.into_vec());
+    document.propagate_expand();
+
+    state.assert_formatted_all_tokens(&root);
+
+    let context = state.into_context();
+    let comments = context.comments();
+
+    comments.assert_checked_all_suppressions(&root);
+    comments.assert_formatted_all_comments();
+
+    Ok(Formatted::new(document, context))
+}
+
+/// Formats a syntax node file based on its features.
+///
+/// It returns a [Formatted] result, which the user can use to override a file.
+pub fn format_node_with_offset<L: FormatLanguage>(
+    root: &SyntaxNodeWithOffset<L::SyntaxLanguage>,
+    language: L,
+    delegate_fmt_embedded_nodes: bool,
+) -> FormatResult<Formatted<L::Context>> {
+    let (root, source_map) = match language.transform(&root.node.clone()) {
+        Some((transformed, source_map)) => {
+            // we don't need to insert the node back if it has the same offset
+            if transformed == root.node {
+                (transformed, Some(source_map))
+            } else {
+                match root
+                    .node
+                    .ancestors()
+                    // ancestors() always returns self as the first element of the iterator.
+                    .skip(1)
+                    .last()
+                {
+                    // current root node is the topmost node we don't need to insert the transformed node back
+                    None => (transformed, Some(source_map)),
+                    Some(top_root) => {
+                        // we have to return transformed node back into subtree
+                        let transformed_range = transformed.text_range_with_trivia();
+                        let root_range = root.text_range_with_trivia();
+
+                        let transformed_root = top_root
+                            .replace_child(root.node.clone().into(), transformed.into())
+                            // SAFETY: Calling `unwrap` is safe because we know that `root` is part of the `top_root` subtree.
+                            .unwrap();
+                        let transformed = transformed_root.covering_element(TextRange::new(
+                            root_range.start(),
+                            root_range.start() + transformed_range.len(),
+                        ));
+
+                        let node = match transformed {
+                            NodeOrToken::Node(node) => node,
+                            NodeOrToken::Token(token) => {
+                                // if we get a token we need to get the parent node
+                                token.parent().unwrap_or(transformed_root)
+                            }
+                        };
+
+                        (node, Some(source_map))
+                    }
+                }
+            }
+        }
+        None => (root.node.clone(), None),
+    };
+
+    let context = language.create_context(&root, source_map, delegate_fmt_embedded_nodes);
     let format_node = FormatRefWithRule::new(&root, L::FormatRule::default());
 
     let mut state = FormatState::new(context);
@@ -1860,7 +1984,7 @@ pub fn format_sub_tree<L: FormatLanguage>(
         None => 0,
     };
 
-    let formatted = format_node(root, language)?;
+    let formatted = format_node(root, language, false)?;
     let mut printed = formatted.print_with_indent(initial_indent)?;
     let sourcemap = printed.take_sourcemap();
     let verbatim_ranges = printed.take_verbatim_ranges();
diff --git a/crates/biome_formatter/src/printer/mod.rs b/crates/biome_formatter/src/printer/mod.rs
index 3087609c2319..f9952d2b70ce 100644
--- a/crates/biome_formatter/src/printer/mod.rs
+++ b/crates/biome_formatter/src/printer/mod.rs
@@ -264,7 +264,7 @@ impl<'a> Printer<'a> {
                 stack.push(TagKind::Verbatim, args);
             }
 
-            FormatElement::Tag(tag @ (StartLabelled(_) | StartEntry)) => {
+            FormatElement::Tag(tag @ (StartLabelled(_) | StartEntry | StartEmbedded(_))) => {
                 stack.push(tag.kind(), args);
             }
             FormatElement::Tag(
@@ -273,7 +273,8 @@ impl<'a> Printer<'a> {
                 | EndGroup
                 | EndConditionalContent
                 | EndVerbatim
-                | EndFill),
+                | EndFill
+                | EndEmbedded),
             ) => {
                 stack.pop(tag.kind())?;
             }
@@ -1228,7 +1229,8 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
             }
 
             FormatElement::Tag(
-                tag @ (StartFill | StartVerbatim(_) | StartLabelled(_) | StartEntry),
+                tag @ (StartFill | StartVerbatim(_) | StartLabelled(_) | StartEntry
+                | StartEmbedded(_)),
             ) => {
                 self.stack.push(tag.kind(), args);
             }
@@ -1238,7 +1240,8 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
                 | EndGroup
                 | EndConditionalContent
                 | EndVerbatim
-                | EndFill),
+                | EndFill
+                | EndEmbedded),
             ) => {
                 self.stack.pop(tag.kind())?;
             }
@@ -1735,7 +1738,7 @@ two lines`,
                         text("The referenced group breaks."),
                         hard_line_break()
                     ])
-                    .with_group_id(Some(group_id)),
+                        .with_group_id(Some(group_id)),
                     group(&format_args![
                         text("This group breaks because:"),
                         soft_line_break_or_space(),
diff --git a/crates/biome_formatter_test/src/lib.rs b/crates/biome_formatter_test/src/lib.rs
index 2e66ab018977..a8269e605fa8 100644
--- a/crates/biome_formatter_test/src/lib.rs
+++ b/crates/biome_formatter_test/src/lib.rs
@@ -29,7 +29,7 @@ pub trait TestFormatLanguage {
         language: Self::FormatLanguage,
         node: &SyntaxNode<Self::ServiceLanguage>,
     ) -> FormatResult<Formatted<Self::Context>> {
-        biome_formatter::format_node(node, language)
+        biome_formatter::format_node(node, language, false)
     }
 
     fn format_range(
diff --git a/crates/biome_graphql_formatter/src/lib.rs b/crates/biome_graphql_formatter/src/lib.rs
index 2c5cddf99571..449680a9ed64 100644
--- a/crates/biome_graphql_formatter/src/lib.rs
+++ b/crates/biome_graphql_formatter/src/lib.rs
@@ -315,6 +315,7 @@ impl FormatLanguage for GraphqlFormatLanguage {
         self,
         root: &GraphqlSyntaxNode,
         source_map: Option<TransformSourceMap>,
+        _delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments = Comments::from_node(root, &GraphqlCommentStyle, source_map.as_ref());
         GraphqlFormatContext::new(self.options, comments).with_source_map(source_map)
@@ -347,7 +348,7 @@ pub fn format_node(
     options: GraphqlFormatOptions,
     root: &GraphqlSyntaxNode,
 ) -> FormatResult<Formatted<GraphqlFormatContext>> {
-    biome_formatter::format_node(root, GraphqlFormatLanguage::new(options))
+    biome_formatter::format_node(root, GraphqlFormatLanguage::new(options), false)
 }
 
 /// Formats a single node within a file, supported by Biome.
diff --git a/crates/biome_grit_formatter/src/lib.rs b/crates/biome_grit_formatter/src/lib.rs
index 19769799c81e..b88281ed72c7 100644
--- a/crates/biome_grit_formatter/src/lib.rs
+++ b/crates/biome_grit_formatter/src/lib.rs
@@ -37,7 +37,7 @@ pub fn format_node(
     options: GritFormatOptions,
     root: &GritSyntaxNode,
 ) -> FormatResult<Formatted<GritFormatContext>> {
-    biome_formatter::format_node(root, GritFormatLanguage::new(options))
+    biome_formatter::format_node(root, GritFormatLanguage::new(options), false)
 }
 
 /// Formats a range within a file, supported by Biome
@@ -169,6 +169,7 @@ impl FormatLanguage for GritFormatLanguage {
         self,
         root: &biome_rowan::SyntaxNode<Self::SyntaxLanguage>,
         source_map: Option<biome_formatter::TransformSourceMap>,
+        _delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments: Comments<GritLanguage> =
             Comments::from_node(root, &GritCommentStyle, source_map.as_ref());
diff --git a/crates/biome_html_factory/src/generated/node_factory.rs b/crates/biome_html_factory/src/generated/node_factory.rs
index 7c63856f3806..baf4a7c3012a 100644
--- a/crates/biome_html_factory/src/generated/node_factory.rs
+++ b/crates/biome_html_factory/src/generated/node_factory.rs
@@ -207,6 +207,12 @@ pub fn html_element(
         ],
     ))
 }
+pub fn html_embedded_content(value_token: SyntaxToken) -> HtmlEmbeddedContent {
+    HtmlEmbeddedContent::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_EMBEDDED_CONTENT,
+        [Some(SyntaxElement::Token(value_token))],
+    ))
+}
 pub fn html_opening_element(
     l_angle_token: SyntaxToken,
     name: HtmlTagName,
diff --git a/crates/biome_html_factory/src/generated/syntax_factory.rs b/crates/biome_html_factory/src/generated/syntax_factory.rs
index d9bbe344dba9..ff6a33d039c8 100644
--- a/crates/biome_html_factory/src/generated/syntax_factory.rs
+++ b/crates/biome_html_factory/src/generated/syntax_factory.rs
@@ -351,6 +351,25 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(HTML_ELEMENT, children)
             }
+            HTML_EMBEDDED_CONTENT => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == HTML_LITERAL
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        HTML_EMBEDDED_CONTENT.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(HTML_EMBEDDED_CONTENT, children)
+            }
             HTML_OPENING_ELEMENT => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
diff --git a/crates/biome_html_formatter/benches/html_formatter.rs b/crates/biome_html_formatter/benches/html_formatter.rs
index c700a112ecb3..123d573346d5 100644
--- a/crates/biome_html_formatter/benches/html_formatter.rs
+++ b/crates/biome_html_formatter/benches/html_formatter.rs
@@ -45,7 +45,8 @@ fn bench_formatter(criterion: &mut Criterion) {
                     |b, _| {
                         fn format(root: HtmlRoot) -> Printed {
                             let formatted =
-                                format_node(HtmlFormatOptions::default(), root.syntax()).unwrap();
+                                format_node(HtmlFormatOptions::default(), root.syntax(), false)
+                                    .unwrap();
                             let printed = formatted.print();
                             drop(formatted);
                             printed.expect("Document to be valid")
diff --git a/crates/biome_html_formatter/src/context.rs b/crates/biome_html_formatter/src/context.rs
index 5cf6e2ed9fd7..e1dbd0780e20 100644
--- a/crates/biome_html_formatter/src/context.rs
+++ b/crates/biome_html_formatter/src/context.rs
@@ -371,6 +371,8 @@ pub struct HtmlFormatContext {
     comments: Rc<HtmlComments>,
 
     source_map: Option<TransformSourceMap>,
+
+    should_delegate_fmt_embedded_nodes: bool,
 }
 
 impl HtmlFormatContext {
@@ -379,6 +381,7 @@ impl HtmlFormatContext {
             options,
             comments: Rc::new(comments),
             source_map: None,
+            should_delegate_fmt_embedded_nodes: false,
         }
     }
 
@@ -386,6 +389,15 @@ impl HtmlFormatContext {
         self.source_map = source_map;
         self
     }
+
+    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 {
+        self.should_delegate_fmt_embedded_nodes
+    }
 }
 
 impl FormatContext for HtmlFormatContext {
diff --git a/crates/biome_html_formatter/src/generated.rs b/crates/biome_html_formatter/src/generated.rs
index 0c3c357a8a06..d157094a372e 100644
--- a/crates/biome_html_formatter/src/generated.rs
+++ b/crates/biome_html_formatter/src/generated.rs
@@ -382,6 +382,44 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlElement {
         )
     }
 }
+impl FormatRule<biome_html_syntax::HtmlEmbeddedContent>
+    for crate::html::auxiliary::embedded_content::FormatHtmlEmbeddedContent
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::HtmlEmbeddedContent,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::HtmlEmbeddedContent>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlEmbeddedContent {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::HtmlEmbeddedContent,
+        crate::html::auxiliary::embedded_content::FormatHtmlEmbeddedContent,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::html::auxiliary::embedded_content::FormatHtmlEmbeddedContent::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlEmbeddedContent {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::HtmlEmbeddedContent,
+        crate::html::auxiliary::embedded_content::FormatHtmlEmbeddedContent,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::auxiliary::embedded_content::FormatHtmlEmbeddedContent::default(),
+        )
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlOpeningElement>
     for crate::html::auxiliary::opening_element::FormatHtmlOpeningElement
 {
diff --git a/crates/biome_html_formatter/src/html/any/content.rs b/crates/biome_html_formatter/src/html/any/content.rs
index b264c0c08aca..677a094d1981 100644
--- a/crates/biome_html_formatter/src/html/any/content.rs
+++ b/crates/biome_html_formatter/src/html/any/content.rs
@@ -10,6 +10,7 @@ impl FormatRule<AnyHtmlContent> for FormatAnyHtmlContent {
         match node {
             AnyHtmlContent::AnyHtmlTextExpression(node) => node.format().fmt(f),
             AnyHtmlContent::HtmlContent(node) => node.format().fmt(f),
+            AnyHtmlContent::HtmlEmbeddedContent(node) => node.format().fmt(f),
         }
     }
 }
diff --git a/crates/biome_html_formatter/src/html/auxiliary/element.rs b/crates/biome_html_formatter/src/html/auxiliary/element.rs
index a1d27398be64..223561ce5984 100644
--- a/crates/biome_html_formatter/src/html/auxiliary/element.rs
+++ b/crates/biome_html_formatter/src/html/auxiliary/element.rs
@@ -16,6 +16,7 @@ use super::{
 
 /// `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.
+///
 const HTML_VERBATIM_TAGS: &[&str] = &["script", "style", "pre"];
 
 #[derive(Debug, Clone, Default)]
@@ -44,6 +45,13 @@ impl FormatNodeRule<HtmlElement> for FormatHtmlElement {
                 .is_some_and(|tag_name| tag_name.text().eq_ignore_ascii_case(tag))
         });
 
+        let should_format_embedded_nodes = if f.context().should_delegate_fmt_embedded_nodes() {
+            // Only delegate for JS <script> or <style> content
+            node.is_javascript_tag()? || node.is_style_tag()?
+        } else {
+            false
+        };
+
         let content_has_leading_whitespace = children
             .syntax()
             .first_token()
@@ -85,11 +93,13 @@ impl FormatNodeRule<HtmlElement> for FormatHtmlElement {
         let should_borrow_opening_r_angle = is_whitespace_sensitive
             && !children.is_empty()
             && !content_has_leading_whitespace
-            && !should_be_verbatim;
+            && !should_be_verbatim
+            && !should_format_embedded_nodes;
         let should_borrow_closing_tag = is_whitespace_sensitive
             && !children.is_empty()
             && !content_has_trailing_whitespace
-            && !should_be_verbatim;
+            && !should_be_verbatim
+            && !should_format_embedded_nodes;
 
         let borrowed_r_angle = if should_borrow_opening_r_angle {
             opening_element.r_angle_token().ok()
@@ -111,8 +121,12 @@ impl FormatNodeRule<HtmlElement> for FormatHtmlElement {
             &opening_element,
             f,
         )?;
-        if should_be_verbatim {
-            write!(f, [&format_verbatim_skipped(children.syntax())])?;
+        // The order here is important. First, we must check if we can delegate the formatting
+        // of embedded nodes, then we check if we should format them verbatim.
+        if should_format_embedded_nodes {
+            write!(f, [children.format()])?;
+        } else if should_be_verbatim {
+            write!(f, [&format_html_verbatim_node(children.syntax())])?;
         } else {
             let format_children = FormatHtmlElementList::default()
                 .with_options(FormatHtmlElementListOptions {
diff --git a/crates/biome_html_formatter/src/html/auxiliary/embedded_content.rs b/crates/biome_html_formatter/src/html/auxiliary/embedded_content.rs
new file mode 100644
index 000000000000..70b6731781eb
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/auxiliary/embedded_content.rs
@@ -0,0 +1,32 @@
+use crate::prelude::*;
+use biome_html_syntax::{HtmlElement, HtmlEmbeddedContent};
+use biome_rowan::{AstNode, TextRange};
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlEmbeddedContent;
+impl FormatNodeRule<HtmlEmbeddedContent> for FormatHtmlEmbeddedContent {
+    fn fmt_fields(&self, node: &HtmlEmbeddedContent, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_verbatim_skipped(node.syntax()).fmt(f)
+    }
+
+    fn embedded_node_range(
+        &self,
+        node: &HtmlEmbeddedContent,
+        f: &mut HtmlFormatter,
+    ) -> Option<TextRange> {
+        if !f.context().should_delegate_fmt_embedded_nodes() {
+            return None;
+        }
+        let element = node
+            .syntax()
+            .ancestors()
+            .skip(1)
+            .find_map(HtmlElement::cast)?;
+        if element.is_javascript_tag().unwrap_or_default()
+            || element.is_style_tag().unwrap_or_default()
+        {
+            Some(node.range())
+        } else {
+            None
+        }
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/auxiliary/mod.rs b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
index 4a97911822b0..260ed313e467 100644
--- a/crates/biome_html_formatter/src/html/auxiliary/mod.rs
+++ b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
@@ -9,6 +9,7 @@ pub(crate) mod content;
 pub(crate) mod directive;
 pub(crate) mod double_text_expression;
 pub(crate) mod element;
+pub(crate) mod embedded_content;
 pub(crate) mod opening_element;
 pub(crate) mod root;
 pub(crate) mod self_closing_element;
diff --git a/crates/biome_html_formatter/src/html/lists/element_list.rs b/crates/biome_html_formatter/src/html/lists/element_list.rs
index bc256f86fd52..de96d885a41d 100644
--- a/crates/biome_html_formatter/src/html/lists/element_list.rs
+++ b/crates/biome_html_formatter/src/html/lists/element_list.rs
@@ -59,6 +59,20 @@ impl FormatRule<HtmlElementList> for FormatHtmlElementList {
         if node.is_empty() {
             return Ok(());
         }
+
+        let should_delegate_fmt_embedded_nodes = f.context().should_delegate_fmt_embedded_nodes();
+        // early exit - If it's just a single HtmlEmbeddedContent node as the only child,
+        // we know the parser will only emit one of these. We can simply call its formatter and be done.
+        // This is also necessary for how we implement embedded language formatting.
+        if node.len() == 1
+            && should_delegate_fmt_embedded_nodes
+            && let Some(AnyHtmlElement::AnyHtmlContent(AnyHtmlContent::HtmlEmbeddedContent(
+                embedded_content,
+            ))) = node.first()
+        {
+            return embedded_content.format().fmt(f);
+        }
+
         let result = self.fmt_children(node, f)?;
         match result {
             FormatChildrenResult::ForceMultiline(format_multiline) => {
@@ -510,6 +524,12 @@ impl FormatHtmlElementList {
                             .value_token()
                             .is_ok_and(|token| is_meaningful_html_text(token.text()));
                 }
+                AnyHtmlElement::AnyHtmlContent(AnyHtmlContent::HtmlEmbeddedContent(text)) => {
+                    meta.meaningful_text = meta.meaningful_text
+                        || text
+                            .value_token()
+                            .is_ok_and(|token| is_meaningful_html_text(token.text()));
+                }
                 _ => {}
             }
         }
diff --git a/crates/biome_html_formatter/src/lib.rs b/crates/biome_html_formatter/src/lib.rs
index d57886d51998..a44de1b408d7 100644
--- a/crates/biome_html_formatter/src/lib.rs
+++ b/crates/biome_html_formatter/src/lib.rs
@@ -2,11 +2,12 @@
 
 use crate::prelude::*;
 use biome_formatter::comments::Comments;
+use biome_formatter::prelude::Tag::{EndEmbedded, StartEmbedded};
 use biome_formatter::trivia::{FormatToken, format_skipped_token_trivia};
 use biome_formatter::{CstFormatContext, FormatOwnedWithRule, FormatRefWithRule, prelude::*};
 use biome_formatter::{FormatLanguage, FormatResult, Formatted, write};
 use biome_html_syntax::{HtmlLanguage, HtmlSyntaxNode, HtmlSyntaxToken};
-use biome_rowan::{AstNode, SyntaxToken};
+use biome_rowan::{AstNode, SyntaxToken, TextRange};
 use comments::HtmlCommentStyle;
 use context::HtmlFormatContext;
 pub use context::HtmlFormatOptions;
@@ -29,8 +30,13 @@ mod verbatim;
 pub fn format_node(
     options: HtmlFormatOptions,
     root: &HtmlSyntaxNode,
+    delegate_fmt_embedded_nodes: bool,
 ) -> FormatResult<Formatted<HtmlFormatContext>> {
-    biome_formatter::format_node(root, HtmlFormatLanguage::new(options))
+    biome_formatter::format_node(
+        root,
+        HtmlFormatLanguage::new(options),
+        delegate_fmt_embedded_nodes,
+    )
 }
 
 /// Used to get an object that knows how to format this object.
@@ -153,9 +159,15 @@ impl FormatLanguage for HtmlFormatLanguage {
         self,
         root: &biome_rowan::SyntaxNode<Self::SyntaxLanguage>,
         source_map: Option<biome_formatter::TransformSourceMap>,
+        delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments = Comments::from_node(root, &HtmlCommentStyle, source_map.as_ref());
-        HtmlFormatContext::new(self.options, comments).with_source_map(source_map)
+        let context = HtmlFormatContext::new(self.options, comments).with_source_map(source_map);
+        if delegate_fmt_embedded_nodes {
+            context.with_fmt_embedded_nodes()
+        } else {
+            context
+        }
     }
 }
 
@@ -205,10 +217,30 @@ where
 
     /// Formats the node without comments. Ignores any suppression comments.
     fn fmt_node(&self, node: &N, f: &mut HtmlFormatter) -> FormatResult<()> {
-        self.fmt_fields(node, f)?;
+        if let Some(range) = self.embedded_node_range(node, f) {
+            // Tokens that belong to embedded nodes are formatted later on,
+            // so we track them, even though they aren't formatted now during this pass.
+            let state = f.state_mut();
+            for token in node.syntax().tokens() {
+                state.track_token(&token);
+            }
+
+            f.write_elements(vec![
+                FormatElement::Tag(StartEmbedded(range)),
+                FormatElement::Tag(EndEmbedded),
+            ])?;
+        } else {
+            self.fmt_fields(node, f)?;
+        }
         Ok(())
     }
 
+    /// Whether this node contains content that needs to be formatted by an external formatter.
+    /// If so, the function must return the range of the nodes that will be formatted in the second phase.
+    fn embedded_node_range(&self, _node: &N, _f: &mut HtmlFormatter) -> Option<TextRange> {
+        None
+    }
+
     /// Formats the node's fields.
     fn fmt_fields(&self, item: &N, f: &mut HtmlFormatter) -> FormatResult<()>;
 
diff --git a/crates/biome_html_formatter/src/utils/children.rs b/crates/biome_html_formatter/src/utils/children.rs
index 75b2176ede06..e9d8fbfec59d 100644
--- a/crates/biome_html_formatter/src/utils/children.rs
+++ b/crates/biome_html_formatter/src/utils/children.rs
@@ -183,102 +183,127 @@ where
 
     let mut prev_child_was_content = false;
     for child in children {
-        match child {
-            AnyHtmlElement::AnyHtmlContent(AnyHtmlContent::HtmlContent(text)) => {
-                // Split the text into words
-                // Keep track if there's any leading/trailing empty line, new line or whitespace
-
-                let value_token = text.value_token()?;
-                let is_suppressed = f.comments().is_suppressed(text.syntax());
-                if is_suppressed {
-                    builder.entry(HtmlChild::Verbatim(AnyHtmlElement::AnyHtmlContent(
-                        text.into(),
-                    )));
-                    continue;
+        let element_has_content = matches!(
+            &child,
+            AnyHtmlElement::AnyHtmlContent(
+                AnyHtmlContent::HtmlContent(_) | AnyHtmlContent::HtmlEmbeddedContent(_)
+            )
+        );
+
+        if element_has_content {
+            let (text_syntax, value_token) = match &child {
+                AnyHtmlElement::AnyHtmlContent(AnyHtmlContent::HtmlContent(text)) => {
+                    (text.syntax(), text.value_token()?)
                 }
-                f.state_mut().track_token(&value_token);
-                // Manually mark these comments as formatted because they are. Because we override the formatting of text content in here, the formatter does not seem to recognize them as formatted.
-                // We do have to manually check to make sure the comment's text range is actually inside this node's text range. Some comments may be included in this call to `leading_trailing_comments` that are not actually part of this node.
-
-                let mut trailing_comments_to_format = vec![];
-                for comment in f
-                    .comments()
-                    .leading_dangling_trailing_comments(text.syntax())
+                AnyHtmlElement::AnyHtmlContent(AnyHtmlContent::HtmlEmbeddedContent(text)) => {
+                    (text.syntax(), text.value_token()?)
+                }
+                _ => unreachable!(
+                    "You should update the condition of `element_has_content` to handle this case."
+                ),
+            };
+            // Split the text into words
+            // Keep track if there's any leading/trailing empty line, new line or whitespace
+
+            let is_suppressed = f.comments().is_suppressed(text_syntax);
+            if is_suppressed {
+                builder.entry(HtmlChild::Verbatim(child));
+                continue;
+            }
+            f.state_mut().track_token(&value_token);
+            // Manually mark these comments as formatted because they are. Because we override the formatting of text content in here, the formatter does not seem to recognize them as formatted.
+            // We do have to manually check to make sure the comment's text range is actually inside this node's text range. Some comments may be included in this call to `leading_trailing_comments` that are not actually part of this node.
+
+            let mut trailing_comments_to_format = vec![];
+            for comment in f.comments().leading_dangling_trailing_comments(text_syntax) {
+                let comment_range = comment.piece().text_range();
+                // TODO: might be able to make this a debug assertion instead
+                if comment_range.start() >= value_token.text_range().start()
+                    && comment_range.end() <= value_token.text_range().end()
                 {
-                    let comment_range = comment.piece().text_range();
-                    // TODO: might be able to make this a debug assertion instead
-                    if comment_range.start() >= value_token.text_range().start()
-                        && comment_range.end() <= value_token.text_range().end()
-                    {
-                        comment.mark_formatted();
-                    }
+                    comment.mark_formatted();
                 }
-                for comment in f.comments().trailing_comments(text.syntax()) {
-                    let comment_range = comment.piece().text_range();
-                    // TODO: might be able to make this a debug assertion instead
-                    if !(comment_range.start() >= value_token.text_range().start()
-                        && comment_range.end() <= value_token.text_range().end())
-                    {
-                        trailing_comments_to_format.push(comment);
-                    }
+            }
+            for comment in f.comments().trailing_comments(text_syntax) {
+                let comment_range = comment.piece().text_range();
+                // TODO: might be able to make this a debug assertion instead
+                if !(comment_range.start() >= value_token.text_range().start()
+                    && comment_range.end() <= value_token.text_range().end())
+                {
+                    trailing_comments_to_format.push(comment);
                 }
+            }
 
-                let mut chunks = HtmlSplitChunksIterator::new(value_token.text()).peekable();
-
-                // Text starting with a whitespace
-                if let Some((_, HtmlTextChunk::Whitespace(_whitespace))) = chunks.peek() {
-                    // SAFETY: We just checked this above.
-                    match chunks.next().unwrap() {
-                        (_, HtmlTextChunk::Whitespace(whitespace)) => {
-                            if whitespace.contains('\n') && !prev_child_was_content {
-                                if chunks.peek().is_none() {
-                                    // A text only consisting of whitespace that also contains a new line isn't considered meaningful text.
-                                    // It can be entirely removed from the content without changing the semantics.
-                                    let newlines =
-                                        whitespace.bytes().filter(|b| *b == b'\n').count();
-
-                                    // Keep up to one blank line between tags.
-                                    // ```html
-                                    // <div>
-                                    //
-                                    //   <MyElement />
-                                    // </div>
-                                    // ```
-                                    if newlines > 1 {
-                                        builder.entry(HtmlChild::EmptyLine);
-                                    }
+            let mut chunks = HtmlSplitChunksIterator::new(value_token.text()).peekable();
 
-                                    continue;
+            // Text starting with a whitespace
+            if let Some((_, HtmlTextChunk::Whitespace(_whitespace))) = chunks.peek() {
+                // SAFETY: We just checked this above.
+                match chunks.next().unwrap() {
+                    (_, HtmlTextChunk::Whitespace(whitespace)) => {
+                        if whitespace.contains('\n') && !prev_child_was_content {
+                            if chunks.peek().is_none() {
+                                // A text only consisting of whitespace that also contains a new line isn't considered meaningful text.
+                                // It can be entirely removed from the content without changing the semantics.
+                                let newlines = whitespace.bytes().filter(|b| *b == b'\n').count();
+
+                                // Keep up to one blank line between tags.
+                                // ```html
+                                // <div>
+                                //
+                                //   <MyElement />
+                                // </div>
+                                // ```
+                                if newlines > 1 {
+                                    builder.entry(HtmlChild::EmptyLine);
                                 }
 
+                                continue;
+                            }
+
+                            builder.entry(HtmlChild::Newline)
+                        } else {
+                            // if there's newlines before a comment, we need to preserve them
+                            if whitespace.contains('\n')
+                                && matches!(chunks.peek(), Some(&(_, HtmlTextChunk::Comment(_))))
+                            {
                                 builder.entry(HtmlChild::Newline)
                             } else {
-                                // if there's newlines before a comment, we need to preserve them
-                                if whitespace.contains('\n')
-                                    && matches!(
-                                        chunks.peek(),
-                                        Some(&(_, HtmlTextChunk::Comment(_)))
-                                    )
-                                {
-                                    builder.entry(HtmlChild::Newline)
-                                } else {
-                                    builder.entry(HtmlChild::Whitespace)
-                                }
+                                builder.entry(HtmlChild::Whitespace)
                             }
                         }
-                        _ => unreachable!(),
                     }
+                    _ => unreachable!(),
                 }
+            }
 
-                let mut prev_chunk_was_comment = false;
-                while let Some(chunk) = chunks.next() {
-                    match chunk {
-                        (_, HtmlTextChunk::Whitespace(whitespace)) => {
-                            // Only handle trailing whitespace. Words must always be joined by new lines
-                            let newlines = whitespace.chars().filter(|b| *b == '\n').count();
-                            match chunks.peek() {
-                                Some(&(_, HtmlTextChunk::Comment(_))) => {
-                                    // if the next chunk is a comment, preserve the whitespace
+            let mut prev_chunk_was_comment = false;
+            while let Some(chunk) = chunks.next() {
+                match chunk {
+                    (_, HtmlTextChunk::Whitespace(whitespace)) => {
+                        // Only handle trailing whitespace. Words must always be joined by new lines
+                        let newlines = whitespace.chars().filter(|b| *b == '\n').count();
+                        match chunks.peek() {
+                            Some(&(_, HtmlTextChunk::Comment(_))) => {
+                                // if the next chunk is a comment, preserve the whitespace
+                                if newlines >= 2 {
+                                    builder.entry(HtmlChild::EmptyLine)
+                                } else if newlines == 1 {
+                                    builder.entry(HtmlChild::Newline)
+                                } else {
+                                    builder.entry(HtmlChild::Whitespace)
+                                }
+                            }
+                            None => {
+                                if newlines >= 1 {
+                                    builder.entry(HtmlChild::Newline)
+                                } else {
+                                    builder.entry(HtmlChild::Whitespace)
+                                }
+                            }
+                            _ => {
+                                // if the previous chunk was a comment, we need to preserve the whitespace before the next chunk.
+                                if prev_chunk_was_comment {
                                     if newlines >= 2 {
                                         builder.entry(HtmlChild::EmptyLine)
                                     } else if newlines == 1 {
@@ -287,111 +312,91 @@ where
                                         builder.entry(HtmlChild::Whitespace)
                                     }
                                 }
-                                None => {
-                                    if newlines >= 1 {
-                                        builder.entry(HtmlChild::Newline)
-                                    } else {
-                                        builder.entry(HtmlChild::Whitespace)
-                                    }
-                                }
-                                _ => {
-                                    // if the previous chunk was a comment, we need to preserve the whitespace before the next chunk.
-                                    if prev_chunk_was_comment {
-                                        if newlines >= 2 {
-                                            builder.entry(HtmlChild::EmptyLine)
-                                        } else if newlines == 1 {
-                                            builder.entry(HtmlChild::Newline)
-                                        } else {
-                                            builder.entry(HtmlChild::Whitespace)
-                                        }
-                                    }
-                                }
                             }
                         }
+                    }
 
-                        (relative_start, HtmlTextChunk::Word(word)) => {
-                            let text = value_token
-                                .token_text()
-                                .slice(TextRange::at(relative_start, word.text_len()));
-                            let source_position = value_token.text_range().start() + relative_start;
-
-                            builder.entry(HtmlChild::Word(HtmlWord::new(text, source_position)));
-                        }
-                        (relative_start, HtmlTextChunk::Comment(word)) => {
-                            let text = value_token
-                                .token_text()
-                                .slice(TextRange::at(relative_start, word.text_len()));
-                            let source_position = value_token.text_range().start() + relative_start;
+                    (relative_start, HtmlTextChunk::Word(word)) => {
+                        let text = value_token
+                            .token_text()
+                            .slice(TextRange::at(relative_start, word.text_len()));
+                        let source_position = value_token.text_range().start() + relative_start;
 
-                            builder.entry(HtmlChild::Comment(HtmlWord::new(text, source_position)));
-                        }
+                        builder.entry(HtmlChild::Word(HtmlWord::new(text, source_position)));
                     }
-                    prev_chunk_was_comment = matches!(chunk, (_, HtmlTextChunk::Comment(_)));
-                }
+                    (relative_start, HtmlTextChunk::Comment(word)) => {
+                        let text = value_token
+                            .token_text()
+                            .slice(TextRange::at(relative_start, word.text_len()));
+                        let source_position = value_token.text_range().start() + relative_start;
 
-                // There may be trailing comments that we attached to the content if this is the last child of an Element. They won't show up in the `value_token.text()` because they are actually attached to the leading token of the closing tag. This means we have to format them manually.
-                for comment in trailing_comments_to_format {
-                    // This might not actually be the best way to handle the whitespace before the comment. If there are bugs here involving whitespace preceding the comment, try this:
-                    // Instead of the below match on `comment.lines_before()`, try to include the whitespace in the sliced range from the token text. Right now, that preceding whitespace is excluded, and we add it back in via the `lines_before` match below.
-                    match comment.lines_before() {
-                        0 => {}
-                        1 => builder.entry(HtmlChild::Newline),
-                        _ => builder.entry(HtmlChild::EmptyLine),
+                        builder.entry(HtmlChild::Comment(HtmlWord::new(text, source_position)));
                     }
-                    let token = comment.piece().as_piece().token();
-                    let text = token.token_text();
-
-                    builder.entry(HtmlChild::Comment(HtmlWord::new(
-                        text.slice(comment.piece().text_range() - token.text_range().start()),
-                        comment.piece().text_range().start(),
-                    )));
-                    comment.mark_formatted();
                 }
+                prev_chunk_was_comment = matches!(chunk, (_, HtmlTextChunk::Comment(_)));
+            }
 
-                prev_child_was_content = true;
+            // There may be trailing comments that we attached to the content if this is the last child of an Element. They won't show up in the `value_token.text()` because they are actually attached to the leading token of the closing tag. This means we have to format them manually.
+            for comment in trailing_comments_to_format {
+                // This might not actually be the best way to handle the whitespace before the comment. If there are bugs here involving whitespace preceding the comment, try this:
+                // Instead of the below match on `comment.lines_before()`, try to include the whitespace in the sliced range from the token text. Right now, that preceding whitespace is excluded, and we add it back in via the `lines_before` match below.
+                match comment.lines_before() {
+                    0 => {}
+                    1 => builder.entry(HtmlChild::Newline),
+                    _ => builder.entry(HtmlChild::EmptyLine),
+                }
+                let token = comment.piece().as_piece().token();
+                let text = token.token_text();
+
+                builder.entry(HtmlChild::Comment(HtmlWord::new(
+                    text.slice(comment.piece().text_range() - token.text_range().start()),
+                    comment.piece().text_range().start(),
+                )));
+                comment.mark_formatted();
             }
-            child => {
-                let text = child.to_string();
-                let mut chunks = HtmlSplitChunksIterator::new(&text).peekable();
-
-                // Text starting with a whitespace
-                if let Some((_, HtmlTextChunk::Whitespace(_whitespace))) = chunks.peek() {
-                    // SAFETY: We just checked this above.
-                    match chunks.next().unwrap() {
-                        (_, HtmlTextChunk::Whitespace(whitespace)) => {
-                            if whitespace.contains('\n') {
-                                // A text only consisting of whitespace that also contains a new line isn't considered meaningful text.
-                                // It can be entirely removed from the content without changing the semantics.
-                                let newlines = whitespace.chars().filter(|c| *c == '\n').count();
 
-                                // Keep up to one blank line between tags.
-                                // ```html
-                                // <div>
-                                //
-                                //   <MyElement />
-                                // </div>
-                                // ```
-                                if newlines > 1 {
-                                    builder.entry(HtmlChild::EmptyLine);
-                                } else {
-                                    builder.entry(HtmlChild::Newline);
-                                }
+            prev_child_was_content = true;
+        } else {
+            let text = child.to_string();
+            let mut chunks = HtmlSplitChunksIterator::new(&text).peekable();
+
+            // Text starting with a whitespace
+            if let Some((_, HtmlTextChunk::Whitespace(_whitespace))) = chunks.peek() {
+                // SAFETY: We just checked this above.
+                match chunks.next().unwrap() {
+                    (_, HtmlTextChunk::Whitespace(whitespace)) => {
+                        if whitespace.contains('\n') {
+                            // A text only consisting of whitespace that also contains a new line isn't considered meaningful text.
+                            // It can be entirely removed from the content without changing the semantics.
+                            let newlines = whitespace.chars().filter(|c| *c == '\n').count();
+
+                            // Keep up to one blank line between tags.
+                            // ```html
+                            // <div>
+                            //
+                            //   <MyElement />
+                            // </div>
+                            // ```
+                            if newlines > 1 {
+                                builder.entry(HtmlChild::EmptyLine);
                             } else {
-                                builder.entry(HtmlChild::Whitespace)
+                                builder.entry(HtmlChild::Newline);
                             }
+                        } else {
+                            builder.entry(HtmlChild::Whitespace)
                         }
-                        _ => unreachable!(),
                     }
+                    _ => unreachable!(),
                 }
+            }
 
-                let is_suppressed = f.comments().is_suppressed(child.syntax());
-                if is_suppressed {
-                    builder.entry(HtmlChild::Verbatim(child));
-                } else {
-                    builder.entry(HtmlChild::NonText(child));
-                }
-                prev_child_was_content = false;
+            let is_suppressed = f.comments().is_suppressed(child.syntax());
+            if is_suppressed {
+                builder.entry(HtmlChild::Verbatim(child.clone()));
+            } else {
+                builder.entry(HtmlChild::NonText(child.clone()));
             }
+            prev_child_was_content = false;
         }
     }
 
diff --git a/crates/biome_html_formatter/tests/quick_test.rs b/crates/biome_html_formatter/tests/quick_test.rs
index fae0e5bd1a7e..c173bcc2f355 100644
--- a/crates/biome_html_formatter/tests/quick_test.rs
+++ b/crates/biome_html_formatter/tests/quick_test.rs
@@ -31,7 +31,7 @@ quick brown fox
         .with_line_width(LineWidth::try_from(80).unwrap())
         .with_attribute_position(AttributePosition::Auto);
 
-    let doc = format_node(options.clone(), &tree.syntax()).unwrap();
+    let doc = format_node(options.clone(), &tree.syntax(), false).unwrap();
     let result = doc.print().unwrap();
 
     println!("{}", doc.into_document());
diff --git a/crates/biome_html_formatter/tests/specs/html/elements/pre-with-brackets.html.snap b/crates/biome_html_formatter/tests/specs/html/elements/pre-with-brackets.html.snap
index 7c14598a607f..2bc59f46d3be 100644
--- a/crates/biome_html_formatter/tests/specs/html/elements/pre-with-brackets.html.snap
+++ b/crates/biome_html_formatter/tests/specs/html/elements/pre-with-brackets.html.snap
@@ -1,7 +1,6 @@
 ---
 source: crates/biome_formatter_test/src/snapshot_builder.rs
 info: elements/pre-with-brackets.html
-snapshot_kind: text
 ---
 # Input
 
@@ -50,3 +49,9 @@ Self close void elements: never
                 ||     ||
 </pre>
 ```
+
+
+
+## Unimplemented nodes/tokens
+
+"\n _______\n< Biome >\n -------\n        \\   ^__^\n         \\  (oo)\\_______\n            (__)\\       )\\/\\\n                ||----w |\n                ||     ||\n" => 5..157
diff --git a/crates/biome_html_formatter/tests/specs/html/elements/pre-with-braille.html.snap b/crates/biome_html_formatter/tests/specs/html/elements/pre-with-braille.html.snap
index 53053ee367bb..e32b6fb697af 100644
--- a/crates/biome_html_formatter/tests/specs/html/elements/pre-with-braille.html.snap
+++ b/crates/biome_html_formatter/tests/specs/html/elements/pre-with-braille.html.snap
@@ -1,7 +1,6 @@
 ---
 source: crates/biome_formatter_test/src/snapshot_builder.rs
 info: elements/pre-with-braille.html
-snapshot_kind: text
 ---
 # Input
 
@@ -95,6 +94,11 @@ Self close void elements: never
 </pre>
 ```
 
+
+
+## Unimplemented nodes/tokens
+
+"\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠴⠤⠤⠴⠄⡄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀               BBBB\n⠀⠀⠀⠀⠀⠀⠀⣠⠄⠒⠉⠀⠀⠀⠀⠀⠀⠀⠀⠁⠃⠆⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀             BB  BB\n⠀⠀⠀⠀⠀⢀⡜⠁⠀⠀⠀⢠⡄⠀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠑⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀            BB    BB\n⠀⠀⠀⠀⠀⢈⠁⠀⠀⠠⣿⠿⡟⣀⡹⠆⡿⣃⣰⣆⣤⣀⠀⠀⠹⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀           BB      BB\n⠀⠀⠀⠀⠀⣼⠀⠀⢀⣀⣀⣀⣀⡈⠁⠙⠁⠘⠃⠡⠽⡵⢚⠱⠂⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀           BB        BB\n⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀          BB          BB\n⠀⠀⠀⠀⠀⡆⠀⠀⠀⠀⢐⣢⣤⣵⡄⢀⠀⢀⢈⣉⠉⠉⠒⠤⠀⠿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀            BBBBBBBB   BB\n⠀⠀⠀⠀⠘⡇⠀⠀⠀⠀⠀⠉⠉⠁⠁⠈⠀⠸⢖⣿⣿⣷⠀⠀⢰⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀                        BB\n⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⢀⠃⠀⡄⠀⠈⠉⠀⠀⠀⢴⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀       BBBBBBBBB   B    BB\n⠀⠀⠀⠀⢈⣇⠀⠀⠀⠀⠀⠀⠀⢰⠉⠀⠀⠱⠀⠀⠀⠀⠀⢠⡄⠀⠀⠀⠀⠀⣀⠔⠒⢒⡩⠃⠀⠀⠀     BBBB        B BB     BB\n⠀⠀⠀⠀⣴⣿⣤⢀⠀⠀⠀⠀⠀⠈⠓⠒⠢⠔⠀⠀⠀⠀⠀⣶⠤⠄⠒⠒⠉⠁⠀⠀⠀⢸⡀⠀⠀⠀   BB      BBBBBB  B       BB\n⡄⠤⠒⠈⠈⣿⣿⣽⣦⠀⢀⢀⠰⢰⣀⣲⣿⡐⣤⠀⠀⢠⡾⠃⠀⠀⠀⠀⠀⠀⠀⣀⡄⣠⣵⠀  BB     BBB      BB        BB\n⠀⠀⠀⠀⠘⠏⢿⣿⡁⢐⠶⠈⣰⣿⣿⣿⣿⣷⢈⣣⢰⡞⠀⠀⠀⠀⠀⠀⢀⡴⠋⠁⠀⠀⠀⠀⠀ BB    BB  BBBBBBBB          BB\n⠀⠀⠀⠀⠀⠀⠈⢿⣿⣍⠀⠀⠸⣿⣿⣿⣿⠃⢈⣿⡎⠁⠀⠀⠀⠀⣠⠞⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀BB       BBB     B            BB\n⠀⠀⠀⠀⠀⠀⠀⠈⢙⣿⣆⠀⠀⠈⠛⠛⢋⢰⡼⠁⠁⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀B      BB                      BB\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠚⣷⣧⣷⣤⡶⠎⠛⠁⠀⠀⠀⢀⡤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠈⠁⠀⠀⠀⠀⠀⠠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n" => 5..4047
 # Lines exceeding max width of 80 characters
 ```
     2: ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠴⠤⠤⠴⠄⡄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀               BBBB
diff --git a/crates/biome_html_formatter/tests/specs/html/elements/pre.html.snap b/crates/biome_html_formatter/tests/specs/html/elements/pre.html.snap
index 7a70617ee4f3..f2839f17b0d4 100644
--- a/crates/biome_html_formatter/tests/specs/html/elements/pre.html.snap
+++ b/crates/biome_html_formatter/tests/specs/html/elements/pre.html.snap
@@ -1,7 +1,6 @@
 ---
 source: crates/biome_formatter_test/src/snapshot_builder.rs
 info: elements/pre.html
-snapshot_kind: text
 ---
 # Input
 
@@ -56,3 +55,9 @@ Self close void elements: never
 	~~                        \/__/         \/__/         \/__/
 </pre>
 ```
+
+
+
+## Unimplemented nodes/tokens
+
+"\n\t___                       ___           ___           ___\n\t/\\  \\          ___        /\\  \\         /\\__\\         /\\  \\\n /::\\  \\        /\\  \\      /::\\  \\       /::|  |       /::\\  \\\n/:/\\:\\  \\       \\:\\  \\    /:/\\:\\  \\     /:|:|  |      /:/\\:\\  \\\n/::\\~\\:\\__\\      /::\\__\\  /:/  \\:\\  \\   /:/|:|__|__   /::\\~\\:\\  \\\n/:/\\:\\ \\:|__|  __/:/\\/__/ /:/__/ \\:\\__\\ /:/ |::::\\__\\ /:/\\:\\ \\:\\__\\\n\\:\\~\\:\\/:/  / /\\/:/  /    \\:\\  \\ /:/  / \\/__/~~/:/  / \\:\\~\\:\\ \\/__/\n\\:\\ \\::/  /  \\::/__/      \\:\\  /:/  /        /:/  /   \\:\\ \\:\\__\\\n\\:\\/:/  /    \\:\\__\\       \\:\\/:/  /        /:/  /     \\:\\ \\/__/\n \\::/__/      \\/__/        \\::/  /        /:/  /       \\:\\__\\\n\t~~                        \\/__/         \\/__/         \\/__/\n" => 5..707
diff --git a/crates/biome_html_formatter/tests/specs/html/embedded/strict-whitespace-sensitivity/sensitive-style.html.snap b/crates/biome_html_formatter/tests/specs/html/embedded/strict-whitespace-sensitivity/sensitive-style.html.snap
index 13577cbec12d..03a3d68b83cc 100644
--- a/crates/biome_html_formatter/tests/specs/html/embedded/strict-whitespace-sensitivity/sensitive-style.html.snap
+++ b/crates/biome_html_formatter/tests/specs/html/embedded/strict-whitespace-sensitivity/sensitive-style.html.snap
@@ -39,6 +39,11 @@ body {
 </style>
 ```
 
+
+
+## Unimplemented nodes/tokens
+
+"\nbody {\n  background-color: seagreen;\n}\n" => 7..47
 ## Output 1
 
 -----
@@ -60,3 +65,9 @@ body {
 }
 </style>
 ```
+
+
+
+## Unimplemented nodes/tokens
+
+"\nbody {\n  background-color: seagreen;\n}\n" => 7..47
diff --git a/crates/biome_html_parser/src/parser.rs b/crates/biome_html_parser/src/parser.rs
index e6b9ad3548be..66261d3154b6 100644
--- a/crates/biome_html_parser/src/parser.rs
+++ b/crates/biome_html_parser/src/parser.rs
@@ -117,6 +117,18 @@ impl HtmlParseOptions {
         self.frontmatter = true;
         self
     }
+
+    /// 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) {
+        match value {
+            true => self.text_expression = Some(TextExpressionKind::Double),
+            false => self.text_expression = None,
+        }
+    }
 }
 
 impl From<&HtmlFileSource> for HtmlParseOptions {
diff --git a/crates/biome_html_parser/src/syntax/mod.rs b/crates/biome_html_parser/src/syntax/mod.rs
index 3ed586ff622f..2b3e77be002c 100644
--- a/crates/biome_html_parser/src/syntax/mod.rs
+++ b/crates/biome_html_parser/src/syntax/mod.rs
@@ -153,17 +153,30 @@ fn parse_element(p: &mut HtmlParser) -> ParsedSyntax {
             },
         );
         let opening = m.complete(p, HTML_OPENING_ELEMENT);
-        loop {
-            ElementList.parse_list(p);
-            if let Some(mut closing) =
-                parse_closing_tag(p).or_add_diagnostic(p, expected_closing_tag)
-                && !closing.text(p).contains(opening_tag_name.as_str())
-            {
-                p.error(expected_matching_closing_tag(p, closing.range(p)).into_diagnostic(p));
-                closing.change_to_bogus(p);
-                continue;
+        if is_embedded_language_tag {
+            // embedded language tags always have 1 element as content
+            let list = p.start();
+            if p.at(HTML_LITERAL) {
+                let m = p.start();
+                p.bump(HTML_LITERAL);
+                m.complete(p, HTML_EMBEDDED_CONTENT);
+            }
+            list.complete(p, HTML_ELEMENT_LIST);
+
+            parse_closing_tag(p).or_add_diagnostic(p, expected_closing_tag);
+        } else {
+            loop {
+                ElementList.parse_list(p);
+                if let Some(mut closing) =
+                    parse_closing_tag(p).or_add_diagnostic(p, expected_closing_tag)
+                    && !closing.text(p).contains(opening_tag_name.as_str())
+                {
+                    p.error(expected_matching_closing_tag(p, closing.range(p)).into_diagnostic(p));
+                    closing.change_to_bogus(p);
+                    continue;
+                }
+                break;
             }
-            break;
         }
         let previous = opening.precede(p);
 
diff --git a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-basic.html.snap b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-basic.html.snap
index 4f99514c76f3..8036a51f9eb4 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-basic.html.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-basic.html.snap
@@ -30,7 +30,7 @@ HtmlRoot {
                 r_angle_token: R_ANGLE@7..8 ">" [] [],
             },
             children: HtmlElementList [
-                HtmlContent {
+                HtmlEmbeddedContent {
                     value_token: HTML_LITERAL@8..40 "\n\tconsole.log('Hello, world!');\n" [] [],
                 },
             ],
@@ -64,7 +64,7 @@ HtmlRoot {
         2: HTML_ATTRIBUTE_LIST@7..7
         3: R_ANGLE@7..8 ">" [] []
       1: HTML_ELEMENT_LIST@8..40
-        0: HTML_CONTENT@8..40
+        0: HTML_EMBEDDED_CONTENT@8..40
           0: HTML_LITERAL@8..40 "\n\tconsole.log('Hello, world!');\n" [] []
       2: HTML_CLOSING_ELEMENT@40..49
         0: L_ANGLE@40..41 "<" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-in-string.html.snap b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-in-string.html.snap
index bcdac3f0bd27..53cb21d634b7 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-in-string.html.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-in-string.html.snap
@@ -28,7 +28,7 @@ HtmlRoot {
                 r_angle_token: R_ANGLE@7..8 ">" [] [],
             },
             children: HtmlElementList [
-                HtmlContent {
+                HtmlEmbeddedContent {
                     value_token: HTML_LITERAL@8..97 "window.jQuery || document.write('<script src=\"js/vendor/jquery-3.3.1.min.js\"><\\/script>')" [] [],
                 },
             ],
@@ -62,7 +62,7 @@ HtmlRoot {
         2: HTML_ATTRIBUTE_LIST@7..7
         3: R_ANGLE@7..8 ">" [] []
       1: HTML_ELEMENT_LIST@8..97
-        0: HTML_CONTENT@8..97
+        0: HTML_EMBEDDED_CONTENT@8..97
           0: HTML_LITERAL@8..97 "window.jQuery || document.write('<script src=\"js/vendor/jquery-3.3.1.min.js\"><\\/script>')" [] []
       2: HTML_CLOSING_ELEMENT@97..106
         0: L_ANGLE@97..98 "<" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-less-than.html.snap b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-less-than.html.snap
index 8e84d0cdcfad..4d363bdc90d5 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-less-than.html.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/embedded-languages/script-less-than.html.snap
@@ -32,7 +32,7 @@ HtmlRoot {
                 r_angle_token: R_ANGLE@7..8 ">" [] [],
             },
             children: HtmlElementList [
-                HtmlContent {
+                HtmlEmbeddedContent {
                     value_token: HTML_LITERAL@8..58 "\n\tif (1 < 2) {\n\t\tconsole.log('Hello, world!');\n\t}\n" [] [],
                 },
             ],
@@ -66,7 +66,7 @@ HtmlRoot {
         2: HTML_ATTRIBUTE_LIST@7..7
         3: R_ANGLE@7..8 ">" [] []
       1: HTML_ELEMENT_LIST@8..58
-        0: HTML_CONTENT@8..58
+        0: HTML_EMBEDDED_CONTENT@8..58
           0: HTML_LITERAL@8..58 "\n\tif (1 < 2) {\n\t\tconsole.log('Hello, world!');\n\t}\n" [] []
       2: HTML_CLOSING_ELEMENT@58..67
         0: L_ANGLE@58..59 "<" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap
index 134cb19c7bca..2b3886a4ca18 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte_expressions.svelte.snap
@@ -32,7 +32,7 @@ HtmlRoot {
                 r_angle_token: R_ANGLE@7..8 ">" [] [],
             },
             children: HtmlElementList [
-                HtmlContent {
+                HtmlEmbeddedContent {
                     value_token: HTML_LITERAL@8..33 "\n\tlet binding = \"World\";\n" [] [],
                 },
             ],
@@ -93,7 +93,7 @@ HtmlRoot {
         2: HTML_ATTRIBUTE_LIST@7..7
         3: R_ANGLE@7..8 ">" [] []
       1: HTML_ELEMENT_LIST@8..33
-        0: HTML_CONTENT@8..33
+        0: HTML_EMBEDDED_CONTENT@8..33
           0: HTML_LITERAL@8..33 "\n\tlet binding = \"World\";\n" [] []
       2: HTML_CLOSING_ELEMENT@33..42
         0: L_ANGLE@33..34 "<" [] []
diff --git a/crates/biome_html_syntax/Cargo.toml b/crates/biome_html_syntax/Cargo.toml
index d618cb0e4e2e..6a8c52ec5db1 100644
--- a/crates/biome_html_syntax/Cargo.toml
+++ b/crates/biome_html_syntax/Cargo.toml
@@ -18,6 +18,11 @@ biome_string_case = { workspace = true }
 camino            = { workspace = true }
 schemars          = { workspace = true, optional = true }
 serde             = { workspace = true, features = ["derive"] }
+
+[dev-dependencies]
+biome_html_factory = { path = "../biome_html_factory" }
+biome_html_parser  = { path = "../biome_html_parser" }
+
 [features]
 schema = ["schemars", "biome_rowan/serde"]
 
diff --git a/crates/biome_html_syntax/src/element_ext.rs b/crates/biome_html_syntax/src/element_ext.rs
index ea786c900fd3..ebf6126fbbc0 100644
--- a/crates/biome_html_syntax/src/element_ext.rs
+++ b/crates/biome_html_syntax/src/element_ext.rs
@@ -1,5 +1,7 @@
-use crate::HtmlSelfClosingElement;
-use biome_rowan::SyntaxResult;
+use crate::{
+    AnyHtmlElement, HtmlAttribute, HtmlElement, HtmlSelfClosingElement, inner_string_text,
+};
+use biome_rowan::{AstNodeList, SyntaxResult};
 
 /// https://html.spec.whatwg.org/#void-elements
 const VOID_ELEMENTS: &[&str] = &[
@@ -18,3 +20,194 @@ impl HtmlSelfClosingElement {
             .is_ok())
     }
 }
+
+impl AnyHtmlElement {
+    pub fn is_javascript_tag(&self) -> SyntaxResult<bool> {
+        match self {
+            Self::AnyHtmlContent(_)
+            | Self::HtmlBogusElement(_)
+            | Self::HtmlSelfClosingElement(_)
+            | Self::HtmlCdataSection(_) => Ok(false),
+            Self::HtmlElement(element) => element.is_javascript_tag(),
+        }
+    }
+
+    pub fn is_style_tag(&self) -> SyntaxResult<bool> {
+        match self {
+            Self::AnyHtmlContent(_)
+            | Self::HtmlBogusElement(_)
+            | Self::HtmlSelfClosingElement(_)
+            | Self::HtmlCdataSection(_) => Ok(false),
+            Self::HtmlElement(element) => element.is_style_tag(),
+        }
+    }
+
+    pub fn find_attribute_by_name(&self, name_to_lookup: &str) -> Option<HtmlAttribute> {
+        match self {
+            Self::HtmlElement(element) => element.find_attribute_by_name(name_to_lookup),
+            Self::HtmlSelfClosingElement(element) => element.find_attribute_by_name(name_to_lookup),
+            // Other variants don't have attributes
+            Self::AnyHtmlContent(_) | Self::HtmlBogusElement(_) | Self::HtmlCdataSection(_) => None,
+        }
+    }
+}
+
+impl HtmlSelfClosingElement {
+    pub fn find_attribute_by_name(&self, name_to_lookup: &str) -> Option<HtmlAttribute> {
+        self.attributes().iter().find_map(|attr| {
+            let attribute = attr.as_html_attribute()?;
+            let name = attribute.name().ok()?;
+            let name_token = name.value_token().ok()?;
+            if name_token
+                .text_trimmed()
+                .eq_ignore_ascii_case(name_to_lookup)
+            {
+                Some(attribute.clone())
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl HtmlElement {
+    pub fn find_attribute_by_name(&self, name_to_lookup: &str) -> Option<HtmlAttribute> {
+        self.opening_element()
+            .ok()?
+            .attributes()
+            .iter()
+            .find_map(|attr| {
+                let attribute = attr.as_html_attribute()?;
+                let name = attribute.name().ok()?;
+                let name_token = name.value_token().ok()?;
+                if name_token
+                    .text_trimmed()
+                    .eq_ignore_ascii_case(name_to_lookup)
+                {
+                    Some(attribute.clone())
+                } else {
+                    None
+                }
+            })
+    }
+
+    pub fn is_javascript_tag(&self) -> SyntaxResult<bool> {
+        let is_script = self.is_script_tag()?;
+        let type_attribute = self.find_attribute_by_name("type");
+
+        let is_type_javascript = type_attribute.is_none_or(|attribute| {
+            attribute
+                .initializer()
+                .and_then(|initializer| initializer.value().ok())
+                .and_then(|value| value.as_html_string().cloned())
+                .and_then(|value| value.value_token().ok())
+                .is_some_and(|token| {
+                    let text = inner_string_text(&token);
+                    text.eq_ignore_ascii_case("text/javascript")
+                        || text.eq_ignore_ascii_case("application/javascript")
+                        || text.eq_ignore_ascii_case("application/ecmascript")
+                        || text.eq_ignore_ascii_case("module")
+                })
+        });
+
+        Ok(is_script && is_type_javascript)
+    }
+
+    pub fn is_javascript_module(&self) -> SyntaxResult<bool> {
+        let is_script = self.is_script_tag()?;
+        let type_attribute = self.find_attribute_by_name("type");
+        let is_type_module = type_attribute.is_some_and(|attribute| {
+            attribute
+                .initializer()
+                .and_then(|initializer| initializer.value().ok())
+                .and_then(|value| value.as_html_string().cloned())
+                .and_then(|value| value.value_token().ok())
+                .is_some_and(|token| {
+                    let text = inner_string_text(&token);
+                    text.eq_ignore_ascii_case("module")
+                })
+        });
+
+        Ok(is_script && is_type_module)
+    }
+
+    pub fn is_style_tag(&self) -> SyntaxResult<bool> {
+        let opening_element = self.opening_element()?;
+        let name = opening_element.name()?;
+        let name_text = name.value_token()?;
+        Ok(name_text.text_trimmed().eq_ignore_ascii_case("style"))
+    }
+
+    pub fn is_script_tag(&self) -> SyntaxResult<bool> {
+        let opening_element = self.opening_element()?;
+        let name = opening_element.name()?;
+        let name_text = name.value_token()?;
+        Ok(name_text.text_trimmed().eq_ignore_ascii_case("script"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use biome_html_factory::syntax::HtmlElement;
+    use biome_html_parser::{HtmlParseOptions, parse_html};
+    use biome_rowan::AstNode;
+
+    #[test]
+    fn test_is_javascript_tag() {
+        let html = r#"
+        <script type="text/javascript">
+        </script>
+        "#;
+        let syntax = parse_html(html, HtmlParseOptions::default());
+        let element = syntax
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(HtmlElement::cast)
+            .unwrap();
+
+        assert!(element.is_javascript_tag().unwrap());
+
+        let html = r#"
+        <script type="application/javascript">
+        </script>
+        "#;
+        let syntax = parse_html(html, HtmlParseOptions::default());
+        let element = syntax
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(HtmlElement::cast)
+            .unwrap();
+
+        assert!(element.is_javascript_tag().unwrap());
+
+        let html = r#"
+        <script type="application/ecmascript">
+        </script>
+        "#;
+        let syntax = parse_html(html, HtmlParseOptions::default());
+        let element = syntax
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(HtmlElement::cast)
+            .unwrap();
+
+        assert!(element.is_javascript_tag().unwrap());
+
+        let html = r#"
+        <script type="module">
+        </script>
+        "#;
+        let syntax = parse_html(html, HtmlParseOptions::default());
+        let element = syntax
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(HtmlElement::cast)
+            .unwrap();
+
+        assert!(element.is_javascript_tag().unwrap());
+    }
+}
diff --git a/crates/biome_html_syntax/src/generated/kind.rs b/crates/biome_html_syntax/src/generated/kind.rs
index 5edc36f15042..61a5270415d9 100644
--- a/crates/biome_html_syntax/src/generated/kind.rs
+++ b/crates/biome_html_syntax/src/generated/kind.rs
@@ -53,6 +53,7 @@ pub enum HtmlSyntaxKind {
     HTML_ELEMENT_LIST,
     HTML_ATTRIBUTE_LIST,
     HTML_CONTENT,
+    HTML_EMBEDDED_CONTENT,
     HTML_CDATA_SECTION,
     COMMENT,
     HTML_DOUBLE_TEXT_EXPRESSION,
diff --git a/crates/biome_html_syntax/src/generated/macros.rs b/crates/biome_html_syntax/src/generated/macros.rs
index 55bd8b9c27fa..71179950f576 100644
--- a/crates/biome_html_syntax/src/generated/macros.rs
+++ b/crates/biome_html_syntax/src/generated/macros.rs
@@ -57,6 +57,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlElement::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_EMBEDDED_CONTENT => {
+                    let $pattern = unsafe { $crate::HtmlEmbeddedContent::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_OPENING_ELEMENT => {
                     let $pattern = unsafe { $crate::HtmlOpeningElement::new_unchecked(node) };
                     $body
diff --git a/crates/biome_html_syntax/src/generated/nodes.rs b/crates/biome_html_syntax/src/generated/nodes.rs
index 126711d7dcfd..47922befd7b2 100644
--- a/crates/biome_html_syntax/src/generated/nodes.rs
+++ b/crates/biome_html_syntax/src/generated/nodes.rs
@@ -470,6 +470,41 @@ pub struct HtmlElementFields {
     pub closing_element: SyntaxResult<HtmlClosingElement>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlEmbeddedContent {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlEmbeddedContent {
+    #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
+    #[doc = r""]
+    #[doc = r" # Safety"]
+    #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"]
+    #[doc = r" or a match on [SyntaxNode::kind]"]
+    #[inline]
+    pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self { syntax }
+    }
+    pub fn as_fields(&self) -> HtmlEmbeddedContentFields {
+        HtmlEmbeddedContentFields {
+            value_token: self.value_token(),
+        }
+    }
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlEmbeddedContent {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlEmbeddedContentFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HtmlOpeningElement {
     pub(crate) syntax: SyntaxNode,
 }
@@ -847,6 +882,7 @@ impl AnyHtmlAttributeInitializer {
 pub enum AnyHtmlContent {
     AnyHtmlTextExpression(AnyHtmlTextExpression),
     HtmlContent(HtmlContent),
+    HtmlEmbeddedContent(HtmlEmbeddedContent),
 }
 impl AnyHtmlContent {
     pub fn as_any_html_text_expression(&self) -> Option<&AnyHtmlTextExpression> {
@@ -861,6 +897,12 @@ impl AnyHtmlContent {
             _ => None,
         }
     }
+    pub fn as_html_embedded_content(&self) -> Option<&HtmlEmbeddedContent> {
+        match &self {
+            Self::HtmlEmbeddedContent(item) => Some(item),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub enum AnyHtmlElement {
@@ -1487,6 +1529,56 @@ impl From<HtmlElement> for SyntaxElement {
         n.syntax.into()
     }
 }
+impl AstNode for HtmlEmbeddedContent {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_EMBEDDED_CONTENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == HTML_EMBEDDED_CONTENT
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for HtmlEmbeddedContent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
+        let current_depth = DEPTH.get();
+        let result = if current_depth < 16 {
+            DEPTH.set(current_depth + 1);
+            f.debug_struct("HtmlEmbeddedContent")
+                .field(
+                    "value_token",
+                    &support::DebugSyntaxResult(self.value_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("HtmlEmbeddedContent").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<HtmlEmbeddedContent> for SyntaxNode {
+    fn from(n: HtmlEmbeddedContent) -> Self {
+        n.syntax
+    }
+}
+impl From<HtmlEmbeddedContent> for SyntaxElement {
+    fn from(n: HtmlEmbeddedContent) -> Self {
+        n.syntax.into()
+    }
+}
 impl AstNode for HtmlOpeningElement {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
@@ -2075,13 +2167,19 @@ impl From<HtmlContent> for AnyHtmlContent {
         Self::HtmlContent(node)
     }
 }
+impl From<HtmlEmbeddedContent> for AnyHtmlContent {
+    fn from(node: HtmlEmbeddedContent) -> Self {
+        Self::HtmlEmbeddedContent(node)
+    }
+}
 impl AstNode for AnyHtmlContent {
     type Language = Language;
-    const KIND_SET: SyntaxKindSet<Language> =
-        AnyHtmlTextExpression::KIND_SET.union(HtmlContent::KIND_SET);
+    const KIND_SET: SyntaxKindSet<Language> = AnyHtmlTextExpression::KIND_SET
+        .union(HtmlContent::KIND_SET)
+        .union(HtmlEmbeddedContent::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            HTML_CONTENT => true,
+            HTML_CONTENT | HTML_EMBEDDED_CONTENT => true,
             k if AnyHtmlTextExpression::can_cast(k) => true,
             _ => false,
         }
@@ -2089,6 +2187,7 @@ impl AstNode for AnyHtmlContent {
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
             HTML_CONTENT => Self::HtmlContent(HtmlContent { syntax }),
+            HTML_EMBEDDED_CONTENT => Self::HtmlEmbeddedContent(HtmlEmbeddedContent { syntax }),
             _ => {
                 if let Some(any_html_text_expression) = AnyHtmlTextExpression::cast(syntax) {
                     return Some(Self::AnyHtmlTextExpression(any_html_text_expression));
@@ -2101,12 +2200,14 @@ impl AstNode for AnyHtmlContent {
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Self::HtmlContent(it) => &it.syntax,
+            Self::HtmlEmbeddedContent(it) => &it.syntax,
             Self::AnyHtmlTextExpression(it) => it.syntax(),
         }
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
             Self::HtmlContent(it) => it.syntax,
+            Self::HtmlEmbeddedContent(it) => it.syntax,
             Self::AnyHtmlTextExpression(it) => it.into_syntax(),
         }
     }
@@ -2116,6 +2217,7 @@ impl std::fmt::Debug for AnyHtmlContent {
         match self {
             Self::AnyHtmlTextExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlContent(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlEmbeddedContent(it) => std::fmt::Debug::fmt(it, f),
         }
     }
 }
@@ -2124,6 +2226,7 @@ impl From<AnyHtmlContent> for SyntaxNode {
         match n {
             AnyHtmlContent::AnyHtmlTextExpression(it) => it.into(),
             AnyHtmlContent::HtmlContent(it) => it.into(),
+            AnyHtmlContent::HtmlEmbeddedContent(it) => it.into(),
         }
     }
 }
@@ -2393,6 +2496,11 @@ impl std::fmt::Display for HtmlElement {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for HtmlEmbeddedContent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for HtmlOpeningElement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/biome_html_syntax/src/generated/nodes_mut.rs b/crates/biome_html_syntax/src/generated/nodes_mut.rs
index 3a0ef8e5326b..b20bd803d65b 100644
--- a/crates/biome_html_syntax/src/generated/nodes_mut.rs
+++ b/crates/biome_html_syntax/src/generated/nodes_mut.rs
@@ -203,6 +203,14 @@ impl HtmlElement {
         )
     }
 }
+impl HtmlEmbeddedContent {
+    pub fn with_value_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
 impl HtmlOpeningElement {
     pub fn with_l_angle_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
diff --git a/crates/biome_js_formatter/src/lib.rs b/crates/biome_js_formatter/src/lib.rs
index a7a92bfabf73..cab7fabf7153 100644
--- a/crates/biome_js_formatter/src/lib.rs
+++ b/crates/biome_js_formatter/src/lib.rs
@@ -190,7 +190,8 @@ use biome_formatter::{
     CstFormatContext, Format, FormatLanguage, TransformSourceMap, comments::Comments, write,
 };
 use biome_js_syntax::{
-    AnyJsDeclaration, AnyJsStatement, JsLanguage, JsSyntaxKind, JsSyntaxNode, JsSyntaxToken,
+    AnyJsDeclaration, AnyJsStatement, JsLanguage, JsSyntaxKind, JsSyntaxNode,
+    JsSyntaxNodeWithOffset, JsSyntaxToken,
 };
 use biome_rowan::TextRange;
 use biome_rowan::{AstNode, SyntaxNode};
@@ -527,6 +528,7 @@ impl FormatLanguage for JsFormatLanguage {
         self,
         root: &JsSyntaxNode,
         source_map: Option<TransformSourceMap>,
+        _delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments = Comments::from_node(root, &JsCommentStyle, source_map.as_ref());
         JsFormatContext::new(self.options, comments).with_source_map(source_map)
@@ -559,7 +561,17 @@ pub fn format_node(
     options: JsFormatOptions,
     root: &JsSyntaxNode,
 ) -> FormatResult<Formatted<JsFormatContext>> {
-    biome_formatter::format_node(root, JsFormatLanguage::new(options))
+    biome_formatter::format_node(root, JsFormatLanguage::new(options), false)
+}
+
+/// Formats a JavaScript (and its super languages) file based on its features.
+///
+/// It returns a [Formatted] result, which the user can use to override a file.
+pub fn format_node_with_offset(
+    options: JsFormatOptions,
+    root: &JsSyntaxNodeWithOffset,
+) -> FormatResult<Formatted<JsFormatContext>> {
+    biome_formatter::format_node_with_offset(root, JsFormatLanguage::new(options), false)
 }
 
 /// Formats a single node within a file, supported by Biome.
diff --git a/crates/biome_js_syntax/src/syntax_node.rs b/crates/biome_js_syntax/src/syntax_node.rs
index b14609ab4639..4ef457468c6a 100644
--- a/crates/biome_js_syntax/src/syntax_node.rs
+++ b/crates/biome_js_syntax/src/syntax_node.rs
@@ -26,3 +26,4 @@ pub type JsSyntaxNodeChildren = biome_rowan::SyntaxNodeChildren<JsLanguage>;
 pub type JsSyntaxElementChildren = biome_rowan::SyntaxElementChildren<JsLanguage>;
 pub type JsSyntaxList = biome_rowan::SyntaxList<JsLanguage>;
 pub type JsSyntaxTrivia = biome_rowan::syntax::SyntaxTrivia<JsLanguage>;
+pub type JsSyntaxNodeWithOffset = biome_rowan::SyntaxNodeWithOffset<JsLanguage>;
diff --git a/crates/biome_json_formatter/src/lib.rs b/crates/biome_json_formatter/src/lib.rs
index 45b34fa25681..4ac8313d9775 100644
--- a/crates/biome_json_formatter/src/lib.rs
+++ b/crates/biome_json_formatter/src/lib.rs
@@ -269,6 +269,7 @@ impl FormatLanguage for JsonFormatLanguage {
         self,
         root: &JsonSyntaxNode,
         source_map: Option<TransformSourceMap>,
+        _delegate_fmt_embedded_nodes: bool,
     ) -> Self::Context {
         let comments = Comments::from_node(root, &JsonCommentStyle, source_map.as_ref());
         JsonFormatContext::new(self.options, comments).with_source_map(source_map)
@@ -345,7 +346,7 @@ pub fn format_node(
     options: JsonFormatOptions,
     root: &JsonSyntaxNode,
 ) -> FormatResult<Formatted<JsonFormatContext>> {
-    biome_formatter::format_node(root, JsonFormatLanguage::new(options))
+    biome_formatter::format_node(root, JsonFormatLanguage::new(options), false)
 }
 
 /// Formats a single node within a file, supported by Biome.
diff --git a/crates/biome_service/src/file_handlers/astro.rs b/crates/biome_service/src/file_handlers/astro.rs
index cff3065ba1ef..b53405bb06d1 100644
--- a/crates/biome_service/src/file_handlers/astro.rs
+++ b/crates/biome_service/src/file_handlers/astro.rs
@@ -94,6 +94,7 @@ impl ExtensionHandler for AstroFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             // TODO: We should be able to search JS portions already
             search: SearchCapabilities { search: None },
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index 4eccfd8a87ce..4ee50aa0dba0 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -138,15 +138,42 @@ impl CssParserSettings {
 impl ServiceLanguage for CssLanguage {
     type FormatterSettings = CssFormatterSettings;
     type LinterSettings = CssLinterSettings;
+    type AssistSettings = CssAssistSettings;
     type FormatOptions = CssFormatOptions;
     type ParserSettings = CssParserSettings;
-    type AssistSettings = CssAssistSettings;
+    type ParserOptions = CssParserOptions;
+
     type EnvironmentSettings = ();
 
     fn lookup_settings(language: &LanguageListSettings) -> &LanguageSettings<Self> {
         &language.css
     }
 
+    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
+        None
+    }
+
+    fn resolve_parse_options(
+        overrides: &OverrideSettings,
+        language: &Self::ParserSettings,
+        path: &BiomePath,
+        _file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+        let mut options = CssParserOptions {
+            allow_wrong_line_comments: language
+                .allow_wrong_line_comments
+                .unwrap_or_default()
+                .into(),
+            css_modules: language.css_modules_enabled.unwrap_or_default().into(),
+            grit_metavariables: false,
+            tailwind_directives: language.tailwind_directives_enabled(),
+        };
+
+        overrides.apply_override_css_parser_options(path, &mut options);
+
+        options
+    }
+
     fn resolve_format_options(
         global: &FormatSettings,
         overrides: &OverrideSettings,
@@ -228,7 +255,7 @@ impl ServiceLanguage for CssLanguage {
             .with_suppression_reason(suppression_reason)
     }
 
-    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -237,8 +264,8 @@ impl ServiceLanguage for CssLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.css.formatter.enabled,
-                        pattern.formatter.enabled,
+                        pattern.languages.css.linter.enabled,
+                        pattern.linter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -248,14 +275,14 @@ impl ServiceLanguage for CssLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.css.formatter.enabled,
-                settings.formatter.enabled,
+                settings.languages.css.linter.enabled,
+                settings.linter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -264,8 +291,8 @@ impl ServiceLanguage for CssLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.css.assist.enabled,
-                        pattern.assist.enabled,
+                        pattern.languages.css.formatter.enabled,
+                        pattern.formatter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -275,14 +302,14 @@ impl ServiceLanguage for CssLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.css.assist.enabled,
-                settings.assist.enabled,
+                settings.languages.css.formatter.enabled,
+                settings.formatter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -291,8 +318,8 @@ impl ServiceLanguage for CssLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.css.linter.enabled,
-                        pattern.linter.enabled,
+                        pattern.languages.css.assist.enabled,
+                        pattern.assist.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -302,16 +329,12 @@ impl ServiceLanguage for CssLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.css.linter.enabled,
-                settings.linter.enabled,
+                settings.languages.css.assist.enabled,
+                settings.assist.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
-
-    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
-        None
-    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -339,6 +362,7 @@ impl ExtensionHandler for CssFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             search: SearchCapabilities {
                 search: Some(search),
diff --git a/crates/biome_service/src/file_handlers/graphql.rs b/crates/biome_service/src/file_handlers/graphql.rs
index 405250ea9f33..9e43b2ab079e 100644
--- a/crates/biome_service/src/file_handlers/graphql.rs
+++ b/crates/biome_service/src/file_handlers/graphql.rs
@@ -94,15 +94,29 @@ impl From<GraphqlAssistConfiguration> for GraphqlAssistSettings {
 impl ServiceLanguage for GraphqlLanguage {
     type FormatterSettings = GraphqlFormatterSettings;
     type LinterSettings = GraphqlLinterSettings;
+    type AssistSettings = GraphqlAssistSettings;
     type FormatOptions = GraphqlFormatOptions;
     type ParserSettings = ();
+    type ParserOptions = ();
+
     type EnvironmentSettings = ();
-    type AssistSettings = GraphqlAssistSettings;
 
     fn lookup_settings(language: &LanguageListSettings) -> &LanguageSettings<Self> {
         &language.graphql
     }
 
+    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
+        None
+    }
+
+    fn resolve_parse_options(
+        _overrides: &OverrideSettings,
+        _language: &Self::ParserSettings,
+        _path: &BiomePath,
+        _file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+    }
+
     fn resolve_format_options(
         global: &FormatSettings,
         overrides: &OverrideSettings,
@@ -163,7 +177,7 @@ impl ServiceLanguage for GraphqlLanguage {
             .with_suppression_reason(suppression_reason)
     }
 
-    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -172,8 +186,8 @@ impl ServiceLanguage for GraphqlLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.graphql.formatter.enabled,
-                        pattern.formatter.enabled,
+                        pattern.languages.graphql.linter.enabled,
+                        pattern.linter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -183,14 +197,14 @@ impl ServiceLanguage for GraphqlLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.graphql.formatter.enabled,
-                settings.formatter.enabled,
+                settings.languages.graphql.linter.enabled,
+                settings.linter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -199,8 +213,8 @@ impl ServiceLanguage for GraphqlLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.graphql.assist.enabled,
-                        pattern.assist.enabled,
+                        pattern.languages.graphql.formatter.enabled,
+                        pattern.formatter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -210,14 +224,14 @@ impl ServiceLanguage for GraphqlLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.graphql.assist.enabled,
-                settings.assist.enabled,
+                settings.languages.graphql.formatter.enabled,
+                settings.formatter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -226,8 +240,8 @@ impl ServiceLanguage for GraphqlLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.graphql.linter.enabled,
-                        pattern.linter.enabled,
+                        pattern.languages.graphql.assist.enabled,
+                        pattern.assist.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -237,16 +251,12 @@ impl ServiceLanguage for GraphqlLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.graphql.linter.enabled,
-                settings.linter.enabled,
+                settings.languages.graphql.assist.enabled,
+                settings.assist.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
-
-    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
-        None
-    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -280,6 +290,7 @@ impl ExtensionHandler for GraphqlFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             search: SearchCapabilities { search: None },
         }
diff --git a/crates/biome_service/src/file_handlers/grit.rs b/crates/biome_service/src/file_handlers/grit.rs
index c2a3739d7c32..34473cf5b46d 100644
--- a/crates/biome_service/src/file_handlers/grit.rs
+++ b/crates/biome_service/src/file_handlers/grit.rs
@@ -3,7 +3,7 @@ use super::{
     ExtensionHandler, FixAllParams, FormatterCapabilities, LintParams, LintResults, ParseResult,
     ParserCapabilities, SearchCapabilities,
 };
-use crate::settings::{check_feature_activity, check_override_feature_activity};
+use crate::settings::{OverrideSettings, check_feature_activity, check_override_feature_activity};
 use crate::workspace::{FixFileResult, GetSyntaxTreeResult};
 use crate::{
     WorkspaceError,
@@ -78,16 +78,30 @@ impl From<GritAssistConfiguration> for GritAssistSettings {
 impl ServiceLanguage for GritLanguage {
     type FormatterSettings = GritFormatterSettings;
     type LinterSettings = GritLinterSettings;
+    type AssistSettings = GritAssistSettings;
     type FormatOptions = GritFormatOptions;
     type ParserSettings = ();
+    type ParserOptions = ();
     type EnvironmentSettings = ();
-    type AssistSettings = GritAssistSettings;
+
     fn lookup_settings(
         languages: &crate::settings::LanguageListSettings,
     ) -> &crate::settings::LanguageSettings<Self> {
         &languages.grit
     }
 
+    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
+        None
+    }
+
+    fn resolve_parse_options(
+        _overrides: &OverrideSettings,
+        _language: &Self::ParserSettings,
+        _path: &BiomePath,
+        _file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+    }
+
     fn resolve_format_options(
         global: &crate::settings::FormatSettings,
         overrides: &crate::settings::OverrideSettings,
@@ -138,7 +152,7 @@ impl ServiceLanguage for GritLanguage {
             .with_suppression_reason(suppression_reason)
     }
 
-    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -147,8 +161,8 @@ impl ServiceLanguage for GritLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.grit.formatter.enabled,
-                        pattern.formatter.enabled,
+                        pattern.languages.grit.linter.enabled,
+                        pattern.linter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -158,14 +172,14 @@ impl ServiceLanguage for GritLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.grit.formatter.enabled,
-                settings.formatter.enabled,
+                settings.languages.grit.linter.enabled,
+                settings.linter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -174,8 +188,8 @@ impl ServiceLanguage for GritLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.grit.assist.enabled,
-                        pattern.assist.enabled,
+                        pattern.languages.grit.formatter.enabled,
+                        pattern.formatter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -185,14 +199,14 @@ impl ServiceLanguage for GritLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.grit.assist.enabled,
-                settings.assist.enabled,
+                settings.languages.grit.formatter.enabled,
+                settings.formatter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -201,8 +215,8 @@ impl ServiceLanguage for GritLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.grit.linter.enabled,
-                        pattern.linter.enabled,
+                        pattern.languages.grit.assist.enabled,
+                        pattern.assist.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -212,16 +226,12 @@ impl ServiceLanguage for GritLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.grit.linter.enabled,
-                settings.linter.enabled,
+                settings.languages.grit.assist.enabled,
+                settings.assist.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
-
-    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
-        None
-    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -255,6 +265,7 @@ impl ExtensionHandler for GritFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             search: SearchCapabilities { search: None },
         }
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
index f449c1be894e..83d141bca4fa 100644
--- a/crates/biome_service/src/file_handlers/html.rs
+++ b/crates/biome_service/src/file_handlers/html.rs
@@ -1,9 +1,9 @@
 use super::{
     AnalyzerCapabilities, Capabilities, DebugCapabilities, DocumentFileSource, EnabledForPath,
-    ExtensionHandler, FixAllParams, FormatterCapabilities, LintParams, LintResults, ParseResult,
-    ParserCapabilities, SearchCapabilities,
+    ExtensionHandler, FixAllParams, FormatEmbedNode, FormatterCapabilities, LintParams,
+    LintResults, ParseResult, ParserCapabilities, SearchCapabilities,
 };
-use crate::settings::{check_feature_activity, check_override_feature_activity};
+use crate::settings::{OverrideSettings, check_feature_activity, check_override_feature_activity};
 use crate::workspace::FixFileResult;
 use crate::workspace::{EmbeddedCssContent, EmbeddedJsContent};
 use crate::{
@@ -17,9 +17,13 @@ use biome_configuration::html::{
     HtmlParserConfiguration,
 };
 use biome_css_parser::{CssParserOptions, parse_css_with_offset_and_cache};
+use biome_css_syntax::{CssFileSource, CssLanguage};
 use biome_diagnostics::{Diagnostic, Severity};
+use biome_formatter::format_element::{Interned, LineMode};
+use biome_formatter::prelude::{Document, Tag};
 use biome_formatter::{
-    AttributePosition, BracketSameLine, IndentStyle, IndentWidth, LineEnding, LineWidth, Printed,
+    AttributePosition, BracketSameLine, FormatElement, IndentStyle, IndentWidth, LineEnding,
+    LineWidth, Printed,
 };
 use biome_fs::BiomePath;
 use biome_html_formatter::context::SelfCloseVoidElements;
@@ -31,10 +35,11 @@ use biome_html_formatter::{
 use biome_html_parser::{HtmlParseOptions, parse_html_with_cache};
 use biome_html_syntax::{HtmlElement, HtmlLanguage, HtmlRoot, HtmlSyntaxNode};
 use biome_js_parser::{JsParserOptions, parse_js_with_offset_and_cache};
-use biome_js_syntax::JsFileSource;
+use biome_js_syntax::{JsFileSource, JsLanguage};
 use biome_parser::AnyParse;
 use biome_rowan::{AstNode, AstNodeList, NodeCache};
 use camino::Utf8Path;
+use std::fmt::Debug;
 use tracing::debug_span;
 
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
@@ -200,6 +205,25 @@ impl ServiceLanguage for HtmlLanguage {
     fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
         None
     }
+
+    type ParserOptions = HtmlParseOptions;
+
+    fn resolve_parse_options(
+        overrides: &OverrideSettings,
+        language: &Self::ParserSettings,
+        path: &BiomePath,
+        file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+        let html_file_source = file_source.to_html_file_source().unwrap_or_default();
+        let mut options = HtmlParseOptions::from(&html_file_source);
+        if language.interpolation.unwrap_or_default().into() && html_file_source.is_html() {
+            options = options.with_double_text_expression();
+        }
+
+        overrides.apply_override_html_parser_options(path, &mut options);
+
+        options
+    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -233,6 +257,7 @@ impl ExtensionHandler for HtmlFileHandler {
                 format: Some(format),
                 format_range: None,
                 format_on_type: None,
+                format_embedded: Some(format_embedded),
             },
             search: SearchCapabilities { search: None },
         }
@@ -256,25 +281,13 @@ fn search_enabled(_path: &Utf8Path, _settings: &Settings) -> bool {
 }
 
 fn parse(
-    _biome_path: &BiomePath,
+    biome_path: &BiomePath,
     file_source: DocumentFileSource,
     text: &str,
     settings: &Settings,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    let html_file_source = file_source.to_html_file_source().unwrap_or_default();
-    let mut options = HtmlParseOptions::from(&html_file_source);
-    if settings
-        .languages
-        .html
-        .parser
-        .interpolation
-        .unwrap_or_default()
-        .into()
-        && html_file_source.is_html()
-    {
-        options = options.with_double_text_expression();
-    }
+    let options = settings.parse_options::<HtmlLanguage>(biome_path, &file_source);
     let parse = parse_html_with_cache(text, cache, options);
 
     ParseResult {
@@ -283,57 +296,37 @@ fn parse(
     }
 }
 
-/// Extracts embedded JavaScript content from HTML script elements.
-///
-/// This function walks the HTML syntax tree to find all `<script>` elements
-/// and extracts their content for offset-aware JavaScript parsing.
-///
-/// # Arguments
-/// * `html_root` - The parsed HTML syntax tree
-/// * `source_text` - The original HTML source text
-/// * `cache` - Node cache for performance optimization
-///
-/// # Returns
-/// A vector of `EmbeddedJsContent` containing parsed JavaScript with correct offsets
-pub(crate) fn extract_embedded_scripts(
-    html_root: &HtmlRoot,
-    cache: &mut NodeCache,
-) -> Vec<EmbeddedJsContent> {
-    let mut scripts = Vec::new();
-
-    // Walk through all HTML elements looking for script tags
-    for element in html_root.syntax().descendants() {
-        let Some(list) = extract_embedded_script(element.clone(), cache) else {
-            continue;
-        };
-        scripts.extend(list);
-    }
-    scripts
-}
-
-fn extract_embedded_script(
+pub(crate) fn extract_embedded_script(
     element: HtmlSyntaxNode,
     cache: &mut NodeCache,
+    options: JsParserOptions,
+    source_index_fn: impl Fn(JsFileSource) -> usize,
 ) -> Option<Vec<EmbeddedJsContent>> {
     let html_element = HtmlElement::cast(element)?;
-    let opening_element = html_element.opening_element().ok()?;
-    let name = opening_element.name().ok()?;
-    let name_text = name.value_token().ok()?;
 
-    if name_text.text_trimmed() == "script" {
+    if html_element.is_javascript_tag().unwrap_or_default() {
+        let is_modules = html_element.is_javascript_module().unwrap_or_default();
+        let file_source = if is_modules {
+            JsFileSource::js_module()
+        } else {
+            JsFileSource::js_script()
+        };
+
+        let file_source_index = source_index_fn(file_source);
+
         Some(
             html_element
                 .children()
                 .iter()
                 .filter_map(|child| child.as_any_html_content().cloned())
-                .filter_map(|child| child.as_html_content().cloned())
+                .filter_map(|child| child.as_html_embedded_content().cloned())
                 .filter_map(|child| {
                     let content = child.value_token().ok()?;
                     let parse = parse_js_with_offset_and_cache(
                         content.text(),
                         content.text_range().start(),
-                        JsFileSource::js_script(),
-                        JsParserOptions::default(),
+                        file_source,
+                        options.clone(),
                         cache,
                     );
 
@@ -342,6 +335,7 @@ fn extract_embedded_script(
                         element_range: child.range(),
                         content_range: content.text_range(),
                         content_offset: content.text_range().start(),
+                        file_source_index,
                     })
                 })
                 .collect::<Vec<_>>(),
@@ -351,54 +345,41 @@ fn extract_embedded_script(
     }
 }
 
-/// Extracts embedded CSS content from HTML style elements.
-pub(crate) fn parse_embedded_styles(
-    html_root: &HtmlRoot,
-    cache: &mut NodeCache,
-) -> Vec<EmbeddedCssContent> {
-    let mut styles = Vec::new();
-
-    // Walk through all HTML elements looking for style tags
-    for element in html_root.syntax().descendants() {
-        let Some(list) = parse_embedded_style(element.clone(), cache) else {
-            continue;
-        };
-        styles.extend(list);
-    }
-
-    styles
-}
-
-fn parse_embedded_style(
+pub(crate) fn parse_embedded_style<F>(
     element: HtmlSyntaxNode,
     cache: &mut NodeCache,
-) -> Option<Vec<EmbeddedCssContent>> {
+    options: CssParserOptions,
+    source_index_fn: F,
+) -> Option<Vec<EmbeddedCssContent>>
+where
+    F: Fn(CssFileSource) -> usize,
+{
     let html_element = HtmlElement::cast(element)?;
-    let opening_element = html_element.opening_element().ok()?;
-    let name = opening_element.name().ok()?;
-    let name_text = name.value_token().ok()?;
 
-    if name_text.text_trimmed() == "style" {
+    if html_element.is_style_tag().unwrap_or_default() {
         Some(
             html_element
                 .children()
                 .iter()
                 .filter_map(|child| child.as_any_html_content().cloned())
-                .filter_map(|child| child.as_html_content().cloned())
+                .filter_map(|child| child.as_html_embedded_content().cloned())
                 .filter_map(|child| {
                     let content = child.value_token().ok()?;
                     let parse = parse_css_with_offset_and_cache(
                         content.text(),
                         content.text_range().start(),
                         cache,
-                        CssParserOptions::default(),
+                        options,
                     );
 
+                    let file_source_index = source_index_fn(CssFileSource::css());
+
                     Some(EmbeddedCssContent {
                         parse: parse.into(),
                         element_range: child.range(),
                         content_range: content.text_range(),
                         content_offset: content.text_range().start(),
+                        file_source_index,
                     })
                 })
                 .collect::<Vec<_>>(),
@@ -426,7 +407,7 @@ fn debug_formatter_ir(
     let options = settings.format_options::<HtmlLanguage>(path, document_file_source);
 
     let tree = parse.syntax();
-    let formatted = format_node(options, &tree)?;
+    let formatted = format_node(options, &tree, false)?;
 
     let root_element = formatted.into_document();
     Ok(root_element.to_string())
@@ -442,7 +423,88 @@ fn format(
     let options = settings.format_options::<HtmlLanguage>(biome_path, document_file_source);
 
     let tree = parse.syntax();
-    let formatted = format_node(options, &tree)?;
+    let formatted = format_node(options, &tree, true)?;
+
+    match formatted.print() {
+        Ok(printed) => Ok(printed),
+        Err(error) => Err(WorkspaceError::FormatError(error.into())),
+    }
+}
+
+fn format_embedded(
+    biome_path: &BiomePath,
+    document_file_source: &DocumentFileSource,
+    parse: AnyParse,
+    settings: &Settings,
+    embedded_nodes: Vec<FormatEmbedNode>,
+) -> Result<Printed, WorkspaceError> {
+    let options = settings.format_options::<HtmlLanguage>(biome_path, document_file_source);
+
+    let tree = parse.syntax();
+    let indent_script_and_style = options.indent_script_and_style().value();
+    let mut formatted = format_node(options, &tree, true)?;
+    formatted.format_embedded(move |range| {
+        let mut iter = embedded_nodes.iter();
+        let node = iter.find(|node| node.range == range)?;
+
+        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))
+                }
+            }
+            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))
+                }
+            }
+            _ => None,
+        }
+    });
 
     match formatted.print() {
         Ok(printed) => Ok(printed),
@@ -480,6 +542,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 .settings
                 .format_options::<HtmlLanguage>(params.biome_path, &params.document_file_source),
             tree.syntax(),
+            false,
         )?
         .print()?
         .into_code()
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 67c8c0f37a41..eae73dfdea0c 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -171,15 +171,40 @@ impl From<JsxRuntime> for JsEnvironmentSettings {
 impl ServiceLanguage for JsLanguage {
     type FormatterSettings = JsFormatterSettings;
     type LinterSettings = JsLinterSettings;
+    type AssistSettings = JsAssistSettings;
     type FormatOptions = JsFormatOptions;
     type ParserSettings = JsParserSettings;
+    type ParserOptions = JsParserOptions;
+
     type EnvironmentSettings = JsEnvironmentSettings;
-    type AssistSettings = JsAssistSettings;
 
     fn lookup_settings(languages: &LanguageListSettings) -> &LanguageSettings<Self> {
         &languages.javascript
     }
 
+    fn resolve_environment(global: &Settings) -> Option<&Self::EnvironmentSettings> {
+        Some(&global.languages.javascript.environment)
+    }
+
+    fn resolve_parse_options(
+        overrides: &OverrideSettings,
+        language: &Self::ParserSettings,
+        path: &BiomePath,
+        _file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+        let mut options = JsParserOptions {
+            grit_metavariables: false,
+            parse_class_parameter_decorators: language
+                .parse_class_parameter_decorators
+                .unwrap_or_default()
+                .into(),
+        };
+
+        overrides.apply_override_js_parser_options(path, &mut options);
+
+        options
+    }
+
     fn resolve_format_options(
         global: &FormatSettings,
         overrides: &OverrideSettings,
@@ -357,7 +382,7 @@ impl ServiceLanguage for JsLanguage {
             .with_suppression_reason(suppression_reason)
     }
 
-    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -366,8 +391,8 @@ impl ServiceLanguage for JsLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.javascript.formatter.enabled,
-                        pattern.formatter.enabled,
+                        pattern.languages.javascript.linter.enabled,
+                        pattern.linter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -377,14 +402,14 @@ impl ServiceLanguage for JsLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.javascript.formatter.enabled,
-                settings.formatter.enabled,
+                settings.languages.javascript.linter.enabled,
+                settings.linter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -393,8 +418,8 @@ impl ServiceLanguage for JsLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.javascript.assist.enabled,
-                        pattern.assist.enabled,
+                        pattern.languages.javascript.formatter.enabled,
+                        pattern.formatter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -404,14 +429,14 @@ impl ServiceLanguage for JsLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.javascript.assist.enabled,
-                settings.assist.enabled,
+                settings.languages.javascript.formatter.enabled,
+                settings.formatter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -420,8 +445,8 @@ impl ServiceLanguage for JsLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.javascript.linter.enabled,
-                        pattern.linter.enabled,
+                        pattern.languages.javascript.assist.enabled,
+                        pattern.assist.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -431,16 +456,12 @@ impl ServiceLanguage for JsLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.javascript.linter.enabled,
-                settings.linter.enabled,
+                settings.languages.javascript.assist.enabled,
+                settings.assist.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
-
-    fn resolve_environment(global: &Settings) -> Option<&Self::EnvironmentSettings> {
-        Some(&global.languages.javascript.environment)
-    }
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -474,6 +495,7 @@ impl ExtensionHandler for JsFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             search: SearchCapabilities {
                 search: Some(search),
@@ -505,20 +527,7 @@ fn parse(
     settings: &Settings,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    let mut options = JsParserOptions {
-        grit_metavariables: false,
-        parse_class_parameter_decorators: settings
-            .languages
-            .javascript
-            .parser
-            .parse_class_parameter_decorators
-            .unwrap_or_default()
-            .into(),
-    };
-
-    settings
-        .override_settings
-        .apply_override_js_parser_options(biome_path, &mut options);
+    let options = settings.parse_options::<JsLanguage>(biome_path, &file_source);
 
     let file_source = file_source.to_js_file_source().unwrap_or_default();
     let parse = biome_js_parser::parse_js_with_cache(text, file_source, options, cache);
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index 2e7f284fb7a9..f0574d54b2bc 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -119,15 +119,49 @@ impl From<JsonAssistConfiguration> for JsonAssistSettings {
 impl ServiceLanguage for JsonLanguage {
     type FormatterSettings = JsonFormatterSettings;
     type LinterSettings = JsonLinterSettings;
+    type AssistSettings = JsonAssistSettings;
     type FormatOptions = JsonFormatOptions;
     type ParserSettings = JsonParserSettings;
-    type AssistSettings = JsonAssistSettings;
+    type ParserOptions = JsonParserOptions;
     type EnvironmentSettings = ();
 
     fn lookup_settings(language: &LanguageListSettings) -> &LanguageSettings<Self> {
         &language.json
     }
 
+    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
+        None
+    }
+
+    fn resolve_parse_options(
+        overrides: &OverrideSettings,
+        language: &Self::ParserSettings,
+        path: &BiomePath,
+        file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions {
+        if path.ends_with(ConfigName::biome_jsonc()) {
+            JsonParserOptions::default()
+                .with_allow_comments()
+                .with_allow_trailing_commas()
+        } else {
+            let optional_json_file_source = file_source.to_json_file_source();
+            let mut options = JsonParserOptions {
+                allow_comments: language.allow_comments.map_or_else(
+                    || optional_json_file_source.is_some_and(|x| x.allow_comments()),
+                    |value| value.value(),
+                ),
+                allow_trailing_commas: language.allow_trailing_commas.map_or_else(
+                    || optional_json_file_source.is_some_and(|x| x.allow_trailing_commas()),
+                    |value| value.value(),
+                ),
+            };
+
+            overrides.apply_override_json_parser_options(path, &mut options);
+
+            options
+        }
+    }
+
     fn resolve_format_options(
         global: &FormatSettings,
         overrides: &OverrideSettings,
@@ -208,7 +242,7 @@ impl ServiceLanguage for JsonLanguage {
             .with_suppression_reason(suppression_reason)
     }
 
-    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -217,8 +251,8 @@ impl ServiceLanguage for JsonLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.json.formatter.enabled,
-                        pattern.formatter.enabled,
+                        pattern.languages.json.linter.enabled,
+                        pattern.linter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -228,14 +262,14 @@ impl ServiceLanguage for JsonLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.json.formatter.enabled,
-                settings.formatter.enabled,
+                settings.languages.json.linter.enabled,
+                settings.linter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn formatter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -244,8 +278,8 @@ impl ServiceLanguage for JsonLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.json.assist.enabled,
-                        pattern.assist.enabled,
+                        pattern.languages.json.formatter.enabled,
+                        pattern.formatter.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -255,14 +289,14 @@ impl ServiceLanguage for JsonLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.json.assist.enabled,
-                settings.assist.enabled,
+                settings.languages.json.formatter.enabled,
+                settings.formatter.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
 
-    fn linter_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
+    fn assist_enabled_for_file_path(settings: &Settings, path: &Utf8Path) -> bool {
         let overrides_activity =
             settings
                 .override_settings
@@ -271,8 +305,8 @@ impl ServiceLanguage for JsonLanguage {
                 .rev()
                 .find_map(|pattern| {
                     check_override_feature_activity(
-                        pattern.languages.json.linter.enabled,
-                        pattern.linter.enabled,
+                        pattern.languages.json.assist.enabled,
+                        pattern.assist.enabled,
                     )
                     .filter(|_| {
                         // Then check whether the path satisfies
@@ -282,16 +316,12 @@ impl ServiceLanguage for JsonLanguage {
 
         overrides_activity
             .or(check_feature_activity(
-                settings.languages.json.linter.enabled,
-                settings.linter.enabled,
+                settings.languages.json.assist.enabled,
+                settings.assist.enabled,
             ))
             .unwrap_or_default()
             .into()
     }
-
-    fn resolve_environment(_settings: &Settings) -> Option<&Self::EnvironmentSettings> {
-        None
-    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]
@@ -325,6 +355,7 @@ impl ExtensionHandler for JsonFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             search: SearchCapabilities { search: None },
         }
@@ -354,29 +385,7 @@ fn parse(
     settings: &Settings,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    let options = if biome_path.ends_with(ConfigName::biome_jsonc()) {
-        JsonParserOptions::default()
-            .with_allow_comments()
-            .with_allow_trailing_commas()
-    } else {
-        let parser = &settings.languages.json.parser;
-        let overrides = &settings.override_settings;
-        let optional_json_file_source = file_source.to_json_file_source();
-        let mut options = JsonParserOptions {
-            allow_comments: parser.allow_comments.map_or_else(
-                || optional_json_file_source.is_some_and(|x| x.allow_comments()),
-                |value| value.value(),
-            ),
-            allow_trailing_commas: parser.allow_trailing_commas.map_or_else(
-                || optional_json_file_source.is_some_and(|x| x.allow_trailing_commas()),
-                |value| value.value(),
-            ),
-        };
-
-        overrides.apply_override_json_parser_options(biome_path, &mut options);
-
-        options
-    };
+    let options = settings.parse_options::<JsonLanguage>(biome_path, &file_source);
 
     let parse = biome_json_parser::parse_json_with_cache(text, cache, options);
 
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index d1ecc423b944..44ba03543255 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -11,6 +11,7 @@ pub use crate::file_handlers::vue::{VUE_FENCE, VueFileHandler};
 use crate::settings::Settings;
 use crate::workspace::{
     FixFileMode, FixFileResult, GetSyntaxTreeResult, PullActionsResult, RenameResult,
+    SendEmbeddedParse,
 };
 use biome_analyze::{
     AnalyzerDiagnostic, AnalyzerOptions, AnalyzerPluginVec, AnalyzerSignal, ControlFlow,
@@ -655,6 +656,20 @@ type FormatOnType = fn(
     TextSize,
 ) -> Result<Printed, WorkspaceError>;
 
+type FormatEmbedded = fn(
+    &BiomePath,
+    &DocumentFileSource,
+    AnyParse,
+    &Settings,
+    Vec<FormatEmbedNode>,
+) -> Result<Printed, WorkspaceError>;
+
+pub(crate) struct FormatEmbedNode {
+    pub(crate) range: TextRange,
+    pub(crate) node: SendEmbeddedParse,
+    pub(crate) source: DocumentFileSource,
+}
+
 #[derive(Default)]
 pub(crate) struct FormatterCapabilities {
     /// It formats a file
@@ -663,6 +678,8 @@ pub(crate) struct FormatterCapabilities {
     pub(crate) format_range: Option<FormatRange>,
     /// It formats a file while typing
     pub(crate) format_on_type: Option<FormatOnType>,
+    /// It formats a file with embedded nodes
+    pub(crate) format_embedded: Option<FormatEmbedded>,
 }
 
 type Enabled = fn(&Utf8Path, &Settings) -> bool;
diff --git a/crates/biome_service/src/file_handlers/svelte.rs b/crates/biome_service/src/file_handlers/svelte.rs
index 9bf3ee0dade6..1350b74c3ea0 100644
--- a/crates/biome_service/src/file_handlers/svelte.rs
+++ b/crates/biome_service/src/file_handlers/svelte.rs
@@ -108,6 +108,7 @@ impl ExtensionHandler for SvelteFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             // TODO: We should be able to search JS portions already
             search: SearchCapabilities { search: None },
diff --git a/crates/biome_service/src/file_handlers/vue.rs b/crates/biome_service/src/file_handlers/vue.rs
index efb327dae747..91354ff00085 100644
--- a/crates/biome_service/src/file_handlers/vue.rs
+++ b/crates/biome_service/src/file_handlers/vue.rs
@@ -108,6 +108,7 @@ impl ExtensionHandler for VueFileHandler {
                 format: Some(format),
                 format_range: Some(format_range),
                 format_on_type: Some(format_on_type),
+                format_embedded: None,
             },
             // TODO: We should be able to search JS portions already
             search: SearchCapabilities { search: None },
diff --git a/crates/biome_service/src/settings.rs b/crates/biome_service/src/settings.rs
index 4c07b9750fb3..7e2df058ae46 100644
--- a/crates/biome_service/src/settings.rs
+++ b/crates/biome_service/src/settings.rs
@@ -32,6 +32,7 @@ use biome_graphql_syntax::GraphqlLanguage;
 use biome_grit_formatter::context::GritFormatOptions;
 use biome_grit_syntax::GritLanguage;
 use biome_html_formatter::HtmlFormatOptions;
+use biome_html_parser::HtmlParseOptions;
 use biome_html_syntax::HtmlLanguage;
 use biome_js_formatter::context::JsFormatOptions;
 use biome_js_parser::JsParserOptions;
@@ -615,6 +616,8 @@ pub trait ServiceLanguage: biome_rowan::Language {
     /// Settings that belong to the parser
     type ParserSettings: Default;
 
+    type ParserOptions: Default;
+
     /// Settings related to the environment/runtime in which the language is used.
     type EnvironmentSettings: Default;
 
@@ -624,6 +627,14 @@ pub trait ServiceLanguage: biome_rowan::Language {
     /// Retrieve the environment settings of the current language
     fn resolve_environment(settings: &Settings) -> Option<&Self::EnvironmentSettings>;
 
+    /// Retrieve the parser options that belong to this language
+    fn resolve_parse_options(
+        overrides: &OverrideSettings,
+        language: &Self::ParserSettings,
+        path: &BiomePath,
+        file_source: &DocumentFileSource,
+    ) -> Self::ParserOptions;
+
     /// Resolve the formatter options from the global (workspace level),
     /// per-language and editor provided formatter settings
     fn resolve_format_options(
@@ -1061,6 +1072,19 @@ impl Settings {
         L::resolve_format_options(formatter, overrides, editor_settings, path, file_source)
     }
 
+    pub fn parse_options<L>(
+        &self,
+        path: &BiomePath,
+        file_source: &DocumentFileSource,
+    ) -> L::ParserOptions
+    where
+        L: ServiceLanguage,
+    {
+        let overrides = &self.override_settings;
+        let editor_settings = &L::lookup_settings(&self.languages).parser;
+        L::resolve_parse_options(overrides, editor_settings, path, file_source)
+    }
+
     pub fn analyzer_options<L>(
         &self,
         path: &BiomePath,
@@ -1227,6 +1251,18 @@ impl OverrideSettings {
         }
     }
 
+    pub(crate) fn apply_override_html_parser_options(
+        &self,
+        path: &Utf8Path,
+        options: &mut HtmlParseOptions,
+    ) {
+        for pattern in self.patterns.iter() {
+            if pattern.is_file_included(path) {
+                pattern.apply_overrides_to_html_parser_options(options);
+            }
+        }
+    }
+
     /// Scans the override rules and returns the parser options of the first matching override.
     pub fn apply_override_css_parser_options(
         &self,
@@ -1596,6 +1632,14 @@ impl OverrideSettingPattern {
         }
     }
 
+    fn apply_overrides_to_html_parser_options(&self, options: &mut HtmlParseOptions) {
+        let html_parser = &self.languages.html.parser;
+
+        if let Some(interpolation) = html_parser.interpolation {
+            options.set_double_text_expression(interpolation.value());
+        }
+    }
+
     fn apply_overrides_to_css_parser_options(&self, options: &mut CssParserOptions) {
         let css_parser = &self.languages.css.parser;
 
diff --git a/crates/biome_service/src/workspace.rs b/crates/biome_service/src/workspace.rs
index 0d31a56a6349..0bfc78e2d25d 100644
--- a/crates/biome_service/src/workspace.rs
+++ b/crates/biome_service/src/workspace.rs
@@ -55,6 +55,7 @@ mod client;
 mod document;
 mod server;
 
+pub use document::{EmbeddedCssContent, EmbeddedJsContent, SendEmbeddedParse};
 use std::{
     borrow::Cow,
     fmt::{Debug, Display, Formatter},
@@ -97,7 +98,6 @@ pub use crate::{
 };
 
 pub use client::{TransportRequest, WorkspaceClient, WorkspaceTransport};
-pub use document::{EmbeddedCssContent, EmbeddedJsContent};
 pub use server::OpenFileReason;
 
 /// Notification regarding a workspace's service data.
diff --git a/crates/biome_service/src/workspace/document.rs b/crates/biome_service/src/workspace/document.rs
index 1cf82332c687..d07cf6c0c7ff 100644
--- a/crates/biome_service/src/workspace/document.rs
+++ b/crates/biome_service/src/workspace/document.rs
@@ -1,4 +1,5 @@
 use biome_css_parser::CssOffsetParse;
+use biome_css_syntax::CssLanguage;
 use biome_js_parser::JsOffsetParse;
 use biome_js_syntax::JsLanguage;
 use biome_parser::AnyParse;
@@ -8,13 +9,13 @@ use biome_rowan::{EmbeddedSendNode, SyntaxNodeWithOffset, TextRange, TextSize};
 use crate::diagnostics::FileTooLarge;
 
 #[derive(Clone, Debug)]
-pub struct SendJsEmbeddedParse {
+pub struct SendEmbeddedParse {
     pub(crate) root: EmbeddedSendNode,
     #[expect(unused)]
     pub(crate) diagnostics: Vec<ParseDiagnostic>,
 }
 
-impl From<JsOffsetParse> for SendJsEmbeddedParse {
+impl From<JsOffsetParse> for SendEmbeddedParse {
     fn from(value: JsOffsetParse) -> Self {
         Self {
             root: value.syntax().clone().as_embedded_send(),
@@ -23,6 +24,15 @@ impl From<JsOffsetParse> for SendJsEmbeddedParse {
     }
 }
 
+impl From<CssOffsetParse> for SendEmbeddedParse {
+    fn from(value: CssOffsetParse) -> Self {
+        Self {
+            root: value.syntax().clone().as_embedded_send(),
+            diagnostics: value.into_diagnostics(),
+        }
+    }
+}
+
 /// Represents embedded JavaScript content extracted from HTML documents.
 ///
 /// This struct stores parsing metadata and provides access to the parsed content
@@ -30,7 +40,7 @@ impl From<JsOffsetParse> for SendJsEmbeddedParse {
 #[derive(Clone, Debug)]
 pub struct EmbeddedJsContent {
     /// The JavaScript source code extracted from the script element.
-    pub parse: SendJsEmbeddedParse,
+    pub parse: SendEmbeddedParse,
 
     /// The range of the entire script element in the HTML document,
     /// including the opening and closing tags.
@@ -43,6 +53,9 @@ pub struct EmbeddedJsContent {
     /// The offset where the JavaScript content starts in the parent document.
     /// This is used for offset-aware parsing.
     pub content_offset: TextSize,
+
+    /// The file source of the document
+    pub file_source_index: usize,
 }
 
 impl EmbeddedJsContent {
@@ -52,26 +65,10 @@ impl EmbeddedJsContent {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct SendCssEmbeddedParse {
-    pub(crate) root: EmbeddedSendNode,
-    #[expect(unused)]
-    pub(crate) diagnostics: Vec<ParseDiagnostic>,
-}
-
 impl EmbeddedCssContent {
     /// Returns a syntax node
-    pub fn node(&self) -> SyntaxNodeWithOffset<JsLanguage> {
-        self.parse.root.clone().into_node::<JsLanguage>()
-    }
-}
-
-impl From<CssOffsetParse> for SendCssEmbeddedParse {
-    fn from(value: CssOffsetParse) -> Self {
-        Self {
-            root: value.syntax().clone().as_embedded_send(),
-            diagnostics: value.into_diagnostics(),
-        }
+    pub fn node(&self) -> SyntaxNodeWithOffset<CssLanguage> {
+        self.parse.root.clone().into_node::<CssLanguage>()
     }
 }
 
@@ -82,7 +79,7 @@ impl From<CssOffsetParse> for SendCssEmbeddedParse {
 #[derive(Clone, Debug)]
 pub struct EmbeddedCssContent {
     /// The CSS source code extracted from the style element.
-    pub parse: SendCssEmbeddedParse,
+    pub parse: SendEmbeddedParse,
 
     /// The range of the entire style element in the HTML document,
     /// including the opening and closing tags.
@@ -95,6 +92,9 @@ pub struct EmbeddedCssContent {
     /// The offset where the CSS content starts in the parent document.
     /// This is used for offset-aware parsing.
     pub content_offset: TextSize,
+
+    /// The file source of the embedded document
+    pub file_source_index: usize,
 }
 
 #[derive(Clone, Debug)]
@@ -119,19 +119,17 @@ pub(crate) struct Document {
     /// The result of the parser (syntax tree + diagnostics).
     /// Types explained:
     /// - `Option`: if the file can be read
-    /// - `Result`: if the file is read, but the  file is too large
+    /// - `Result`: if the file is read, but the file is too large
     /// - `AnyParse`: the result of the parsed file
     pub(crate) syntax: Option<Result<AnyParse, FileTooLarge>>,
 
     /// Embedded JavaScript content found in HTML documents (script tags).
     /// Each entry contains the parsed JavaScript with offset-aware positioning
     /// relative to the parent HTML document.
-    // FIXME: remove underscore once we start reading the field
-    pub(crate) _embedded_scripts: Vec<EmbeddedJsContent>,
+    pub(crate) embedded_scripts: Vec<EmbeddedJsContent>,
 
     /// Embedded CSS content found in HTML documents (style tags).
     /// Each entry contains the parsed CSS with offset-aware positioning
     /// relative to the parent HTML document
-    // FIXME: remove underscore once we start reading the field
-    pub(crate) _embedded_styles: Vec<EmbeddedCssContent>,
+    pub(crate) embedded_styles: Vec<EmbeddedCssContent>,
 }
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
index a8ae2b6a74f9..95c7dd929f0b 100644
--- a/crates/biome_service/src/workspace/server.rs
+++ b/crates/biome_service/src/workspace/server.rs
@@ -2,12 +2,25 @@ use std::panic::RefUnwindSafe;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 
+use crate::Watcher;
+use crate::configuration::{LoadedConfiguration, read_config};
+use crate::diagnostics::{FileTooLarge, NoIgnoreFileFound, VcsDiagnostic};
+use crate::file_handlers::{
+    Capabilities, CodeActionsParams, DocumentFileSource, Features, FixAllParams, FormatEmbedNode,
+    LintParams, ParseResult,
+};
+use crate::projects::Projects;
+use crate::scanner::{
+    IndexRequestKind, IndexTrigger, ScanOptions, Scanner, ScannerWatcherBridge, WatcherInstruction,
+    WorkspaceScannerBridge,
+};
 use append_only_vec::AppendOnlyVec;
 use biome_analyze::{AnalyzerPluginVec, RuleCategory};
 use biome_configuration::bool::Bool;
 use biome_configuration::plugins::{PluginConfiguration, Plugins};
 use biome_configuration::vcs::VcsClientKind;
 use biome_configuration::{BiomeDiagnostic, Configuration, ConfigurationPathHint};
+use biome_css_syntax::{CssFileSource, CssLanguage};
 use biome_deserialize::json::deserialize_from_json_str;
 use biome_deserialize::{Deserialized, Merge};
 use biome_diagnostics::print_diagnostic_to_string;
@@ -17,7 +30,8 @@ use biome_diagnostics::{
 use biome_formatter::Printed;
 use biome_fs::{BiomePath, ConfigName, PathKind};
 use biome_grit_patterns::{CompilePatternOptions, GritQuery, compile_pattern_with_options};
-use biome_js_syntax::{AnyJsRoot, LanguageVariant, ModuleKind};
+use biome_html_syntax::HtmlRoot;
+use biome_js_syntax::{AnyJsRoot, JsFileSource, JsLanguage, LanguageVariant, ModuleKind};
 use biome_json_parser::JsonParserOptions;
 use biome_json_syntax::JsonFileSource;
 use biome_module_graph::{ModuleDependencies, ModuleDiagnostic, ModuleGraph};
@@ -31,23 +45,10 @@ use camino::{Utf8Path, Utf8PathBuf};
 use crossbeam::channel::Sender;
 use papaya::HashMap;
 use rustc_hash::{FxBuildHasher, FxHashMap};
+use std::time::Duration;
 use tokio::sync::watch;
 use tracing::{info, instrument, warn};
 
-use crate::Watcher;
-use crate::configuration::{LoadedConfiguration, read_config};
-use crate::diagnostics::{FileTooLarge, NoIgnoreFileFound, VcsDiagnostic};
-use crate::file_handlers::html::{extract_embedded_scripts, parse_embedded_styles};
-use crate::file_handlers::{
-    Capabilities, CodeActionsParams, DocumentFileSource, Features, FixAllParams, LintParams,
-    ParseResult,
-};
-use crate::projects::Projects;
-use crate::scanner::{
-    IndexRequestKind, IndexTrigger, ScanOptions, Scanner, ScannerWatcherBridge, WatcherInstruction,
-    WorkspaceScannerBridge,
-};
-
 use super::{document::Document, *};
 
 pub struct WorkspaceServer {
@@ -368,8 +369,22 @@ impl WorkspaceServer {
             && let Some(html_root) = biome_html_syntax::HtmlRoot::cast(any_parse.syntax())
         {
             let mut node_cache = NodeCache::default();
-            let scripts = extract_embedded_scripts(&html_root, &mut node_cache);
-            let styles = parse_embedded_styles(&html_root, &mut node_cache);
+            let scripts = self.parse_embedded_scripts(
+                project_key,
+                &biome_path,
+                &source,
+                &html_root,
+                &mut node_cache,
+                |file_source| self.insert_source(file_source.into()),
+            )?;
+            let styles = self.parse_embedded_styles(
+                project_key,
+                &biome_path,
+                &source,
+                &html_root,
+                &mut node_cache,
+                |file_source| self.insert_source(file_source.into()),
+            )?;
             (scripts, styles)
         } else {
             (Vec::new(), Vec::new())
@@ -413,8 +428,8 @@ impl WorkspaceServer {
                         version,
                         file_source_index,
                         syntax: syntax.clone(),
-                        _embedded_scripts: embedded_scripts.clone(),
-                        _embedded_styles: embedded_styles.clone(),
+                        embedded_scripts: embedded_scripts.clone(),
+                        embedded_styles: embedded_styles.clone(),
                     }
                 },
                 || Document {
@@ -422,8 +437,8 @@ impl WorkspaceServer {
                     version,
                     file_source_index,
                     syntax: syntax.clone(),
-                    _embedded_scripts: embedded_scripts.clone(),
-                    _embedded_styles: embedded_styles.clone(),
+                    embedded_scripts: embedded_scripts.clone(),
+                    embedded_styles: embedded_styles.clone(),
                 },
             );
 
@@ -465,6 +480,124 @@ impl WorkspaceServer {
         }
     }
 
+    fn get_embedded_parse(&self, path: &Utf8Path) -> Vec<FormatEmbedNode> {
+        let documents = self.documents.pin();
+
+        documents
+            .get(path)
+            .map(|doc| {
+                doc.embedded_scripts
+                    .clone()
+                    .iter()
+                    .map(|node| {
+                        let text_range = node.content_range;
+                        let parse = node.parse.clone();
+                        let file_source = self
+                            .get_source(node.file_source_index)
+                            .expect("Document source must exist");
+
+                        FormatEmbedNode {
+                            range: text_range,
+                            source: file_source,
+                            node: parse,
+                        }
+                    })
+                    .chain(doc.embedded_styles.clone().iter().map(|node| {
+                        let text_range = node.content_range;
+                        let parse = node.parse.clone();
+                        let file_source = self
+                            .get_source(node.file_source_index)
+                            .expect("Document source must exist");
+
+                        FormatEmbedNode {
+                            range: text_range,
+                            source: file_source,
+                            node: parse,
+                        }
+                    }))
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Extracts embedded JavaScript content from HTML script elements.
+    ///
+    /// This function walks the HTML syntax tree to find all `<script>` elements
+    /// and extracts their content for offset-aware JavaScript parsing.
+    ///
+    /// # Returns
+    /// A vector of `EmbeddedJsContent` containing parsed JavaScript with correct offsets
+    fn parse_embedded_scripts<F>(
+        &self,
+        project_key: ProjectKey,
+        path: &BiomePath,
+        source: &DocumentFileSource,
+        html_root: &HtmlRoot,
+        cache: &mut NodeCache,
+        source_index_fn: F,
+    ) -> Result<Vec<EmbeddedJsContent>, WorkspaceError>
+    where
+        F: Fn(JsFileSource) -> usize,
+    {
+        let mut scripts = Vec::new();
+        let settings = self
+            .projects
+            .get_settings_based_on_path(project_key, path)
+            .ok_or_else(WorkspaceError::no_project)?;
+        let options = settings.parse_options::<JsLanguage>(path, source);
+
+        // Walk through all HTML elements looking for script tags
+        for element in html_root.syntax().descendants() {
+            let result = crate::file_handlers::html::extract_embedded_script(
+                element.clone(),
+                cache,
+                options.clone(),
+                &source_index_fn,
+            );
+            let Some(list) = result else {
+                continue;
+            };
+            scripts.extend(list);
+        }
+        Ok(scripts)
+    }
+
+    /// Extracts embedded CSS content from HTML style elements.
+    fn parse_embedded_styles<F>(
+        &self,
+        project_key: ProjectKey,
+        path: &BiomePath,
+        source: &DocumentFileSource,
+        html_root: &HtmlRoot,
+        cache: &mut NodeCache,
+        source_index_fn: F,
+    ) -> Result<Vec<EmbeddedCssContent>, WorkspaceError>
+    where
+        F: Fn(CssFileSource) -> usize,
+    {
+        let mut styles = Vec::new();
+        let settings = self
+            .projects
+            .get_settings_based_on_path(project_key, path)
+            .ok_or_else(WorkspaceError::no_project)?;
+        let options = settings.parse_options::<CssLanguage>(path, source);
+
+        // Walk through all HTML elements looking for style tags
+        for element in html_root.syntax().descendants() {
+            let Some(list) = crate::file_handlers::html::parse_embedded_style(
+                element.clone(),
+                cache,
+                options,
+                &source_index_fn,
+            ) else {
+                continue;
+            };
+            styles.extend(list);
+        }
+
+        Ok(styles)
+    }
+
     fn parse(
         &self,
         project_key: ProjectKey,
@@ -1194,8 +1327,22 @@ impl Workspace for WorkspaceServer {
                 biome_html_syntax::HtmlRoot::cast(parsed.any_parse.syntax().clone())
         {
             let mut embedded_node_cache = NodeCache::default();
-            let scripts = extract_embedded_scripts(&html_root, &mut embedded_node_cache);
-            let styles = parse_embedded_styles(&html_root, &mut embedded_node_cache);
+            let scripts = self.parse_embedded_scripts(
+                project_key,
+                &path,
+                &file_source,
+                &html_root,
+                &mut embedded_node_cache,
+                |file_source| self.insert_source(file_source.into()),
+            )?;
+            let styles = self.parse_embedded_styles(
+                project_key,
+                &path,
+                &file_source,
+                &html_root,
+                &mut embedded_node_cache,
+                |file_source| self.insert_source(file_source.into()),
+            )?;
             (scripts, styles)
         } else {
             (Vec::new(), Vec::new())
@@ -1206,8 +1353,8 @@ impl Workspace for WorkspaceServer {
             version: Some(version),
             file_source_index: index,
             syntax: Some(Ok(parsed.any_parse)),
-            _embedded_scripts: embedded_scripts,
-            _embedded_styles: embedded_styles,
+            embedded_scripts,
+            embedded_styles,
         };
 
         if persist_node_cache {
@@ -1418,12 +1565,16 @@ impl Workspace for WorkspaceServer {
             .formatter
             .format
             .ok_or_else(self.build_capability_error(&params.path))?;
+
+        let format_embedded = capabilities.formatter.format_embedded;
+
         let settings = self
             .projects
             .get_settings_based_on_path(params.project_key, &params.path)
             .ok_or_else(WorkspaceError::no_project)?;
 
         let parse = self.get_parse(&params.path)?;
+        let embedded_nodes = self.get_embedded_parse(&params.path);
 
         if !settings.format_with_errors_enabled_for_this_file_path(&params.path)
             && parse.has_errors()
@@ -1431,6 +1582,17 @@ impl Workspace for WorkspaceServer {
             return Err(WorkspaceError::format_with_errors_disabled());
         }
         let document_file_source = self.get_file_source(&params.path);
+        if !embedded_nodes.is_empty() {
+            let format_embedded =
+                format_embedded.ok_or_else(self.build_capability_error(&params.path))?;
+            return format_embedded(
+                &params.path,
+                &document_file_source,
+                parse,
+                &settings,
+                embedded_nodes,
+            );
+        }
         format(&params.path, &document_file_source, parse, &settings)
     }
 
diff --git a/crates/biome_service/src/workspace/server.tests.rs b/crates/biome_service/src/workspace/server.tests.rs
index 1be74d379e9c..cc5c3ae2a40d 100644
--- a/crates/biome_service/src/workspace/server.tests.rs
+++ b/crates/biome_service/src/workspace/server.tests.rs
@@ -99,11 +99,11 @@ fn store_embedded_nodes_with_current_ranges() {
     assert!(document.is_some());
 
     let document = document.unwrap();
-    assert_eq!(document._embedded_scripts.len(), 1);
-    assert_eq!(document._embedded_styles.len(), 1);
+    assert_eq!(document.embedded_scripts.len(), 1);
+    assert_eq!(document.embedded_styles.len(), 1);
 
-    let script = document._embedded_scripts.first().unwrap();
-    let style = document._embedded_styles.first().unwrap();
+    let script = document.embedded_scripts.first().unwrap();
+    let style = document.embedded_styles.first().unwrap();
 
     let script_node = script.node();
     assert!(script_node.text_range_with_trivia().start() > TextSize::from(0));
@@ -112,6 +112,72 @@ fn store_embedded_nodes_with_current_ranges() {
     assert!(style_node.text_range_with_trivia().start() > TextSize::from(0));
 }
 
+#[test]
+fn format_html_with_scripts_and_css() {
+    const FILE_CONTENT: &str = r#"<html>
+    <head>
+        <style>
+            #id { background-color: red; }
+        </style>
+        <script>
+            const foo = "bar";
+            function bar() { const object = { ["literal"]: "SOME OTHER STRING" }; return 1; }
+        </script>
+    </head>
+</html>"#;
+
+    let fs = MemoryFileSystem::default();
+    fs.insert(Utf8PathBuf::from("/project/file.html"), FILE_CONTENT);
+
+    let (workspace, project_key) = setup_workspace_and_open_project(fs, "/");
+
+    workspace
+        .scan_project(ScanProjectParams {
+            project_key,
+            watch: false,
+            force: false,
+            scan_kind: ScanKind::Project,
+            verbose: false,
+        })
+        .unwrap();
+
+    workspace
+        .open_file(OpenFileParams {
+            project_key,
+            path: BiomePath::new("/project/file.html"),
+            content: FileContent::FromServer,
+            document_file_source: None,
+            persist_node_cache: false,
+        })
+        .unwrap();
+
+    let result = workspace
+        .format_file(FormatFileParams {
+            path: Utf8PathBuf::from("/project/file.html").into(),
+            project_key,
+        })
+        .unwrap();
+
+    insta::assert_snapshot!(result.as_code(), @r#"
+    <html>
+    	<head>
+    		<style>
+    		#id {
+    			background-color: red;
+    		}
+    		</style>
+    		<script>
+    		const foo = "bar";
+    		function bar() {
+    			const object = { ["literal"]: "SOME OTHER STRING" };
+    			return 1;
+    		}
+    		</script>
+    	</head>
+    </html>
+    "#);
+}
+
 #[test]
 fn jsx_everywhere_sets_correct_variant() {
     const TS_FILE_CONTENT: &[u8] = br"
diff --git a/crates/biome_service/src/workspace/snapshots/biome_service__workspace__server__tests__embedded_formatting_html.snap b/crates/biome_service/src/workspace/snapshots/biome_service__workspace__server__tests__embedded_formatting_html.snap
new file mode 100644
index 000000000000..50fc50430306
--- /dev/null
+++ b/crates/biome_service/src/workspace/snapshots/biome_service__workspace__server__tests__embedded_formatting_html.snap
@@ -0,0 +1,18 @@
+---
+source: crates/biome_service/src/workspace/server.tests.rs
+expression: result.as_code()
+---
+<html>
+	<head>
+		<style>
+			.#id {}
+		</style>
+		<script>
+			const foo = "bar";
+			function bar() {
+				const object = { ["literal"]: "SOME OTHER STRING" };
+				return 1;
+			}
+		</script>
+	</head>
+</html>
diff --git a/xtask/codegen/html.ungram b/xtask/codegen/html.ungram
index 92113baabfb1..ea7aa639c584 100644
--- a/xtask/codegen/html.ungram
+++ b/xtask/codegen/html.ungram
@@ -76,6 +76,7 @@ AnyHtmlElement =
 
 AnyHtmlContent =
 	HtmlContent
+	| HtmlEmbeddedContent
 	| AnyHtmlTextExpression
 
 AnyHtmlTextExpression =
@@ -181,3 +182,4 @@ HtmlString = value: 'html_string_literal'
 HtmlTagName = value: 'html_literal'
 HtmlAttributeName = value: 'html_literal'
 HtmlContent = value: 'html_literal'
+HtmlEmbeddedContent = value: 'html_literal'
diff --git a/xtask/codegen/src/html_kinds_src.rs b/xtask/codegen/src/html_kinds_src.rs
index b88e0465ea4b..e0b58e645352 100644
--- a/xtask/codegen/src/html_kinds_src.rs
+++ b/xtask/codegen/src/html_kinds_src.rs
@@ -42,6 +42,7 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "HTML_ELEMENT_LIST",
         "HTML_ATTRIBUTE_LIST",
         "HTML_CONTENT",
+        "HTML_EMBEDDED_CONTENT",
         "HTML_CDATA_SECTION",
         "COMMENT",
         "HTML_DOUBLE_TEXT_EXPRESSION",