diff --git a/.changeset/glimmer-template-support.md b/.changeset/glimmer-template-support.md
new file mode 100644
index 000000000000..d8a8d8214bfc
--- /dev/null
+++ b/.changeset/glimmer-template-support.md
@@ -0,0 +1,20 @@
+---
+"@biomejs/biome": minor
+---
+
+Added support for Glimmer template files (`.gjs` and `.gts`). Biome can now parse, format, and lint Glimmer Component files used in Ember.js applications.
+
+Glimmer templates are recognized using the `<template>...</template>` syntax and can appear in:
+- Variable assignments: `const Tpl = <template>...</template>;`
+- Class bodies: `class C { <template>...</template> }`
+- Expression contexts
+- Single unassigned templates (treated as default exports)
+
+**Phase 1 Implementation Notes:**
+- Template content is treated as **opaque tokens** - the content is preserved exactly as written without internal parsing or linting
+- The template syntax itself is validated (e.g., checking for unclosed tags)
+- Templates work with whitespace in the opening tag (e.g., `<template >`, `<template\n>`)
+- LSP language IDs "gjs" and "gts" are now recognized
+- Future phases will add internal template parsing and linting support
+
+The template content is preserved as-is during formatting, and the parser provides diagnostics for unclosed template tags.
diff --git a/crates/biome_grit_patterns/src/grit_js_parser.rs b/crates/biome_grit_patterns/src/grit_js_parser.rs
index dfe97eabf627..1689ee5efe98 100644
--- a/crates/biome_grit_patterns/src/grit_js_parser.rs
+++ b/crates/biome_grit_patterns/src/grit_js_parser.rs
@@ -2,7 +2,7 @@ use crate::{
     grit_analysis_ext::GritAnalysisExt, grit_target_language::GritTargetParser,
     grit_tree::GritTargetTree,
 };
-use biome_js_parser::{JsParserOptions, parse};
+use biome_js_parser::{JsParserOptions, parse, parse_with_options};
 use biome_js_syntax::{JsFileSource, JsLanguage};
 use biome_parser::AnyParse;
 use camino::Utf8Path;
@@ -34,7 +34,7 @@ impl GritTargetParser for GritJsParser {
             _ => JsFileSource::ts(),
         };
 
-        parse(source, source_type, JsParserOptions::default()).into()
+        parse(source, source_type).into()
     }
 }
 
@@ -48,7 +48,7 @@ impl Parser for GritJsParser {
         logs: &mut AnalysisLogs,
         _old_tree: FileOrigin<'_, GritTargetTree>,
     ) -> Option<GritTargetTree> {
-        let parse_result = parse(
+        let parse_result = parse_with_options(
             body,
             JsFileSource::tsx(),
             JsParserOptions::default().with_metavariables(),
@@ -75,7 +75,7 @@ impl Parser for GritJsParser {
             |src: &str| src.len() as u32
         };
 
-        let parse_result = parse(
+        let parse_result = parse_with_options(
             &context,
             JsFileSource::tsx(),
             JsParserOptions::default().with_metavariables(),
diff --git a/crates/biome_grit_patterns/src/grit_target_language/js_target_language/generated_mappings.rs b/crates/biome_grit_patterns/src/grit_target_language/js_target_language/generated_mappings.rs
index 916e8ec2808a..9622e07b65f6 100644
--- a/crates/biome_grit_patterns/src/grit_target_language/js_target_language/generated_mappings.rs
+++ b/crates/biome_grit_patterns/src/grit_target_language/js_target_language/generated_mappings.rs
@@ -298,6 +298,7 @@ pub fn kind_by_name(node_name: &str) -> Option<JsSyntaxKind> {
         "JsFunctionExpression" => lang::JsFunctionExpression::KIND_SET.iter().next(),
         "JsGetterClassMember" => lang::JsGetterClassMember::KIND_SET.iter().next(),
         "JsGetterObjectMember" => lang::JsGetterObjectMember::KIND_SET.iter().next(),
+        "JsGlimmerTemplate" => lang::JsGlimmerTemplate::KIND_SET.iter().next(),
         "JsIdentifierAssignment" => lang::JsIdentifierAssignment::KIND_SET.iter().next(),
         "JsIdentifierBinding" => lang::JsIdentifierBinding::KIND_SET.iter().next(),
         "JsIdentifierExpression" => lang::JsIdentifierExpression::KIND_SET.iter().next(),
diff --git a/crates/biome_html_factory/src/generated/node_factory.rs b/crates/biome_html_factory/src/generated/node_factory.rs
index a0c6018a025a..e05dbe374ba4 100644
--- a/crates/biome_html_factory/src/generated/node_factory.rs
+++ b/crates/biome_html_factory/src/generated/node_factory.rs
@@ -40,6 +40,297 @@ pub fn astro_frontmatter_element(
         ],
     ))
 }
+pub fn glimmer_block_helper(
+    opening: GlimmerBlockHelperOpening,
+    children: HtmlElementList,
+    closing: GlimmerBlockHelperClosing,
+) -> GlimmerBlockHelper {
+    GlimmerBlockHelper::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BLOCK_HELPER,
+        [
+            Some(SyntaxElement::Node(opening.into_syntax())),
+            Some(SyntaxElement::Node(children.into_syntax())),
+            Some(SyntaxElement::Node(closing.into_syntax())),
+        ],
+    ))
+}
+pub fn glimmer_block_helper_closing(
+    l_curly2_token_token: SyntaxToken,
+    slash_token_token: SyntaxToken,
+    helper: GlimmerPath,
+    r_curly2_token_token: SyntaxToken,
+) -> GlimmerBlockHelperClosing {
+    GlimmerBlockHelperClosing::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BLOCK_HELPER_CLOSING,
+        [
+            Some(SyntaxElement::Token(l_curly2_token_token)),
+            Some(SyntaxElement::Token(slash_token_token)),
+            Some(SyntaxElement::Node(helper.into_syntax())),
+            Some(SyntaxElement::Token(r_curly2_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_block_helper_opening(
+    l_curly2_token_token: SyntaxToken,
+    hash_token_token: SyntaxToken,
+    helper: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_curly2_token_token: SyntaxToken,
+) -> GlimmerBlockHelperOpeningBuilder {
+    GlimmerBlockHelperOpeningBuilder {
+        l_curly2_token_token,
+        hash_token_token,
+        helper,
+        arguments,
+        r_curly2_token_token,
+        block_params: None,
+    }
+}
+pub struct GlimmerBlockHelperOpeningBuilder {
+    l_curly2_token_token: SyntaxToken,
+    hash_token_token: SyntaxToken,
+    helper: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_curly2_token_token: SyntaxToken,
+    block_params: Option<GlimmerBlockParams>,
+}
+impl GlimmerBlockHelperOpeningBuilder {
+    pub fn with_block_params(mut self, block_params: GlimmerBlockParams) -> Self {
+        self.block_params = Some(block_params);
+        self
+    }
+    pub fn build(self) -> GlimmerBlockHelperOpening {
+        GlimmerBlockHelperOpening::unwrap_cast(SyntaxNode::new_detached(
+            HtmlSyntaxKind::GLIMMER_BLOCK_HELPER_OPENING,
+            [
+                Some(SyntaxElement::Token(self.l_curly2_token_token)),
+                Some(SyntaxElement::Token(self.hash_token_token)),
+                Some(SyntaxElement::Node(self.helper.into_syntax())),
+                Some(SyntaxElement::Node(self.arguments.into_syntax())),
+                self.block_params
+                    .map(|token| SyntaxElement::Node(token.into_syntax())),
+                Some(SyntaxElement::Token(self.r_curly2_token_token)),
+            ],
+        ))
+    }
+}
+pub fn glimmer_block_param(name_token_token: SyntaxToken) -> GlimmerBlockParam {
+    GlimmerBlockParam::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BLOCK_PARAM,
+        [Some(SyntaxElement::Token(name_token_token))],
+    ))
+}
+pub fn glimmer_block_params(
+    as_token_token: SyntaxToken,
+    l_pipe_token_token: SyntaxToken,
+    params: GlimmerBlockParamList,
+    r_pipe_token_token: SyntaxToken,
+) -> GlimmerBlockParams {
+    GlimmerBlockParams::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BLOCK_PARAMS,
+        [
+            Some(SyntaxElement::Token(as_token_token)),
+            Some(SyntaxElement::Token(l_pipe_token_token)),
+            Some(SyntaxElement::Node(params.into_syntax())),
+            Some(SyntaxElement::Token(r_pipe_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_element_modifier(
+    l_curly2_token_token: SyntaxToken,
+    path: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_curly2_token_token: SyntaxToken,
+) -> GlimmerElementModifier {
+    GlimmerElementModifier::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_ELEMENT_MODIFIER,
+        [
+            Some(SyntaxElement::Token(l_curly2_token_token)),
+            Some(SyntaxElement::Node(path.into_syntax())),
+            Some(SyntaxElement::Node(arguments.into_syntax())),
+            Some(SyntaxElement::Token(r_curly2_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_literal(value_token_token: SyntaxToken) -> GlimmerLiteral {
+    GlimmerLiteral::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_LITERAL,
+        [Some(SyntaxElement::Token(value_token_token))],
+    ))
+}
+pub fn glimmer_mustache_comment(comment_token_token: SyntaxToken) -> GlimmerMustacheComment {
+    GlimmerMustacheComment::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_MUSTACHE_COMMENT,
+        [Some(SyntaxElement::Token(comment_token_token))],
+    ))
+}
+pub fn glimmer_mustache_expression(
+    l_curly2_token_token: SyntaxToken,
+    path: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_curly2_token_token: SyntaxToken,
+) -> GlimmerMustacheExpression {
+    GlimmerMustacheExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_MUSTACHE_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_curly2_token_token)),
+            Some(SyntaxElement::Node(path.into_syntax())),
+            Some(SyntaxElement::Node(arguments.into_syntax())),
+            Some(SyntaxElement::Token(r_curly2_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_named_argument(
+    name_token_token: SyntaxToken,
+    eq_token_token: SyntaxToken,
+    value: AnyGlimmerArgumentValue,
+) -> GlimmerNamedArgument {
+    GlimmerNamedArgument::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_NAMED_ARGUMENT,
+        [
+            Some(SyntaxElement::Token(name_token_token)),
+            Some(SyntaxElement::Token(eq_token_token)),
+            Some(SyntaxElement::Node(value.into_syntax())),
+        ],
+    ))
+}
+pub fn glimmer_named_block(
+    opening: GlimmerNamedBlockOpening,
+    children: HtmlElementList,
+    closing: GlimmerNamedBlockClosing,
+) -> GlimmerNamedBlock {
+    GlimmerNamedBlock::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_NAMED_BLOCK,
+        [
+            Some(SyntaxElement::Node(opening.into_syntax())),
+            Some(SyntaxElement::Node(children.into_syntax())),
+            Some(SyntaxElement::Node(closing.into_syntax())),
+        ],
+    ))
+}
+pub fn glimmer_named_block_closing(
+    l_angle_token_token: SyntaxToken,
+    slash_token_token: SyntaxToken,
+    colon_token_token: SyntaxToken,
+    name_token_token: SyntaxToken,
+    r_angle_token_token: SyntaxToken,
+) -> GlimmerNamedBlockClosing {
+    GlimmerNamedBlockClosing::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_NAMED_BLOCK_CLOSING,
+        [
+            Some(SyntaxElement::Token(l_angle_token_token)),
+            Some(SyntaxElement::Token(slash_token_token)),
+            Some(SyntaxElement::Token(colon_token_token)),
+            Some(SyntaxElement::Token(name_token_token)),
+            Some(SyntaxElement::Token(r_angle_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_named_block_opening(
+    l_angle_token_token: SyntaxToken,
+    colon_token_token: SyntaxToken,
+    name_token_token: SyntaxToken,
+    attributes: HtmlAttributeList,
+    r_angle_token_token: SyntaxToken,
+) -> GlimmerNamedBlockOpening {
+    GlimmerNamedBlockOpening::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_NAMED_BLOCK_OPENING,
+        [
+            Some(SyntaxElement::Token(l_angle_token_token)),
+            Some(SyntaxElement::Token(colon_token_token)),
+            Some(SyntaxElement::Token(name_token_token)),
+            Some(SyntaxElement::Node(attributes.into_syntax())),
+            Some(SyntaxElement::Token(r_angle_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_path(segments: GlimmerPathSegmentList) -> GlimmerPathBuilder {
+    GlimmerPathBuilder {
+        segments,
+        at_token_token: None,
+    }
+}
+pub struct GlimmerPathBuilder {
+    segments: GlimmerPathSegmentList,
+    at_token_token: Option<SyntaxToken>,
+}
+impl GlimmerPathBuilder {
+    pub fn with_at_token_token(mut self, at_token_token: SyntaxToken) -> Self {
+        self.at_token_token = Some(at_token_token);
+        self
+    }
+    pub fn build(self) -> GlimmerPath {
+        GlimmerPath::unwrap_cast(SyntaxNode::new_detached(
+            HtmlSyntaxKind::GLIMMER_PATH,
+            [
+                self.at_token_token.map(|token| SyntaxElement::Token(token)),
+                Some(SyntaxElement::Node(self.segments.into_syntax())),
+            ],
+        ))
+    }
+}
+pub fn glimmer_path_segment(value_token_token: SyntaxToken) -> GlimmerPathSegment {
+    GlimmerPathSegment::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_PATH_SEGMENT,
+        [Some(SyntaxElement::Token(value_token_token))],
+    ))
+}
+pub fn glimmer_positional_argument(value: AnyGlimmerArgumentValue) -> GlimmerPositionalArgument {
+    GlimmerPositionalArgument::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_POSITIONAL_ARGUMENT,
+        [Some(SyntaxElement::Node(value.into_syntax()))],
+    ))
+}
+pub fn glimmer_splattribute(
+    dotdotdot_token_token: SyntaxToken,
+    attributes_token_token: SyntaxToken,
+) -> GlimmerSplattribute {
+    GlimmerSplattribute::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_SPLATTRIBUTE,
+        [
+            Some(SyntaxElement::Token(dotdotdot_token_token)),
+            Some(SyntaxElement::Token(attributes_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_string_literal(value_token_token: SyntaxToken) -> GlimmerStringLiteral {
+    GlimmerStringLiteral::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_STRING_LITERAL,
+        [Some(SyntaxElement::Token(value_token_token))],
+    ))
+}
+pub fn glimmer_subexpression(
+    l_paren_token_token: SyntaxToken,
+    path: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_paren_token_token: SyntaxToken,
+) -> GlimmerSubexpression {
+    GlimmerSubexpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_SUBEXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_paren_token_token)),
+            Some(SyntaxElement::Node(path.into_syntax())),
+            Some(SyntaxElement::Node(arguments.into_syntax())),
+            Some(SyntaxElement::Token(r_paren_token_token)),
+        ],
+    ))
+}
+pub fn glimmer_triple_stash_expression(
+    l_curly3_token_token: SyntaxToken,
+    path: GlimmerPath,
+    arguments: GlimmerArgumentList,
+    r_curly3_token_token: SyntaxToken,
+) -> GlimmerTripleStashExpression {
+    GlimmerTripleStashExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_TRIPLE_STASH_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_curly3_token_token)),
+            Some(SyntaxElement::Node(path.into_syntax())),
+            Some(SyntaxElement::Node(arguments.into_syntax())),
+            Some(SyntaxElement::Token(r_curly3_token_token)),
+        ],
+    ))
+}
 pub fn html_attribute(name: HtmlAttributeName) -> HtmlAttributeBuilder {
     HtmlAttributeBuilder {
         name,
@@ -369,6 +660,51 @@ pub fn svelte_name(svelte_ident_token: SyntaxToken) -> SvelteName {
         [Some(SyntaxElement::Token(svelte_ident_token))],
     ))
 }
+pub fn glimmer_argument_list<I>(items: I) -> GlimmerArgumentList
+where
+    I: IntoIterator<Item = AnyGlimmerArgument>,
+    I::IntoIter: ExactSizeIterator,
+{
+    GlimmerArgumentList::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_ARGUMENT_LIST,
+        items
+            .into_iter()
+            .map(|item| Some(item.into_syntax().into())),
+    ))
+}
+pub fn glimmer_block_param_list<I>(items: I) -> GlimmerBlockParamList
+where
+    I: IntoIterator<Item = GlimmerBlockParam>,
+    I::IntoIter: ExactSizeIterator,
+{
+    GlimmerBlockParamList::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BLOCK_PARAM_LIST,
+        items
+            .into_iter()
+            .map(|item| Some(item.into_syntax().into())),
+    ))
+}
+pub fn glimmer_path_segment_list<I, S>(items: I, separators: S) -> GlimmerPathSegmentList
+where
+    I: IntoIterator<Item = GlimmerPathSegment>,
+    I::IntoIter: ExactSizeIterator,
+    S: IntoIterator<Item = HtmlSyntaxToken>,
+    S::IntoIter: ExactSizeIterator,
+{
+    let mut items = items.into_iter();
+    let mut separators = separators.into_iter();
+    let length = items.len() + separators.len();
+    GlimmerPathSegmentList::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_PATH_SEGMENT_LIST,
+        (0..length).map(|index| {
+            if index % 2 == 0 {
+                Some(items.next()?.into_syntax().into())
+            } else {
+                Some(separators.next()?.into())
+            }
+        }),
+    ))
+}
 pub fn html_attribute_list<I>(items: I) -> HtmlAttributeList
 where
     I: IntoIterator<Item = AnyHtmlAttribute>,
@@ -424,6 +760,16 @@ where
         slots,
     ))
 }
+pub fn glimmer_bogus_expression<I>(slots: I) -> GlimmerBogusExpression
+where
+    I: IntoIterator<Item = Option<SyntaxElement>>,
+    I::IntoIter: ExactSizeIterator,
+{
+    GlimmerBogusExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::GLIMMER_BOGUS_EXPRESSION,
+        slots,
+    ))
+}
 pub fn html_bogus<I>(slots: I) -> HtmlBogus
 where
     I: IntoIterator<Item = Option<SyntaxElement>>,
diff --git a/crates/biome_html_factory/src/generated/syntax_factory.rs b/crates/biome_html_factory/src/generated/syntax_factory.rs
index 6527c0d76455..5e6c2250c2d6 100644
--- a/crates/biome_html_factory/src/generated/syntax_factory.rs
+++ b/crates/biome_html_factory/src/generated/syntax_factory.rs
@@ -15,6 +15,7 @@ impl SyntaxFactory for HtmlSyntaxFactory {
     ) -> RawSyntaxNode<Self::Kind> {
         match kind {
             ASTRO_BOGUS_FRONTMATTER
+            | GLIMMER_BOGUS_EXPRESSION
             | HTML_BOGUS
             | HTML_BOGUS_ATTRIBUTE
             | HTML_BOGUS_ELEMENT
@@ -72,6 +73,659 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(ASTRO_FRONTMATTER_ELEMENT, children)
             }
+            GLIMMER_BLOCK_HELPER => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && GlimmerBlockHelperOpening::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && HtmlElementList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerBlockHelperClosing::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_BLOCK_HELPER.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_BLOCK_HELPER, children)
+            }
+            GLIMMER_BLOCK_HELPER_CLOSING => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["{{"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [/]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["}}"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_BLOCK_HELPER_CLOSING.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_BLOCK_HELPER_CLOSING, children)
+            }
+            GLIMMER_BLOCK_HELPER_OPENING => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<6usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["{{"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [#]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerArgumentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerBlockParams::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["}}"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_BLOCK_HELPER_OPENING.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_BLOCK_HELPER_OPENING, children)
+            }
+            GLIMMER_BLOCK_PARAM => {
+                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() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_BLOCK_PARAM.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_BLOCK_PARAM, children)
+            }
+            GLIMMER_BLOCK_PARAMS => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [|]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerBlockParamList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [|]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_BLOCK_PARAMS.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_BLOCK_PARAMS, children)
+            }
+            GLIMMER_ELEMENT_MODIFIER => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["{{"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerArgumentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["}}"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_ELEMENT_MODIFIER.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_ELEMENT_MODIFIER, children)
+            }
+            GLIMMER_LITERAL => {
+                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(
+                        GLIMMER_LITERAL.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_LITERAL, children)
+            }
+            GLIMMER_MUSTACHE_COMMENT => {
+                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() == MUSTACHE_COMMENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_MUSTACHE_COMMENT.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_MUSTACHE_COMMENT, children)
+            }
+            GLIMMER_MUSTACHE_EXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["{{"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerArgumentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["}}"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_MUSTACHE_EXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_MUSTACHE_EXPRESSION, children)
+            }
+            GLIMMER_NAMED_ARGUMENT => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [=]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && AnyGlimmerArgumentValue::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_NAMED_ARGUMENT.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_NAMED_ARGUMENT, children)
+            }
+            GLIMMER_NAMED_BLOCK => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && GlimmerNamedBlockOpening::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && HtmlElementList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerNamedBlockClosing::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_NAMED_BLOCK.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_NAMED_BLOCK, children)
+            }
+            GLIMMER_NAMED_BLOCK_CLOSING => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [<]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [/]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [:]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [>]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_NAMED_BLOCK_CLOSING.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_NAMED_BLOCK_CLOSING, children)
+            }
+            GLIMMER_NAMED_BLOCK_OPENING => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<5usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [<]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [:]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && HtmlAttributeList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [>]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_NAMED_BLOCK_OPENING.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_NAMED_BLOCK_OPENING, children)
+            }
+            GLIMMER_PATH => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [@]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPathSegmentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_PATH.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_PATH, children)
+            }
+            GLIMMER_PATH_SEGMENT => {
+                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() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_PATH_SEGMENT.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_PATH_SEGMENT, children)
+            }
+            GLIMMER_POSITIONAL_ARGUMENT => {
+                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
+                    && AnyGlimmerArgumentValue::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_POSITIONAL_ARGUMENT.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_POSITIONAL_ARGUMENT, children)
+            }
+            GLIMMER_SPLATTRIBUTE => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T ! [...]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == IDENT
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_SPLATTRIBUTE.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_SPLATTRIBUTE, children)
+            }
+            GLIMMER_STRING_LITERAL => {
+                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_STRING_LITERAL
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_STRING_LITERAL.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_STRING_LITERAL, children)
+            }
+            GLIMMER_SUBEXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!['(']
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerArgumentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T![')']
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_SUBEXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_SUBEXPRESSION, children)
+            }
+            GLIMMER_TRIPLE_STASH_EXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<4usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == L_TRIPLE_CURLY
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerPath::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && GlimmerArgumentList::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == R_TRIPLE_CURLY
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        GLIMMER_TRIPLE_STASH_EXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(GLIMMER_TRIPLE_STASH_EXPRESSION, children)
+            }
             HTML_ATTRIBUTE => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
@@ -671,6 +1325,19 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(SVELTE_NAME, children)
             }
+            GLIMMER_ARGUMENT_LIST => {
+                Self::make_node_list_syntax(kind, children, AnyGlimmerArgument::can_cast)
+            }
+            GLIMMER_BLOCK_PARAM_LIST => {
+                Self::make_node_list_syntax(kind, children, GlimmerBlockParam::can_cast)
+            }
+            GLIMMER_PATH_SEGMENT_LIST => Self::make_separated_list_syntax(
+                kind,
+                children,
+                GlimmerPathSegment::can_cast,
+                T ! [.],
+                false,
+            ),
             HTML_ATTRIBUTE_LIST => {
                 Self::make_node_list_syntax(kind, children, AnyHtmlAttribute::can_cast)
             }
diff --git a/crates/biome_html_formatter/src/generated.rs b/crates/biome_html_formatter/src/generated.rs
index 870a562cfa3b..1d11b38b6273 100644
--- a/crates/biome_html_formatter/src/generated.rs
+++ b/crates/biome_html_formatter/src/generated.rs
@@ -82,6 +82,758 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AstroFrontmatterElemen
         )
     }
 }
+impl FormatRule<biome_html_syntax::GlimmerBlockHelper>
+    for crate::js::auxiliary::block_helper::FormatGlimmerBlockHelper
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBlockHelper,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerBlockHelper>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelper {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockHelper,
+        crate::js::auxiliary::block_helper::FormatGlimmerBlockHelper,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper::FormatGlimmerBlockHelper::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelper {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockHelper,
+        crate::js::auxiliary::block_helper::FormatGlimmerBlockHelper,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper::FormatGlimmerBlockHelper::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerBlockHelperClosing>
+    for crate::js::auxiliary::block_helper_closing::FormatGlimmerBlockHelperClosing
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBlockHelperClosing,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerBlockHelperClosing>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelperClosing {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockHelperClosing,
+        crate::js::auxiliary::block_helper_closing::FormatGlimmerBlockHelperClosing,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper_closing::FormatGlimmerBlockHelperClosing::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelperClosing {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockHelperClosing,
+        crate::js::auxiliary::block_helper_closing::FormatGlimmerBlockHelperClosing,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper_closing::FormatGlimmerBlockHelperClosing::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerBlockHelperOpening>
+    for crate::js::auxiliary::block_helper_opening::FormatGlimmerBlockHelperOpening
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBlockHelperOpening,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerBlockHelperOpening>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelperOpening {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockHelperOpening,
+        crate::js::auxiliary::block_helper_opening::FormatGlimmerBlockHelperOpening,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper_opening::FormatGlimmerBlockHelperOpening::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockHelperOpening {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockHelperOpening,
+        crate::js::auxiliary::block_helper_opening::FormatGlimmerBlockHelperOpening,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::block_helper_opening::FormatGlimmerBlockHelperOpening::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerBlockParam>
+    for crate::js::auxiliary::block_param::FormatGlimmerBlockParam
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBlockParam,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerBlockParam>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParam {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockParam,
+        crate::js::auxiliary::block_param::FormatGlimmerBlockParam,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::block_param::FormatGlimmerBlockParam::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParam {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockParam,
+        crate::js::auxiliary::block_param::FormatGlimmerBlockParam,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::block_param::FormatGlimmerBlockParam::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerBlockParams>
+    for crate::js::auxiliary::block_params::FormatGlimmerBlockParams
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBlockParams,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerBlockParams>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParams {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockParams,
+        crate::js::auxiliary::block_params::FormatGlimmerBlockParams,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::block_params::FormatGlimmerBlockParams::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParams {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockParams,
+        crate::js::auxiliary::block_params::FormatGlimmerBlockParams,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::block_params::FormatGlimmerBlockParams::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerElementModifier>
+    for crate::js::auxiliary::element_modifier::FormatGlimmerElementModifier
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerElementModifier,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerElementModifier>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerElementModifier {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerElementModifier,
+        crate::js::auxiliary::element_modifier::FormatGlimmerElementModifier,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::element_modifier::FormatGlimmerElementModifier::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerElementModifier {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerElementModifier,
+        crate::js::auxiliary::element_modifier::FormatGlimmerElementModifier,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::element_modifier::FormatGlimmerElementModifier::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerLiteral>
+    for crate::js::auxiliary::literal::FormatGlimmerLiteral
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerLiteral,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerLiteral>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerLiteral {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerLiteral,
+        crate::js::auxiliary::literal::FormatGlimmerLiteral,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::literal::FormatGlimmerLiteral::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerLiteral {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerLiteral,
+        crate::js::auxiliary::literal::FormatGlimmerLiteral,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::literal::FormatGlimmerLiteral::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerMustacheComment>
+    for crate::js::auxiliary::mustache_comment::FormatGlimmerMustacheComment
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerMustacheComment,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerMustacheComment>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerMustacheComment {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerMustacheComment,
+        crate::js::auxiliary::mustache_comment::FormatGlimmerMustacheComment,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::mustache_comment::FormatGlimmerMustacheComment::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerMustacheComment {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerMustacheComment,
+        crate::js::auxiliary::mustache_comment::FormatGlimmerMustacheComment,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::mustache_comment::FormatGlimmerMustacheComment::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerMustacheExpression>
+    for crate::js::auxiliary::mustache_expression::FormatGlimmerMustacheExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerMustacheExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerMustacheExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerMustacheExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerMustacheExpression,
+        crate::js::auxiliary::mustache_expression::FormatGlimmerMustacheExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::mustache_expression::FormatGlimmerMustacheExpression::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerMustacheExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerMustacheExpression,
+        crate::js::auxiliary::mustache_expression::FormatGlimmerMustacheExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::mustache_expression::FormatGlimmerMustacheExpression::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerNamedArgument>
+    for crate::js::auxiliary::named_argument::FormatGlimmerNamedArgument
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerNamedArgument,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerNamedArgument>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedArgument {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerNamedArgument,
+        crate::js::auxiliary::named_argument::FormatGlimmerNamedArgument,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::named_argument::FormatGlimmerNamedArgument::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedArgument {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerNamedArgument,
+        crate::js::auxiliary::named_argument::FormatGlimmerNamedArgument,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::named_argument::FormatGlimmerNamedArgument::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerNamedBlock>
+    for crate::js::auxiliary::named_block::FormatGlimmerNamedBlock
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerNamedBlock,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerNamedBlock>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlock {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerNamedBlock,
+        crate::js::auxiliary::named_block::FormatGlimmerNamedBlock,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::named_block::FormatGlimmerNamedBlock::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlock {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerNamedBlock,
+        crate::js::auxiliary::named_block::FormatGlimmerNamedBlock,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::named_block::FormatGlimmerNamedBlock::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerNamedBlockClosing>
+    for crate::js::auxiliary::named_block_closing::FormatGlimmerNamedBlockClosing
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerNamedBlockClosing,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerNamedBlockClosing>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlockClosing {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerNamedBlockClosing,
+        crate::js::auxiliary::named_block_closing::FormatGlimmerNamedBlockClosing,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::named_block_closing::FormatGlimmerNamedBlockClosing::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlockClosing {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerNamedBlockClosing,
+        crate::js::auxiliary::named_block_closing::FormatGlimmerNamedBlockClosing,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::named_block_closing::FormatGlimmerNamedBlockClosing::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerNamedBlockOpening>
+    for crate::js::auxiliary::named_block_opening::FormatGlimmerNamedBlockOpening
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerNamedBlockOpening,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerNamedBlockOpening>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlockOpening {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerNamedBlockOpening,
+        crate::js::auxiliary::named_block_opening::FormatGlimmerNamedBlockOpening,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::named_block_opening::FormatGlimmerNamedBlockOpening::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerNamedBlockOpening {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerNamedBlockOpening,
+        crate::js::auxiliary::named_block_opening::FormatGlimmerNamedBlockOpening,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::named_block_opening::FormatGlimmerNamedBlockOpening::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerPath> for crate::js::auxiliary::path::FormatGlimmerPath {
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerPath,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerPath>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPath {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerPath,
+        crate::js::auxiliary::path::FormatGlimmerPath,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::path::FormatGlimmerPath::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPath {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerPath,
+        crate::js::auxiliary::path::FormatGlimmerPath,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::path::FormatGlimmerPath::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerPathSegment>
+    for crate::js::auxiliary::path_segment::FormatGlimmerPathSegment
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerPathSegment,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerPathSegment>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPathSegment {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerPathSegment,
+        crate::js::auxiliary::path_segment::FormatGlimmerPathSegment,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::path_segment::FormatGlimmerPathSegment::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPathSegment {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerPathSegment,
+        crate::js::auxiliary::path_segment::FormatGlimmerPathSegment,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::path_segment::FormatGlimmerPathSegment::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerPositionalArgument>
+    for crate::js::auxiliary::positional_argument::FormatGlimmerPositionalArgument
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerPositionalArgument,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerPositionalArgument>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPositionalArgument {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerPositionalArgument,
+        crate::js::auxiliary::positional_argument::FormatGlimmerPositionalArgument,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::positional_argument::FormatGlimmerPositionalArgument::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPositionalArgument {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerPositionalArgument,
+        crate::js::auxiliary::positional_argument::FormatGlimmerPositionalArgument,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::positional_argument::FormatGlimmerPositionalArgument::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerSplattribute>
+    for crate::js::auxiliary::splattribute::FormatGlimmerSplattribute
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerSplattribute,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerSplattribute>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerSplattribute {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerSplattribute,
+        crate::js::auxiliary::splattribute::FormatGlimmerSplattribute,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::splattribute::FormatGlimmerSplattribute::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerSplattribute {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerSplattribute,
+        crate::js::auxiliary::splattribute::FormatGlimmerSplattribute,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::splattribute::FormatGlimmerSplattribute::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerStringLiteral>
+    for crate::js::auxiliary::string_literal::FormatGlimmerStringLiteral
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerStringLiteral,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerStringLiteral>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerStringLiteral {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerStringLiteral,
+        crate::js::auxiliary::string_literal::FormatGlimmerStringLiteral,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::string_literal::FormatGlimmerStringLiteral::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerStringLiteral {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerStringLiteral,
+        crate::js::auxiliary::string_literal::FormatGlimmerStringLiteral,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::string_literal::FormatGlimmerStringLiteral::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerSubexpression>
+    for crate::js::auxiliary::subexpression::FormatGlimmerSubexpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerSubexpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerSubexpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerSubexpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerSubexpression,
+        crate::js::auxiliary::subexpression::FormatGlimmerSubexpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::subexpression::FormatGlimmerSubexpression::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerSubexpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerSubexpression,
+        crate::js::auxiliary::subexpression::FormatGlimmerSubexpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::subexpression::FormatGlimmerSubexpression::default(),
+        )
+    }
+}
+impl FormatRule<biome_html_syntax::GlimmerTripleStashExpression>
+    for crate::js::auxiliary::triple_stash_expression::FormatGlimmerTripleStashExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerTripleStashExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::GlimmerTripleStashExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerTripleStashExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerTripleStashExpression,
+        crate::js::auxiliary::triple_stash_expression::FormatGlimmerTripleStashExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule :: new (self , crate :: js :: auxiliary :: triple_stash_expression :: FormatGlimmerTripleStashExpression :: default ())
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerTripleStashExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerTripleStashExpression,
+        crate::js::auxiliary::triple_stash_expression::FormatGlimmerTripleStashExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule :: new (self , crate :: js :: auxiliary :: triple_stash_expression :: FormatGlimmerTripleStashExpression :: default ())
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlAttribute>
     for crate::html::auxiliary::attribute::FormatHtmlAttribute
 {
@@ -788,6 +1540,81 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::SvelteName {
         )
     }
 }
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerArgumentList {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerArgumentList,
+        crate::js::lists::argument_list::FormatGlimmerArgumentList,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::lists::argument_list::FormatGlimmerArgumentList::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerArgumentList {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerArgumentList,
+        crate::js::lists::argument_list::FormatGlimmerArgumentList,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::lists::argument_list::FormatGlimmerArgumentList::default(),
+        )
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParamList {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBlockParamList,
+        crate::js::lists::block_param_list::FormatGlimmerBlockParamList,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::lists::block_param_list::FormatGlimmerBlockParamList::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBlockParamList {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBlockParamList,
+        crate::js::lists::block_param_list::FormatGlimmerBlockParamList,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::lists::block_param_list::FormatGlimmerBlockParamList::default(),
+        )
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPathSegmentList {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerPathSegmentList,
+        crate::js::lists::path_segment_list::FormatGlimmerPathSegmentList,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::lists::path_segment_list::FormatGlimmerPathSegmentList::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerPathSegmentList {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerPathSegmentList,
+        crate::js::lists::path_segment_list::FormatGlimmerPathSegmentList,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::lists::path_segment_list::FormatGlimmerPathSegmentList::default(),
+        )
+    }
+}
 impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeList {
     type Format<'a> = FormatRefWithRule<
         'a,
@@ -901,6 +1728,44 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AstroBogusFrontmatter
         )
     }
 }
+impl FormatRule<biome_html_syntax::GlimmerBogusExpression>
+    for crate::js::bogus::bogus_expression::FormatGlimmerBogusExpression
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::GlimmerBogusExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatBogusNodeRule::<biome_html_syntax::GlimmerBogusExpression>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBogusExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::GlimmerBogusExpression,
+        crate::js::bogus::bogus_expression::FormatGlimmerBogusExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::bogus::bogus_expression::FormatGlimmerBogusExpression::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::GlimmerBogusExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::GlimmerBogusExpression,
+        crate::js::bogus::bogus_expression::FormatGlimmerBogusExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::bogus::bogus_expression::FormatGlimmerBogusExpression::default(),
+        )
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlBogus> for crate::html::bogus::bogus::FormatHtmlBogus {
     type Context = HtmlFormatContext;
     #[inline(always)]
@@ -1104,6 +1969,81 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyAstroFrontmatterEle
         )
     }
 }
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerArgument {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::AnyGlimmerArgument,
+        crate::js::any::argument::FormatAnyGlimmerArgument,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::any::argument::FormatAnyGlimmerArgument::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerArgument {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::AnyGlimmerArgument,
+        crate::js::any::argument::FormatAnyGlimmerArgument,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::any::argument::FormatAnyGlimmerArgument::default(),
+        )
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerArgumentValue {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::AnyGlimmerArgumentValue,
+        crate::js::any::argument_value::FormatAnyGlimmerArgumentValue,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::any::argument_value::FormatAnyGlimmerArgumentValue::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerArgumentValue {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::AnyGlimmerArgumentValue,
+        crate::js::any::argument_value::FormatAnyGlimmerArgumentValue,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::any::argument_value::FormatAnyGlimmerArgumentValue::default(),
+        )
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerExpression {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::AnyGlimmerExpression,
+        crate::js::any::expression::FormatAnyGlimmerExpression,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::any::expression::FormatAnyGlimmerExpression::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::AnyGlimmerExpression {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::AnyGlimmerExpression,
+        crate::js::any::expression::FormatAnyGlimmerExpression,
+    >;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::any::expression::FormatAnyGlimmerExpression::default(),
+        )
+    }
+}
 impl AsFormat<HtmlFormatContext> for biome_html_syntax::AnyHtmlAttribute {
     type Format<'a> = FormatRefWithRule<
         'a,
diff --git a/crates/biome_html_formatter/src/glimmer.rs b/crates/biome_html_formatter/src/glimmer.rs
new file mode 100644
index 000000000000..7538c2b6922d
--- /dev/null
+++ b/crates/biome_html_formatter/src/glimmer.rs
@@ -0,0 +1,62 @@
+// Glimmer formatter stubs
+// All Glimmer nodes preserve their original formatting for now
+
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::*;
+use biome_rowan::AstNode;
+
+// Helper macro to create formatter stubs that preserve original formatting
+macro_rules! impl_verbatim_formatter {
+    ($node:ty) => {
+        impl crate::AsFormat<HtmlFormatContext> for $node {
+            type Format<'a> = FormatRefWithRule<'a, $node, FormatVerbatimNode>;
+
+            fn format(&self) -> Self::Format<'_> {
+                FormatRefWithRule::new(self, FormatVerbatimNode)
+            }
+        }
+
+        impl crate::IntoFormat<HtmlFormatContext> for $node {
+            type Format = FormatOwnedWithRule<$node, FormatVerbatimNode>;
+
+            fn into_format(self) -> Self::Format {
+                FormatOwnedWithRule::new(self, FormatVerbatimNode)
+            }
+        }
+    };
+}
+
+// Verbatim formatter that preserves original text
+struct FormatVerbatimNode;
+
+impl<T: AstNode<Language = biome_html_syntax::HtmlLanguage>> biome_formatter::FormatRule<T> for FormatVerbatimNode {
+    type Context = HtmlFormatContext;
+
+    fn fmt(&self, node: &T, f: &mut HtmlFormatter) -> biome_formatter::FormatResult<()> {
+        write!(f, [biome_formatter::format_verbatim_node(node.syntax())])
+    }
+}
+
+// Apply verbatim formatting to all Glimmer nodes
+impl_verbatim_formatter!(GlimmerMustacheExpression);
+impl_verbatim_formatter!(GlimmerMustacheComment);
+impl_verbatim_formatter!(GlimmerTripleStashExpression);
+impl_verbatim_formatter!(GlimmerBlockHelper);
+impl_verbatim_formatter!(GlimmerBlockHelperOpening);
+impl_verbatim_formatter!(GlimmerBlockHelperClosing);
+impl_verbatim_formatter!(GlimmerBlockParams);
+impl_verbatim_formatter!(GlimmerBlockParam);
+impl_verbatim_formatter!(GlimmerPath);
+impl_verbatim_formatter!(GlimmerPathSegment);
+impl_verbatim_formatter!(GlimmerPositionalArgument);
+impl_verbatim_formatter!(GlimmerNamedArgument);
+impl_verbatim_formatter!(GlimmerSubexpression);
+impl_verbatim_formatter!(GlimmerStringLiteral);
+impl_verbatim_formatter!(GlimmerLiteral);
+impl_verbatim_formatter!(GlimmerSplattribute);
+impl_verbatim_formatter!(GlimmerElementModifier);
+impl_verbatim_formatter!(GlimmerNamedBlock);
+impl_verbatim_formatter!(GlimmerNamedBlockOpening);
+impl_verbatim_formatter!(GlimmerNamedBlockClosing);
+impl_verbatim_formatter!(GlimmerBogusExpression);
diff --git a/crates/biome_html_formatter/src/html/any/attribute.rs b/crates/biome_html_formatter/src/html/any/attribute.rs
index b1c6704f75bf..7b07e4484cc3 100644
--- a/crates/biome_html_formatter/src/html/any/attribute.rs
+++ b/crates/biome_html_formatter/src/html/any/attribute.rs
@@ -8,6 +8,8 @@ impl FormatRule<AnyHtmlAttribute> for FormatAnyHtmlAttribute {
     type Context = HtmlFormatContext;
     fn fmt(&self, node: &AnyHtmlAttribute, f: &mut HtmlFormatter) -> FormatResult<()> {
         match node {
+            AnyHtmlAttribute::GlimmerElementModifier(node) => node.format().fmt(f),
+            AnyHtmlAttribute::GlimmerSplattribute(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlAttribute(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlBogusAttribute(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlDoubleTextExpression(node) => node.format().fmt(f),
diff --git a/crates/biome_html_formatter/src/html/any/content.rs b/crates/biome_html_formatter/src/html/any/content.rs
index 677a094d1981..7b131670bd3e 100644
--- a/crates/biome_html_formatter/src/html/any/content.rs
+++ b/crates/biome_html_formatter/src/html/any/content.rs
@@ -8,6 +8,7 @@ impl FormatRule<AnyHtmlContent> for FormatAnyHtmlContent {
     type Context = HtmlFormatContext;
     fn fmt(&self, node: &AnyHtmlContent, f: &mut HtmlFormatter) -> FormatResult<()> {
         match node {
+            AnyHtmlContent::AnyGlimmerExpression(node) => node.format().fmt(f),
             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/any/element.rs b/crates/biome_html_formatter/src/html/any/element.rs
index c316fd0cd047..802ed7c8ac44 100644
--- a/crates/biome_html_formatter/src/html/any/element.rs
+++ b/crates/biome_html_formatter/src/html/any/element.rs
@@ -13,6 +13,8 @@ impl FormatRule<AnyHtmlElement> for FormatAnyHtmlElement {
             AnyHtmlElement::HtmlCdataSection(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlElement(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlSelfClosingElement(node) => node.format().fmt(f),
+            AnyHtmlElement::GlimmerMustacheComment(node) => node.format().fmt(f),
+            AnyHtmlElement::GlimmerTripleStashExpression(node) => node.format().fmt(f),
         }
     }
 }
diff --git a/crates/biome_html_formatter/src/html/lists/attribute_list.rs b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
index 26252d23f692..2b6510c395e6 100644
--- a/crates/biome_html_formatter/src/html/lists/attribute_list.rs
+++ b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
@@ -69,6 +69,12 @@ impl FormatRule<HtmlAttributeList> for FormatHtmlAttributeList {
                                     AnyHtmlAttribute::HtmlBogusAttribute(attr) => {
                                         attr.format().fmt(f)
                                     }
+                                    AnyHtmlAttribute::GlimmerElementModifier(attr) => {
+                                        attr.format().fmt(f)
+                                    }
+                                    AnyHtmlAttribute::GlimmerSplattribute(attr) => {
+                                        attr.format().fmt(f)
+                                    }
                                 })
                             }))
                             .finish()?;
diff --git a/crates/biome_html_formatter/src/js/any/argument.rs b/crates/biome_html_formatter/src/js/any/argument.rs
new file mode 100644
index 000000000000..11c4871965ac
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/any/argument.rs
@@ -0,0 +1,15 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_html_syntax::AnyGlimmerArgument;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyGlimmerArgument;
+impl FormatRule<AnyGlimmerArgument> for FormatAnyGlimmerArgument {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &AnyGlimmerArgument, f: &mut HtmlFormatter) -> FormatResult<()> {
+        match node {
+            AnyGlimmerArgument::GlimmerNamedArgument(node) => node.format().fmt(f),
+            AnyGlimmerArgument::GlimmerPositionalArgument(node) => node.format().fmt(f),
+        }
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/any/argument_value.rs b/crates/biome_html_formatter/src/js/any/argument_value.rs
new file mode 100644
index 000000000000..f066ae37812f
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/any/argument_value.rs
@@ -0,0 +1,17 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_html_syntax::AnyGlimmerArgumentValue;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyGlimmerArgumentValue;
+impl FormatRule<AnyGlimmerArgumentValue> for FormatAnyGlimmerArgumentValue {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &AnyGlimmerArgumentValue, f: &mut HtmlFormatter) -> FormatResult<()> {
+        match node {
+            AnyGlimmerArgumentValue::GlimmerLiteral(node) => node.format().fmt(f),
+            AnyGlimmerArgumentValue::GlimmerPath(node) => node.format().fmt(f),
+            AnyGlimmerArgumentValue::GlimmerStringLiteral(node) => node.format().fmt(f),
+            AnyGlimmerArgumentValue::GlimmerSubexpression(node) => node.format().fmt(f),
+        }
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/any/expression.rs b/crates/biome_html_formatter/src/js/any/expression.rs
new file mode 100644
index 000000000000..1c516c01ff96
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/any/expression.rs
@@ -0,0 +1,19 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_html_syntax::AnyGlimmerExpression;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyGlimmerExpression;
+impl FormatRule<AnyGlimmerExpression> for FormatAnyGlimmerExpression {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &AnyGlimmerExpression, f: &mut HtmlFormatter) -> FormatResult<()> {
+        match node {
+            AnyGlimmerExpression::GlimmerBlockHelper(node) => node.format().fmt(f),
+            AnyGlimmerExpression::GlimmerBogusExpression(node) => node.format().fmt(f),
+            AnyGlimmerExpression::GlimmerMustacheComment(node) => node.format().fmt(f),
+            AnyGlimmerExpression::GlimmerMustacheExpression(node) => node.format().fmt(f),
+            AnyGlimmerExpression::GlimmerNamedBlock(node) => node.format().fmt(f),
+            AnyGlimmerExpression::GlimmerTripleStashExpression(node) => node.format().fmt(f),
+        }
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/any/mod.rs b/crates/biome_html_formatter/src/js/any/mod.rs
new file mode 100644
index 000000000000..83d7908a063b
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/any/mod.rs
@@ -0,0 +1,5 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+pub(crate) mod argument;
+pub(crate) mod argument_value;
+pub(crate) mod expression;
diff --git a/crates/biome_html_formatter/src/js/auxiliary/block_helper.rs b/crates/biome_html_formatter/src/js/auxiliary/block_helper.rs
new file mode 100644
index 000000000000..b9564a8cacf7
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/block_helper.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockHelper;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockHelper;
+impl FormatNodeRule<GlimmerBlockHelper> for FormatGlimmerBlockHelper {
+    fn fmt_fields(&self, node: &GlimmerBlockHelper, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/block_helper_closing.rs b/crates/biome_html_formatter/src/js/auxiliary/block_helper_closing.rs
new file mode 100644
index 000000000000..dcc241710f07
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/block_helper_closing.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockHelperClosing;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockHelperClosing;
+impl FormatNodeRule<GlimmerBlockHelperClosing> for FormatGlimmerBlockHelperClosing {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerBlockHelperClosing,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/block_helper_opening.rs b/crates/biome_html_formatter/src/js/auxiliary/block_helper_opening.rs
new file mode 100644
index 000000000000..7696ff416dc6
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/block_helper_opening.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockHelperOpening;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockHelperOpening;
+impl FormatNodeRule<GlimmerBlockHelperOpening> for FormatGlimmerBlockHelperOpening {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerBlockHelperOpening,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/block_param.rs b/crates/biome_html_formatter/src/js/auxiliary/block_param.rs
new file mode 100644
index 000000000000..52251a99c688
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/block_param.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockParam;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockParam;
+impl FormatNodeRule<GlimmerBlockParam> for FormatGlimmerBlockParam {
+    fn fmt_fields(&self, node: &GlimmerBlockParam, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/block_params.rs b/crates/biome_html_formatter/src/js/auxiliary/block_params.rs
new file mode 100644
index 000000000000..c67cee0081fc
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/block_params.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockParams;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockParams;
+impl FormatNodeRule<GlimmerBlockParams> for FormatGlimmerBlockParams {
+    fn fmt_fields(&self, node: &GlimmerBlockParams, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/element_modifier.rs b/crates/biome_html_formatter/src/js/auxiliary/element_modifier.rs
new file mode 100644
index 000000000000..49930c2cedaa
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/element_modifier.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerElementModifier;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerElementModifier;
+impl FormatNodeRule<GlimmerElementModifier> for FormatGlimmerElementModifier {
+    fn fmt_fields(&self, node: &GlimmerElementModifier, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/literal.rs b/crates/biome_html_formatter/src/js/auxiliary/literal.rs
new file mode 100644
index 000000000000..dfc29ed7a34e
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/literal.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerLiteral;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerLiteral;
+impl FormatNodeRule<GlimmerLiteral> for FormatGlimmerLiteral {
+    fn fmt_fields(&self, node: &GlimmerLiteral, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/mod.rs b/crates/biome_html_formatter/src/js/auxiliary/mod.rs
new file mode 100644
index 000000000000..c7e23538f6ec
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/mod.rs
@@ -0,0 +1,22 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+pub(crate) mod block_helper;
+pub(crate) mod block_helper_closing;
+pub(crate) mod block_helper_opening;
+pub(crate) mod block_param;
+pub(crate) mod block_params;
+pub(crate) mod element_modifier;
+pub(crate) mod literal;
+pub(crate) mod mustache_comment;
+pub(crate) mod mustache_expression;
+pub(crate) mod named_argument;
+pub(crate) mod named_block;
+pub(crate) mod named_block_closing;
+pub(crate) mod named_block_opening;
+pub(crate) mod path;
+pub(crate) mod path_segment;
+pub(crate) mod positional_argument;
+pub(crate) mod splattribute;
+pub(crate) mod string_literal;
+pub(crate) mod subexpression;
+pub(crate) mod triple_stash_expression;
diff --git a/crates/biome_html_formatter/src/js/auxiliary/mustache_comment.rs b/crates/biome_html_formatter/src/js/auxiliary/mustache_comment.rs
new file mode 100644
index 000000000000..ee406261d0cb
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/mustache_comment.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerMustacheComment;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerMustacheComment;
+impl FormatNodeRule<GlimmerMustacheComment> for FormatGlimmerMustacheComment {
+    fn fmt_fields(&self, node: &GlimmerMustacheComment, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/mustache_expression.rs b/crates/biome_html_formatter/src/js/auxiliary/mustache_expression.rs
new file mode 100644
index 000000000000..bbc4193df27b
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/mustache_expression.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerMustacheExpression;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerMustacheExpression;
+impl FormatNodeRule<GlimmerMustacheExpression> for FormatGlimmerMustacheExpression {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerMustacheExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/named_argument.rs b/crates/biome_html_formatter/src/js/auxiliary/named_argument.rs
new file mode 100644
index 000000000000..c9ddaf309f6c
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/named_argument.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerNamedArgument;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerNamedArgument;
+impl FormatNodeRule<GlimmerNamedArgument> for FormatGlimmerNamedArgument {
+    fn fmt_fields(&self, node: &GlimmerNamedArgument, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/named_block.rs b/crates/biome_html_formatter/src/js/auxiliary/named_block.rs
new file mode 100644
index 000000000000..b450b6f13371
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/named_block.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerNamedBlock;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerNamedBlock;
+impl FormatNodeRule<GlimmerNamedBlock> for FormatGlimmerNamedBlock {
+    fn fmt_fields(&self, node: &GlimmerNamedBlock, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/named_block_closing.rs b/crates/biome_html_formatter/src/js/auxiliary/named_block_closing.rs
new file mode 100644
index 000000000000..c88ee8d97c46
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/named_block_closing.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerNamedBlockClosing;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerNamedBlockClosing;
+impl FormatNodeRule<GlimmerNamedBlockClosing> for FormatGlimmerNamedBlockClosing {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerNamedBlockClosing,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/named_block_opening.rs b/crates/biome_html_formatter/src/js/auxiliary/named_block_opening.rs
new file mode 100644
index 000000000000..59915c6a046b
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/named_block_opening.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerNamedBlockOpening;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerNamedBlockOpening;
+impl FormatNodeRule<GlimmerNamedBlockOpening> for FormatGlimmerNamedBlockOpening {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerNamedBlockOpening,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/path.rs b/crates/biome_html_formatter/src/js/auxiliary/path.rs
new file mode 100644
index 000000000000..10a227f80a1d
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/path.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerPath;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerPath;
+impl FormatNodeRule<GlimmerPath> for FormatGlimmerPath {
+    fn fmt_fields(&self, node: &GlimmerPath, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/path_segment.rs b/crates/biome_html_formatter/src/js/auxiliary/path_segment.rs
new file mode 100644
index 000000000000..0fb9bfb0625f
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/path_segment.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerPathSegment;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerPathSegment;
+impl FormatNodeRule<GlimmerPathSegment> for FormatGlimmerPathSegment {
+    fn fmt_fields(&self, node: &GlimmerPathSegment, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/positional_argument.rs b/crates/biome_html_formatter/src/js/auxiliary/positional_argument.rs
new file mode 100644
index 000000000000..e1d43e3dfb6e
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/positional_argument.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerPositionalArgument;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerPositionalArgument;
+impl FormatNodeRule<GlimmerPositionalArgument> for FormatGlimmerPositionalArgument {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerPositionalArgument,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/splattribute.rs b/crates/biome_html_formatter/src/js/auxiliary/splattribute.rs
new file mode 100644
index 000000000000..c07794b7b9b9
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/splattribute.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerSplattribute;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerSplattribute;
+impl FormatNodeRule<GlimmerSplattribute> for FormatGlimmerSplattribute {
+    fn fmt_fields(&self, node: &GlimmerSplattribute, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/string_literal.rs b/crates/biome_html_formatter/src/js/auxiliary/string_literal.rs
new file mode 100644
index 000000000000..44b914f73c10
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/string_literal.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerStringLiteral;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerStringLiteral;
+impl FormatNodeRule<GlimmerStringLiteral> for FormatGlimmerStringLiteral {
+    fn fmt_fields(&self, node: &GlimmerStringLiteral, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/subexpression.rs b/crates/biome_html_formatter/src/js/auxiliary/subexpression.rs
new file mode 100644
index 000000000000..32684d3b5ba8
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/subexpression.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerSubexpression;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerSubexpression;
+impl FormatNodeRule<GlimmerSubexpression> for FormatGlimmerSubexpression {
+    fn fmt_fields(&self, node: &GlimmerSubexpression, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/auxiliary/triple_stash_expression.rs b/crates/biome_html_formatter/src/js/auxiliary/triple_stash_expression.rs
new file mode 100644
index 000000000000..4e2ca8520aa0
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/auxiliary/triple_stash_expression.rs
@@ -0,0 +1,14 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerTripleStashExpression;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerTripleStashExpression;
+impl FormatNodeRule<GlimmerTripleStashExpression> for FormatGlimmerTripleStashExpression {
+    fn fmt_fields(
+        &self,
+        node: &GlimmerTripleStashExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        format_html_verbatim_node(node.syntax()).fmt(f)
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/bogus/bogus_expression.rs b/crates/biome_html_formatter/src/js/bogus/bogus_expression.rs
new file mode 100644
index 000000000000..9647d39626df
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/bogus/bogus_expression.rs
@@ -0,0 +1,5 @@
+use crate::FormatBogusNodeRule;
+use biome_html_syntax::GlimmerBogusExpression;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBogusExpression;
+impl FormatBogusNodeRule<GlimmerBogusExpression> for FormatGlimmerBogusExpression {}
diff --git a/crates/biome_html_formatter/src/js/bogus/mod.rs b/crates/biome_html_formatter/src/js/bogus/mod.rs
new file mode 100644
index 000000000000..e7c60f6a619b
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/bogus/mod.rs
@@ -0,0 +1,3 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+pub(crate) mod bogus_expression;
diff --git a/crates/biome_html_formatter/src/js/lists/argument_list.rs b/crates/biome_html_formatter/src/js/lists/argument_list.rs
new file mode 100644
index 000000000000..f2c2d3f20917
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/lists/argument_list.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerArgumentList;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerArgumentList;
+impl FormatRule<GlimmerArgumentList> for FormatGlimmerArgumentList {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &GlimmerArgumentList, f: &mut HtmlFormatter) -> FormatResult<()> {
+        f.join().entries(node.iter().formatted()).finish()
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/lists/block_param_list.rs b/crates/biome_html_formatter/src/js/lists/block_param_list.rs
new file mode 100644
index 000000000000..fade46b191d7
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/lists/block_param_list.rs
@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerBlockParamList;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerBlockParamList;
+impl FormatRule<GlimmerBlockParamList> for FormatGlimmerBlockParamList {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &GlimmerBlockParamList, f: &mut HtmlFormatter) -> FormatResult<()> {
+        f.join().entries(node.iter().formatted()).finish()
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/lists/mod.rs b/crates/biome_html_formatter/src/js/lists/mod.rs
new file mode 100644
index 000000000000..1a17d555ead5
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/lists/mod.rs
@@ -0,0 +1,5 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+pub(crate) mod argument_list;
+pub(crate) mod block_param_list;
+pub(crate) mod path_segment_list;
diff --git a/crates/biome_html_formatter/src/js/lists/path_segment_list.rs b/crates/biome_html_formatter/src/js/lists/path_segment_list.rs
new file mode 100644
index 000000000000..0b82118173cc
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/lists/path_segment_list.rs
@@ -0,0 +1,18 @@
+use crate::prelude::*;
+use biome_html_syntax::GlimmerPathSegmentList;
+use biome_rowan::AstSeparatedList;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatGlimmerPathSegmentList;
+impl FormatRule<GlimmerPathSegmentList> for FormatGlimmerPathSegmentList {
+    type Context = HtmlFormatContext;
+    fn fmt(&self, node: &GlimmerPathSegmentList, f: &mut HtmlFormatter) -> FormatResult<()> {
+        // For separated lists, format each element and its separator
+        for element in node.elements() {
+            crate::prelude::write!(f, [element.node.format()])?;
+            if let Ok(Some(sep)) = element.trailing_separator() {
+                crate::prelude::write!(f, [sep.format()])?;
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/biome_html_formatter/src/js/mod.rs b/crates/biome_html_formatter/src/js/mod.rs
new file mode 100644
index 000000000000..54da8fe0418f
--- /dev/null
+++ b/crates/biome_html_formatter/src/js/mod.rs
@@ -0,0 +1,6 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+pub(crate) mod any;
+pub(crate) mod auxiliary;
+pub(crate) mod bogus;
+pub(crate) mod lists;
diff --git a/crates/biome_html_formatter/src/lib.rs b/crates/biome_html_formatter/src/lib.rs
index 97fb5607a561..21db21455f9c 100644
--- a/crates/biome_html_formatter/src/lib.rs
+++ b/crates/biome_html_formatter/src/lib.rs
@@ -19,6 +19,7 @@ pub mod context;
 mod cst;
 mod generated;
 mod html;
+mod js;
 pub(crate) mod prelude;
 pub(crate) mod separated;
 mod svelte;
diff --git a/crates/biome_html_parser/src/lexer/mod.rs b/crates/biome_html_parser/src/lexer/mod.rs
index 20a8c890b69b..49b89ccb78b6 100644
--- a/crates/biome_html_parser/src/lexer/mod.rs
+++ b/crates/biome_html_parser/src/lexer/mod.rs
@@ -3,7 +3,8 @@ mod tests;
 use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext, TextExpressionKind};
 use biome_html_syntax::HtmlSyntaxKind::{
     COMMENT, DEBUG_KW, DOCTYPE_KW, EOF, ERROR_TOKEN, HTML_KW, HTML_LITERAL, HTML_STRING_LITERAL,
-    NEWLINE, SVELTE_IDENT, TOMBSTONE, UNICODE_BOM, WHITESPACE,
+    IDENT, L_TRIPLE_CURLY, MUSTACHE_COMMENT, NEWLINE, R_TRIPLE_CURLY, SVELTE_IDENT, TOMBSTONE,
+    UNICODE_BOM, WHITESPACE,
 };
 use biome_html_syntax::{HtmlSyntaxKind, T, TextLen, TextSize};
 use biome_parser::diagnostic::ParseDiagnostic;
@@ -39,6 +40,7 @@ enum IdentifierContext {
     None,
     Doctype,
     Svelte,
+    Glimmer,
 }
 
 impl IdentifierContext {
@@ -75,6 +77,8 @@ impl<'src> HtmlLexer<'src> {
             b'/' => self.consume_byte(T![/]),
             b'=' => self.consume_byte(T![=]),
             b'!' => self.consume_byte(T![!]),
+            b'{' if self.at_opening_triple_text_expression() => self.consume_l_triple_text_expression(),
+            b'{' if self.at_mustache_comment() => self.consume_mustache_comment(),
             b'{' if self.at_svelte_opening_block() => self.consume_svelte_opening_block(),
             b'{' => {
                 if self.at_opening_double_text_expression() {
@@ -84,7 +88,9 @@ impl<'src> HtmlLexer<'src> {
                 }
             }
             b'}' => {
-                if self.at_closing_double_text_expression() {
+                if self.at_closing_triple_text_expression() {
+                    self.consume_r_triple_text_expression()
+                } else if self.at_closing_double_text_expression() {
                     self.consume_r_double_text_expression()
                 } else {
                     self.consume_byte(T!['}'])
@@ -114,6 +120,8 @@ impl<'src> HtmlLexer<'src> {
             b'/' if self.current() == T![<] => self.consume_byte(T![/]),
             b',' if self.current() == T![<] => self.consume_byte(T![,]),
             b'-' if self.at_frontmatter_edge() => self.consume_frontmatter_edge(),
+            b'{' if self.at_opening_triple_text_expression() => self.consume_l_triple_text_expression(),
+            b'{' if self.at_mustache_comment() => self.consume_mustache_comment(),
             b'{' if self.at_svelte_opening_block() => self.consume_svelte_opening_block(),
             b'{' => {
                 if self.at_opening_double_text_expression() {
@@ -123,7 +131,9 @@ impl<'src> HtmlLexer<'src> {
                 }
             }
             b'}' => {
-                if self.at_closing_double_text_expression() {
+                if self.at_closing_triple_text_expression() {
+                    self.consume_r_triple_text_expression()
+                } else if self.at_closing_double_text_expression() {
                     self.consume_r_double_text_expression()
                 } else {
                     self.consume_byte(T!['}'])
@@ -241,7 +251,6 @@ impl<'src> HtmlLexer<'src> {
             b'}' if self.at_closing_double_text_expression() => {
                 self.consume_r_double_text_expression()
             }
-            b'<' => self.consume_byte(T![<]),
             _ => {
                 while let Some(current) = self.current_byte() {
                     match current {
@@ -256,6 +265,30 @@ impl<'src> HtmlLexer<'src> {
         }
     }
 
+    /// Consumes tokens within a Glimmer double mustache expression ('{{...}}').
+    /// Properly tokenizes Glimmer expression syntax (identifiers, dots, @, string literals).
+    fn consume_double_glimmer_expression(&mut self, current: u8) -> HtmlSyntaxKind {
+        match current {
+            b'\n' | b'\r' | b'\t' | b' ' => self.consume_newline_or_whitespaces(),
+            b'}' if self.at_closing_double_text_expression() => {
+                self.consume_r_double_text_expression()
+            }
+            b'.' => self.consume_byte(T![.]),
+            b'@' => self.consume_byte(T![@]),
+            b'#' => self.consume_byte(T![#]),
+            b'/' => self.consume_byte(T![/]),
+            b'|' => self.consume_byte(T![|]),
+            b'(' => self.consume_byte(T!['(']),
+            b')' => self.consume_byte(T![')']),
+            b'=' => self.consume_byte(T![=]),
+            b'\'' | b'"' => self.consume_string_literal(current),
+            _ if current.is_ascii_alphabetic() || current == b'_' => {
+                self.consume_identifier(current, IdentifierContext::Glimmer)
+            }
+            _ => self.consume_unexpected_character(),
+        }
+    }
+
     // TODO: keep this function, and enhance svelte_expression until we don't need it anymore
     /// Consumes tokens within a single text expression ('{...}') while tracking nested
     /// brackets until the matching closing bracket is found.
@@ -289,6 +322,27 @@ impl<'src> HtmlLexer<'src> {
         HTML_LITERAL
     }
 
+    /// Consumes tokens within a triple text expression ('{{{...}}}') for Glimmer.
+    /// Unlike simple text expressions, this properly tokenizes identifiers, dots,
+    /// string literals, etc. for Glimmer expression syntax.
+    fn consume_triple_text_expression(&mut self, current: u8) -> HtmlSyntaxKind {
+        match current {
+            b'\n' | b'\r' | b'\t' | b' ' => self.consume_newline_or_whitespaces(),
+            b'}' if self.at_closing_triple_text_expression() => {
+                self.consume_r_triple_text_expression()
+            }
+            b'.' => self.consume_byte(T![.]),
+            b'@' => self.consume_byte(T![@]),
+            b'(' => self.consume_byte(T!['(']),
+            b')' => self.consume_byte(T![')']),
+            b'\'' | b'"' => self.consume_string_literal(current),
+            _ if current.is_ascii_alphabetic() || current == b'_' => {
+                self.consume_identifier(current, IdentifierContext::Glimmer)
+            }
+            _ => self.consume_unexpected_character(),
+        }
+    }
+
     /// Consumes an HTML comment starting with '<!--' until the closing '-->' is found.
     /// Returns COMMENT token type.
     fn consume_comment(&mut self) -> HtmlSyntaxKind {
@@ -421,16 +475,29 @@ impl<'src> HtmlLexer<'src> {
                         break;
                     }
                 }
+                IdentifierContext::Glimmer => {
+                    // Glimmer identifiers: alphanumeric and underscore only
+                    if byte.is_ascii_alphanumeric() || byte == b'_' {
+                        if len < BUFFER_SIZE {
+                            buffer[len] = byte;
+                            len += 1;
+                        }
+                        self.advance(1)
+                    } else {
+                        break;
+                    }
+                }
             }
         }
 
         match &buffer[..len] {
-            b"doctype" | b"DOCTYPE" if !context.is_svelte() => DOCTYPE_KW,
+            b"doctype" | b"DOCTYPE" if context.is_doctype() => DOCTYPE_KW,
             b"html" | b"HTML" if context.is_doctype() => HTML_KW,
             buffer if context.is_svelte() => match buffer {
                 b"debug" if self.current_kind == T!["{@"] => DEBUG_KW,
                 _ => SVELTE_IDENT,
             },
+            _ if matches!(context, IdentifierContext::Glimmer) => IDENT,
             _ => HTML_LITERAL,
         }
     }
@@ -580,6 +647,13 @@ impl<'src> HtmlLexer<'src> {
         }
     }
 
+    /// Consumes an opening triple text expression '{{{' token used for unescaped interpolation.
+    fn consume_l_triple_text_expression(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_opening_triple_text_expression());
+        self.advance(3);
+        L_TRIPLE_CURLY
+    }
+
     /// Consumes an opening double text expression '{{' token used for interpolation.
     fn consume_l_double_text_expression(&mut self) -> HtmlSyntaxKind {
         debug_assert!(self.at_opening_double_text_expression());
@@ -612,6 +686,13 @@ impl<'src> HtmlLexer<'src> {
         T!["}}"]
     }
 
+    /// Consumes a closing triple text expression '}}}' token used for unescaped interpolation.
+    fn consume_r_triple_text_expression(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_closing_triple_text_expression());
+        self.advance(3);
+        R_TRIPLE_CURLY
+    }
+
     /// Consumes a frontmatter fence '---' token that delimits Astro frontmatter blocks.
     fn consume_frontmatter_edge(&mut self) -> HtmlSyntaxKind {
         debug_assert!(self.at_frontmatter_edge());
@@ -619,6 +700,56 @@ impl<'src> HtmlLexer<'src> {
         T![---]
     }
 
+    /// Consumes a Glimmer mustache comment.
+    /// Handles both `{{! comment }}` and `{{!-- comment --}}` formats.
+    fn consume_mustache_comment(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_mustache_comment());
+
+        let comment_start = self.text_position();
+
+        // Check if this is a multi-line comment {{!-- ... --}}
+        let is_multiline = self.byte_at(3) == Some(b'-') && self.byte_at(4) == Some(b'-');
+
+        // Advance past the opening: {{! or {{!--
+        if is_multiline {
+            self.advance(5); // {{!--
+        } else {
+            self.advance(3); // {{!
+        }
+
+        // Consume until we find the closing }} or --}}
+        while let Some(char) = self.current_byte() {
+            if is_multiline {
+                // Look for --}}
+                if self.current_byte() == Some(b'-')
+                    && self.byte_at(1) == Some(b'-')
+                    && self.byte_at(2) == Some(b'}')
+                    && self.byte_at(3) == Some(b'}')
+                {
+                    self.advance(4); // --}}
+                    return MUSTACHE_COMMENT;
+                }
+            } else {
+                // Look for }}
+                if self.at_closing_double_text_expression() {
+                    self.advance(2); // }}
+                    return MUSTACHE_COMMENT;
+                }
+            }
+            self.advance_byte_or_char(char);
+        }
+
+        // If we reach EOF without finding closing, emit an error
+        let expected_closing = if is_multiline { "--}}" } else { "}}" };
+        let err = ParseDiagnostic::new(
+            format!("Unterminated mustache comment, expected closing '{}'", expected_closing),
+            comment_start..self.text_position(),
+        );
+        self.diagnostics.push(err);
+
+        MUSTACHE_COMMENT
+    }
+
     #[inline(always)]
     fn at_start_comment(&self) -> bool {
         self.current_byte() == Some(b'<')
@@ -659,6 +790,20 @@ impl<'src> HtmlLexer<'src> {
             && self.byte_at(2) == Some(b'-')
     }
 
+    #[inline(always)]
+    fn at_opening_triple_text_expression(&self) -> bool {
+        self.current_byte() == Some(b'{')
+            && self.byte_at(1) == Some(b'{')
+            && self.byte_at(2) == Some(b'{')
+    }
+
+    #[inline(always)]
+    fn at_mustache_comment(&self) -> bool {
+        self.current_byte() == Some(b'{')
+            && self.byte_at(1) == Some(b'{')
+            && self.byte_at(2) == Some(b'!')
+    }
+
     #[inline(always)]
     fn at_opening_double_text_expression(&self) -> bool {
         self.current_byte() == Some(b'{') && self.byte_at(1) == Some(b'{')
@@ -678,6 +823,13 @@ impl<'src> HtmlLexer<'src> {
         self.current_byte() == Some(b'}') && self.byte_at(1) == Some(b'}')
     }
 
+    #[inline(always)]
+    fn at_closing_triple_text_expression(&self) -> bool {
+        self.current_byte() == Some(b'}')
+            && self.byte_at(1) == Some(b'}')
+            && self.byte_at(2) == Some(b'}')
+    }
+
     /// Consumes the opening CDATA section marker '<![CDATA[' token.
     fn consume_cdata_start(&mut self) -> HtmlSyntaxKind {
         debug_assert!(self.at_start_cdata());
@@ -891,6 +1043,8 @@ impl<'src> Lexer<'src> for HtmlLexer<'src> {
                     HtmlLexContext::TextExpression(kind) => match kind {
                         TextExpressionKind::Double => self.consume_double_text_expression(current),
                         TextExpressionKind::Single => self.consume_single_text_expression(),
+                        TextExpressionKind::Triple => self.consume_triple_text_expression(current),
+                        TextExpressionKind::DoubleGlimmer => self.consume_double_glimmer_expression(current),
                     },
                     HtmlLexContext::CdataSection => self.consume_inside_cdata(current),
                     HtmlLexContext::AstroFencedCodeBlock => {
diff --git a/crates/biome_html_parser/src/parser.rs b/crates/biome_html_parser/src/parser.rs
index 66261d3154b6..f5d5a1655da5 100644
--- a/crates/biome_html_parser/src/parser.rs
+++ b/crates/biome_html_parser/src/parser.rs
@@ -113,6 +113,11 @@ impl HtmlParseOptions {
         self
     }
 
+    pub fn with_double_glimmer_expression(mut self) -> Self {
+        self.text_expression = Some(TextExpressionKind::DoubleGlimmer);
+        self
+    }
+
     pub fn with_frontmatter(mut self) -> Self {
         self.frontmatter = true;
         self
@@ -154,6 +159,9 @@ impl From<&HtmlFileSource> for HtmlParseOptions {
             HtmlVariant::Svelte => {
                 options = options.with_single_text_expression();
             }
+            HtmlVariant::Glimmer => {
+                options = options.with_double_glimmer_expression();
+            }
         }
 
         options
diff --git a/crates/biome_html_parser/src/syntax/glimmer/mod.rs b/crates/biome_html_parser/src/syntax/glimmer/mod.rs
new file mode 100644
index 000000000000..480bfb71b96f
--- /dev/null
+++ b/crates/biome_html_parser/src/syntax/glimmer/mod.rs
@@ -0,0 +1,392 @@
+use crate::parser::HtmlParser;
+use crate::syntax::ParsedSyntax;
+use crate::syntax::ParsedSyntax::{Absent, Present};
+use crate::token_source::HtmlLexContext;
+use biome_html_syntax::HtmlSyntaxKind::*;
+use biome_html_syntax::T;
+use biome_parser::parse_lists::ParseNodeList;
+use biome_parser::Parser;
+
+/// Parses a Glimmer path like `this.foo`, `@arg`, or `helper`
+///
+/// GlimmerPath =
+///     segments: GlimmerPathSegmentList
+///
+/// GlimmerPathSegmentList = (GlimmerPathSegment ('.' GlimmerPathSegment)*)
+///
+/// GlimmerPathSegment =
+///     value_token: 'ident'
+pub(crate) fn parse_glimmer_path(p: &mut HtmlParser, context: HtmlLexContext) -> ParsedSyntax {
+    if !p.at(IDENT) && !p.at(AT) && !p.at(HTML_LITERAL) {
+        return Absent;
+    }
+
+    let m = p.start();
+
+    // Parse optional @ prefix (for argument references like @arg)
+    let has_at = p.at(AT);
+    if has_at {
+        p.bump_with_context(AT, context);
+    }
+
+    // Start the path segments list
+    let list_m = p.start();
+
+    // Parse first segment
+    if p.at(IDENT) || p.at(HTML_LITERAL) {
+        let segment_m = p.start();
+        p.bump_any_with_context(context); // IDENT or HTML_LITERAL
+        segment_m.complete(p, GLIMMER_PATH_SEGMENT);
+    } else if has_at {
+        // @ was present but no identifier follows
+        p.error(p.err_builder("Expected identifier after '@'", p.cur_range()));
+    }
+
+    // Parse remaining segments separated by dots
+    while p.at(DOT) {
+        // Bump DOT - it will be a separator in the list
+        p.bump_with_context(DOT, context);
+
+        if p.at(IDENT) || p.at(HTML_LITERAL) {
+            let segment_m = p.start();
+            p.bump_any_with_context(context);
+            segment_m.complete(p, GLIMMER_PATH_SEGMENT);
+        }
+    }
+
+    list_m.complete(p, GLIMMER_PATH_SEGMENT_LIST);
+
+    Present(m.complete(p, GLIMMER_PATH))
+}
+
+/// Parses a Glimmer argument list
+///
+/// GlimmerArgumentList = AnyGlimmerArgument*
+///
+/// Parses both:
+/// - GlimmerPositionalArgument (values like `"string"` or `path`)
+/// - GlimmerNamedArgument (name=value like `key=value`)
+pub(crate) fn parse_glimmer_argument_list(
+    p: &mut HtmlParser,
+    context: HtmlLexContext,
+) -> ParsedSyntax {
+    let m = p.start();
+
+    while !p.at(R_TRIPLE_CURLY) && !p.at(R_DOUBLE_CURLY) && !p.at(EOF) {
+        if p.at(HTML_STRING_LITERAL) {
+            // Positional argument with string literal
+            let arg_m = p.start();
+            let value_m = p.start();
+            p.bump_with_context(HTML_STRING_LITERAL, context);
+            value_m.complete(p, GLIMMER_STRING_LITERAL);
+            arg_m.complete(p, GLIMMER_POSITIONAL_ARGUMENT);
+        } else if p.at(IDENT) || p.at(HTML_LITERAL) {
+            // Check if this is the 'as' keyword followed by block params
+            // in patterns like "as |param|"
+            let checkpoint = p.checkpoint();
+            let is_as_keyword = p.cur_text() == "as";
+            p.bump_with_context(p.cur(), context);
+
+            if is_as_keyword && p.at(T![|]) {
+                // This is block params, not an argument - rewind and stop
+                p.rewind(checkpoint);
+                break;
+            }
+
+            // Not block params, check if it's a named argument or positional
+            // Check if next token is '='
+            if p.at(T![=]) {
+                // This is a named argument: rewind and parse properly
+                p.rewind(checkpoint);
+
+                let arg_m = p.start();
+                // Parse name_token (just bump the identifier)
+                p.bump_any_with_context(context);
+
+                // Parse eq_token '='
+                p.bump_with_context(T![=], context);
+
+                // Parse value (can be string literal or path)
+                if p.at(HTML_STRING_LITERAL) {
+                    let value_m = p.start();
+                    p.bump_with_context(HTML_STRING_LITERAL, context);
+                    value_m.complete(p, GLIMMER_STRING_LITERAL);
+                } else {
+                    let _ = parse_glimmer_path(p, context);
+                }
+
+                arg_m.complete(p, GLIMMER_NAMED_ARGUMENT);
+            } else {
+                // This is a positional argument: rewind and parse as path
+                p.rewind(checkpoint);
+
+                let arg_m = p.start();
+                let _ = parse_glimmer_path(p, context);
+                arg_m.complete(p, GLIMMER_POSITIONAL_ARGUMENT);
+            }
+        } else {
+            // Unknown token, stop parsing arguments
+            break;
+        }
+    }
+
+    Present(m.complete(p, GLIMMER_ARGUMENT_LIST))
+}
+
+/// Parse a Glimmer mustache expression (escaped output).
+/// Grammar: GlimmerMustacheExpression =
+///   l_curly2_token: '{{'
+///   path: GlimmerPath
+///   arguments: GlimmerArgumentList
+///   r_curly2_token: '}}'
+pub(crate) fn parse_glimmer_mustache_expression(p: &mut HtmlParser) -> ParsedSyntax {
+    use crate::token_source::TextExpressionKind;
+
+    if !p.at(T!["{{"]) {
+        return Absent;
+    }
+
+    // Only parse as Glimmer if DoubleGlimmer context is enabled (i.e., in .gjs/.gts files)
+    // For other files (Vue, etc.), return Absent to fall back to generic parsing
+    if p.options().text_expression != Some(TextExpressionKind::DoubleGlimmer) {
+        return Absent;
+    }
+
+    let m = p.start();
+
+    // Use DoubleGlimmer context for proper Glimmer tokenization
+    let context = HtmlLexContext::TextExpression(TextExpressionKind::DoubleGlimmer);
+
+    // Bump opening {{ with Glimmer context
+    p.bump_with_context(T!["{{"], context);
+
+    // Parse the path (e.g., this.foo, helper, @arg)
+    let _ = parse_glimmer_path(p, context);
+
+    // Parse the argument list (can be empty)
+    let _ = parse_glimmer_argument_list(p, context);
+
+    // Bump closing }} and switch back to regular context
+    if p.at(T!["}}"]) {
+        p.bump_with_context(T!["}}"], HtmlLexContext::Regular);
+    } else {
+        p.error(p.err_builder("Expected closing }}", p.cur_range()));
+    }
+
+    Present(m.complete(p, GLIMMER_MUSTACHE_EXPRESSION))
+}
+
+/// Parse a Glimmer block helper.
+/// Grammar: GlimmerBlockHelper =
+///   opening: GlimmerBlockHelperOpening
+///   children: HtmlElementList
+///   closing: GlimmerBlockHelperClosing
+pub(crate) fn parse_glimmer_block_helper(p: &mut HtmlParser) -> ParsedSyntax {
+    use crate::token_source::TextExpressionKind;
+
+    if !p.at(T!["{{"]) {
+        return Absent;
+    }
+
+    // Only parse as Glimmer if DoubleGlimmer context is enabled
+    if p.options().text_expression != Some(TextExpressionKind::DoubleGlimmer) {
+        return Absent;
+    }
+
+    // Check if this is a block helper by looking ahead for '#'
+    let checkpoint = p.checkpoint();
+    let context = HtmlLexContext::TextExpression(TextExpressionKind::DoubleGlimmer);
+
+    p.bump_with_context(T!["{{"], context);
+
+    if !p.at(T![#]) {
+        // Not a block helper, rewind
+        p.rewind(checkpoint);
+        return Absent;
+    }
+
+    // Rewind and start properly
+    p.rewind(checkpoint);
+
+    let m = p.start();
+
+    // Parse opening tag
+    let _ = parse_glimmer_block_helper_opening(p);
+
+    // Parse children (HTML elements/text between opening and closing)
+    // We need to manually control the parsing to stop at the closing tag
+    let list_m = p.start();
+    loop {
+        // Check if we're at the closing tag pattern {{/
+        if p.at(T!["{{"]) {
+            let checkpoint = p.checkpoint();
+            let ctx = HtmlLexContext::TextExpression(TextExpressionKind::DoubleGlimmer);
+            p.bump_with_context(T!["{{"], ctx);
+
+            if p.at(T![/]) {
+                // This is the closing tag, rewind and stop
+                p.rewind(checkpoint);
+                break;
+            } else {
+                // Not a closing tag, rewind and let ElementList handle it
+                p.rewind(checkpoint);
+            }
+        }
+
+        // Parse one element
+        let mut element_list = crate::syntax::ElementList::default();
+        if element_list.parse_element(p).is_absent() {
+            // Can't parse anything, stop
+            break;
+        }
+    }
+    list_m.complete(p, HTML_ELEMENT_LIST);
+
+    // Parse closing tag
+    if parse_glimmer_block_helper_closing(p).is_absent() {
+        p.error(p.err_builder("Expected closing tag for block helper", p.cur_range()));
+    }
+
+    Present(m.complete(p, GLIMMER_BLOCK_HELPER))
+}
+
+/// Parse the opening tag of a block helper.
+/// Grammar: GlimmerBlockHelperOpening =
+///   l_curly2_token: '{{'
+///   hash_token: '#'
+///   helper: GlimmerPath
+///   arguments: GlimmerArgumentList
+///   block_params: GlimmerBlockParams?
+///   r_curly2_token: '}}'
+fn parse_glimmer_block_helper_opening(p: &mut HtmlParser) -> ParsedSyntax {
+    use crate::token_source::TextExpressionKind;
+
+    if !p.at(T!["{{"]) {
+        return Absent;
+    }
+
+    let m = p.start();
+    let context = HtmlLexContext::TextExpression(TextExpressionKind::DoubleGlimmer);
+
+    // Bump opening {{
+    p.bump_with_context(T!["{{"], context);
+
+    // Bump # token
+    if p.at(T![#]) {
+        p.bump_with_context(T![#], context);
+    } else {
+        p.error(p.err_builder("Expected '#' for block helper", p.cur_range()));
+    }
+
+    // Parse helper path (e.g., 'if', 'each', 'let')
+    let _ = parse_glimmer_path(p, context);
+
+    // Parse arguments
+    let _ = parse_glimmer_argument_list(p, context);
+
+    // Parse optional block params (as |param1 param2|)
+    if p.at(IDENT) {
+        // Check if this is 'as' keyword
+        let checkpoint = p.checkpoint();
+        p.bump_with_context(IDENT, context);
+
+        if p.at(T![|]) {
+            // This looks like block params, rewind and parse properly
+            p.rewind(checkpoint);
+            let _ = parse_glimmer_block_params(p, context);
+        } else {
+            // Not block params, rewind
+            p.rewind(checkpoint);
+        }
+    }
+
+    // Bump closing }}
+    if p.at(T!["}}"]) {
+        p.bump_with_context(T!["}}"], HtmlLexContext::Regular);
+    } else {
+        p.error(p.err_builder("Expected closing }}", p.cur_range()));
+    }
+
+    Present(m.complete(p, GLIMMER_BLOCK_HELPER_OPENING))
+}
+
+/// Parse the closing tag of a block helper.
+/// Grammar: GlimmerBlockHelperClosing =
+///   l_curly2_token: '{{'
+///   slash_token: '/'
+///   helper: GlimmerPath
+///   r_curly2_token: '}}'
+fn parse_glimmer_block_helper_closing(p: &mut HtmlParser) -> ParsedSyntax {
+    use crate::token_source::TextExpressionKind;
+
+    if !p.at(T!["{{"]) {
+        return Absent;
+    }
+
+    let m = p.start();
+    let context = HtmlLexContext::TextExpression(TextExpressionKind::DoubleGlimmer);
+
+    // Bump opening {{
+    p.bump_with_context(T!["{{"], context);
+
+    // Bump / token
+    if p.at(T![/]) {
+        p.bump_with_context(T![/], context);
+    } else {
+        p.error(p.err_builder("Expected '/' for block helper closing", p.cur_range()));
+    }
+
+    // Parse helper path
+    let _ = parse_glimmer_path(p, context);
+
+    // Bump closing }}
+    if p.at(T!["}}"]) {
+        p.bump_with_context(T!["}}"], HtmlLexContext::Regular);
+    } else {
+        p.error(p.err_builder("Expected closing }}", p.cur_range()));
+    }
+
+    Present(m.complete(p, GLIMMER_BLOCK_HELPER_CLOSING))
+}
+
+/// Parse block parameters (as |param1 param2|).
+/// Grammar: GlimmerBlockParams =
+///   as_token: 'ident'
+///   l_pipe_token: '|'
+///   params: GlimmerBlockParamList
+///   r_pipe_token: '|'
+fn parse_glimmer_block_params(p: &mut HtmlParser, context: HtmlLexContext) -> ParsedSyntax {
+    if !p.at(IDENT) || p.cur_text() != "as" {
+        return Absent;
+    }
+
+    let m = p.start();
+
+    // Bump 'as' keyword
+    p.bump_with_context(IDENT, context);
+
+    // Bump opening |
+    if p.at(T![|]) {
+        p.bump_with_context(T![|], context);
+    } else {
+        p.error(p.err_builder("Expected '|' after 'as' keyword", p.cur_range()));
+    }
+
+    // Parse parameter list
+    let list_m = p.start();
+    while p.at(IDENT) {
+        let param_m = p.start();
+        p.bump_with_context(IDENT, context);
+        param_m.complete(p, GLIMMER_BLOCK_PARAM);
+    }
+    list_m.complete(p, GLIMMER_BLOCK_PARAM_LIST);
+
+    // Bump closing |
+    if p.at(T![|]) {
+        p.bump_with_context(T![|], context);
+    } else {
+        p.error(p.err_builder("Expected closing '|'", p.cur_range()));
+    }
+
+    Present(m.complete(p, GLIMMER_BLOCK_PARAMS))
+}
diff --git a/crates/biome_html_parser/src/syntax/mod.rs b/crates/biome_html_parser/src/syntax/mod.rs
index 47dcf987a28c..a17585bc5c17 100644
--- a/crates/biome_html_parser/src/syntax/mod.rs
+++ b/crates/biome_html_parser/src/syntax/mod.rs
@@ -1,9 +1,14 @@
 mod astro;
+mod glimmer;
 mod parse_error;
 mod svelte;
 
 use crate::parser::HtmlParser;
 use crate::syntax::astro::parse_astro_fence;
+use crate::syntax::glimmer::{
+    parse_glimmer_argument_list, parse_glimmer_block_helper, parse_glimmer_mustache_expression,
+    parse_glimmer_path,
+};
 use crate::syntax::parse_error::*;
 use crate::syntax::svelte::parse_svelte_at_block;
 use crate::token_source::{HtmlEmbeddedLanguage, HtmlLexContext, TextExpressionKind};
@@ -31,9 +36,10 @@ impl SyntaxFeature for HtmlSyntaxFeatures {
     fn is_supported(&self, p: &HtmlParser) -> bool {
         match self {
             Self::Astro => p.options().frontmatter,
-            Self::DoubleTextExpressions => {
-                p.options().text_expression == Some(TextExpressionKind::Double)
-            }
+            Self::DoubleTextExpressions => matches!(
+                p.options().text_expression,
+                Some(TextExpressionKind::Double | TextExpressionKind::DoubleGlimmer)
+            ),
             Self::SingleTextExpressions => {
                 p.options().text_expression == Some(TextExpressionKind::Single)
             }
@@ -211,7 +217,7 @@ fn parse_closing_tag(p: &mut HtmlParser) -> ParsedSyntax {
 }
 
 #[derive(Default)]
-struct ElementList;
+pub(crate) struct ElementList;
 
 impl ParseNodeList for ElementList {
     type Kind = HtmlSyntaxKind;
@@ -222,11 +228,24 @@ impl ParseNodeList for ElementList {
         match p.cur() {
             T!["<![CDATA["] => parse_cdata_section(p),
             T![<] => parse_element(p),
-            T!["{{"] => HtmlSyntaxFeatures::DoubleTextExpressions.parse_exclusive_syntax(
-                p,
-                |p| parse_double_text_expression(p, HtmlLexContext::Regular),
-                |p, m| disabled_interpolation(p, m.range(p)),
-            ),
+            MUSTACHE_COMMENT => parse_mustache_comment(p),
+            L_TRIPLE_CURLY => parse_triple_stash_expression(p),
+            T!["{{"] => {
+                // Try parsing as Glimmer block helper first (checks for '#')
+                parse_glimmer_block_helper(p).or_else(|| {
+                    // Try parsing as Glimmer mustache expression
+                    // If we're in a Glimmer file (.gjs/.gts), tokens inside will be lexed
+                    // with Glimmer context, so this will succeed
+                    parse_glimmer_mustache_expression(p).or_else(|| {
+                        // Fall back to generic double text expression for non-Glimmer files
+                        HtmlSyntaxFeatures::DoubleTextExpressions.parse_exclusive_syntax(
+                            p,
+                            |p| parse_double_text_expression(p, HtmlLexContext::Regular),
+                            |p, m| disabled_interpolation(p, m.range(p)),
+                        )
+                    })
+                })
+            }
             T!["{@"] => parse_svelte_at_block(p),
             T!['{'] => parse_single_text_expression(p, HtmlLexContext::Regular).or_else(|| {
                 let m = p.start();
@@ -586,8 +605,73 @@ impl TextExpression {
                     p.bump_remap_any_with_context(HtmlLexContext::TextExpression(self.kind))
                 }
             }
+            TextExpressionKind::Triple | TextExpressionKind::DoubleGlimmer => {
+                // Triple-stash and DoubleGlimmer expressions are properly tokenized by the lexer,
+                // so we don't need to remap. Just bump any token.
+                p.bump_any_with_context(HtmlLexContext::TextExpression(self.kind));
+            }
         }
 
         Present(m.complete(p, HTML_TEXT_EXPRESSION))
     }
 }
+
+/// Parse a Glimmer mustache comment.
+/// Grammar: GlimmerMustacheComment = comment_token: 'mustache_comment'
+fn parse_mustache_comment(p: &mut HtmlParser) -> ParsedSyntax {
+    if !p.at(MUSTACHE_COMMENT) {
+        return Absent;
+    }
+
+    let m = p.start();
+    p.bump(MUSTACHE_COMMENT);
+    Present(m.complete(p, GLIMMER_MUSTACHE_COMMENT))
+}
+
+/// Parse a Glimmer triple-stash expression (unescaped HTML).
+/// Grammar: GlimmerTripleStashExpression =
+///   l_curly3_token: 'l_triple_curly'
+///   path: GlimmerPath
+///   arguments: GlimmerArgumentList
+///   r_curly3_token: 'r_triple_curly'
+fn parse_triple_stash_expression(p: &mut HtmlParser) -> ParsedSyntax {
+    if !p.at(L_TRIPLE_CURLY) {
+        return Absent;
+    }
+
+    let m = p.start();
+
+    let context = HtmlLexContext::TextExpression(TextExpressionKind::Triple);
+
+    // Bump with context to switch lexer to expression mode
+    p.bump_with_context(L_TRIPLE_CURLY, context);
+
+    // Parse the path (e.g., this.foo, helper, @arg)
+    let _ = parse_glimmer_path(p, context);
+
+    // Parse the argument list (can be empty)
+    let _ = parse_glimmer_argument_list(p, context);
+
+    // Bump closing }}} and switch back to regular context
+    if p.at(R_TRIPLE_CURLY) {
+        p.bump_with_context(R_TRIPLE_CURLY, HtmlLexContext::Regular);
+    } else {
+        // Missing closing }}}, emit error and try to recover
+        p.error(p.err_builder("Expected closing }}}", p.cur_range()));
+
+        // Try to resynchronize: consume tokens until we find }}} or reach a safe boundary
+        while !p.at(R_TRIPLE_CURLY) && !p.at(EOF) && !p.at(T![<]) {
+            p.bump_any();
+        }
+
+        // If we found }}}, consume it
+        if p.at(R_TRIPLE_CURLY) {
+            p.bump_with_context(R_TRIPLE_CURLY, HtmlLexContext::Regular);
+        } else {
+            // Reached EOF or safe boundary, switch context back to Regular
+            // (Note: We don't bump here since we're at a boundary token)
+        }
+    }
+
+    Present(m.complete(p, GLIMMER_TRIPLE_STASH_EXPRESSION))
+}
diff --git a/crates/biome_html_parser/src/token_source.rs b/crates/biome_html_parser/src/token_source.rs
index 49c8fb7d271b..085a629b707b 100644
--- a/crates/biome_html_parser/src/token_source.rs
+++ b/crates/biome_html_parser/src/token_source.rs
@@ -57,11 +57,15 @@ pub(crate) enum HtmlLexContext {
 
 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
 pub(crate) enum TextExpressionKind {
-    // {{ expr }}
+    // {{ expr }} - Generic (Vue, etc.)
     #[default]
     Double,
     // { expr }
     Single,
+    // {{{ expr }}} - Glimmer triple-stash (unescaped HTML)
+    Triple,
+    // {{ expr }} - Glimmer mustache expression (like Triple but with double curlies)
+    DoubleGlimmer,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs b/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs
new file mode 100644
index 000000000000..4ebefb5f1b5a
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs
@@ -0,0 +1,4 @@
+<template>
+  {{@}}
+  {{@ }}
+</template>
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs.snap b/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs.snap
new file mode 100644
index 000000000000..c024b0aa615c
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/empty_path_after_at.gjs.snap
@@ -0,0 +1,131 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+<template>
+  {{@}}
+  {{@ }}
+</template>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerMustacheExpression {
+                    l_curly2_token_token: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: AT@15..16 "@" [] [],
+                        segments: GlimmerPathSegmentList [],
+                    },
+                    arguments: GlimmerArgumentList [],
+                    r_curly2_token_token: R_DOUBLE_CURLY@16..18 "}}" [] [],
+                },
+                GlimmerMustacheExpression {
+                    l_curly2_token_token: L_DOUBLE_CURLY@18..23 "{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: AT@23..25 "@" [] [Whitespace(" ")],
+                        segments: GlimmerPathSegmentList [],
+                    },
+                    arguments: GlimmerArgumentList [],
+                    r_curly2_token_token: R_DOUBLE_CURLY@25..27 "}}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@27..29 "<" [Newline("\n")] [],
+                slash_token: SLASH@29..30 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@30..38 "template" [] [],
+                },
+                r_angle_token: R_ANGLE@38..39 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@39..40 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..40
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..39
+    0: HTML_ELEMENT@0..39
+      0: HTML_OPENING_ELEMENT@0..10
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..9
+          0: HTML_LITERAL@1..9 "template" [] []
+        2: HTML_ATTRIBUTE_LIST@9..9
+        3: R_ANGLE@9..10 ">" [] []
+      1: HTML_ELEMENT_LIST@10..27
+        0: GLIMMER_MUSTACHE_EXPRESSION@10..18
+          0: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@15..16
+            0: AT@15..16 "@" [] []
+            1: GLIMMER_PATH_SEGMENT_LIST@16..16
+          2: GLIMMER_ARGUMENT_LIST@16..16
+          3: R_DOUBLE_CURLY@16..18 "}}" [] []
+        1: GLIMMER_MUSTACHE_EXPRESSION@18..27
+          0: L_DOUBLE_CURLY@18..23 "{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@23..25
+            0: AT@23..25 "@" [] [Whitespace(" ")]
+            1: GLIMMER_PATH_SEGMENT_LIST@25..25
+          2: GLIMMER_ARGUMENT_LIST@25..25
+          3: R_DOUBLE_CURLY@25..27 "}}" [] []
+      2: HTML_CLOSING_ELEMENT@27..39
+        0: L_ANGLE@27..29 "<" [Newline("\n")] []
+        1: SLASH@29..30 "/" [] []
+        2: HTML_TAG_NAME@30..38
+          0: HTML_LITERAL@30..38 "template" [] []
+        3: R_ANGLE@38..39 ">" [] []
+  4: EOF@39..40 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+empty_path_after_at.gjs:2:6 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected identifier after '@'
+  
+    1 │ <template>
+  > 2 │   {{@}}
+      │      ^^
+    3 │   {{@ }}
+    4 │ </template>
+  
+empty_path_after_at.gjs:3:7 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected identifier after '@'
+  
+    1 │ <template>
+    2 │   {{@}}
+  > 3 │   {{@ }}
+      │       ^^
+    4 │ </template>
+    5 │ 
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs
new file mode 100644
index 000000000000..13664911b087
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs
@@ -0,0 +1,4 @@
+<template>
+  {{#if condition}}
+    <div>Content</div>
+</template>
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs.snap b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs.snap
new file mode 100644
index 000000000000..84e176c9535d
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_block_closing.gjs.snap
@@ -0,0 +1,218 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+<template>
+  {{#if condition}}
+    <div>Content</div>
+</template>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerBlockHelper {
+                    opening: GlimmerBlockHelperOpening {
+                        l_curly2_token_token: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] [],
+                        hash_token_token: HASH@15..16 "#" [] [],
+                        helper: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@16..19 "if" [] [Whitespace(" ")],
+                                },
+                            ],
+                        },
+                        arguments: GlimmerArgumentList [
+                            GlimmerPositionalArgument {
+                                value: GlimmerPath {
+                                    at_token_token: missing (optional),
+                                    segments: GlimmerPathSegmentList [
+                                        GlimmerPathSegment {
+                                            value_token_token: IDENT@19..28 "condition" [] [],
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        block_params: missing (optional),
+                        r_curly2_token_token: R_DOUBLE_CURLY@28..30 "}}" [] [],
+                    },
+                    children: HtmlElementList [
+                        HtmlElement {
+                            opening_element: HtmlOpeningElement {
+                                l_angle_token: L_ANGLE@30..36 "<" [Newline("\n"), Whitespace("    ")] [],
+                                name: HtmlTagName {
+                                    value_token: HTML_LITERAL@36..39 "div" [] [],
+                                },
+                                attributes: HtmlAttributeList [],
+                                r_angle_token: R_ANGLE@39..40 ">" [] [],
+                            },
+                            children: HtmlElementList [
+                                HtmlContent {
+                                    value_token: HTML_LITERAL@40..47 "Content" [] [],
+                                },
+                            ],
+                            closing_element: HtmlClosingElement {
+                                l_angle_token: L_ANGLE@47..48 "<" [] [],
+                                slash_token: SLASH@48..49 "/" [] [],
+                                name: HtmlTagName {
+                                    value_token: HTML_LITERAL@49..52 "div" [] [],
+                                },
+                                r_angle_token: R_ANGLE@52..53 ">" [] [],
+                            },
+                        },
+                        HtmlSelfClosingElement {
+                            l_angle_token: L_ANGLE@53..55 "<" [Newline("\n")] [],
+                            name: missing (required),
+                            attributes: HtmlAttributeList [],
+                            slash_token: SLASH@55..56 "/" [] [],
+                            r_angle_token: missing (required),
+                        },
+                        HtmlContent {
+                            value_token: HTML_LITERAL@56..64 "template" [] [],
+                        },
+                        HtmlContent {
+                            value_token: HTML_LITERAL@64..65 ">" [] [],
+                        },
+                    ],
+                    closing: missing (required),
+                },
+            ],
+            closing_element: missing (required),
+        },
+    ],
+    eof_token: EOF@65..66 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..66
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..65
+    0: HTML_ELEMENT@0..65
+      0: HTML_OPENING_ELEMENT@0..10
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..9
+          0: HTML_LITERAL@1..9 "template" [] []
+        2: HTML_ATTRIBUTE_LIST@9..9
+        3: R_ANGLE@9..10 ">" [] []
+      1: HTML_ELEMENT_LIST@10..65
+        0: GLIMMER_BLOCK_HELPER@10..65
+          0: GLIMMER_BLOCK_HELPER_OPENING@10..30
+            0: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] []
+            1: HASH@15..16 "#" [] []
+            2: GLIMMER_PATH@16..19
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@16..19
+                0: GLIMMER_PATH_SEGMENT@16..19
+                  0: IDENT@16..19 "if" [] [Whitespace(" ")]
+            3: GLIMMER_ARGUMENT_LIST@19..28
+              0: GLIMMER_POSITIONAL_ARGUMENT@19..28
+                0: GLIMMER_PATH@19..28
+                  0: (empty)
+                  1: GLIMMER_PATH_SEGMENT_LIST@19..28
+                    0: GLIMMER_PATH_SEGMENT@19..28
+                      0: IDENT@19..28 "condition" [] []
+            4: (empty)
+            5: R_DOUBLE_CURLY@28..30 "}}" [] []
+          1: HTML_ELEMENT_LIST@30..65
+            0: HTML_ELEMENT@30..53
+              0: HTML_OPENING_ELEMENT@30..40
+                0: L_ANGLE@30..36 "<" [Newline("\n"), Whitespace("    ")] []
+                1: HTML_TAG_NAME@36..39
+                  0: HTML_LITERAL@36..39 "div" [] []
+                2: HTML_ATTRIBUTE_LIST@39..39
+                3: R_ANGLE@39..40 ">" [] []
+              1: HTML_ELEMENT_LIST@40..47
+                0: HTML_CONTENT@40..47
+                  0: HTML_LITERAL@40..47 "Content" [] []
+              2: HTML_CLOSING_ELEMENT@47..53
+                0: L_ANGLE@47..48 "<" [] []
+                1: SLASH@48..49 "/" [] []
+                2: HTML_TAG_NAME@49..52
+                  0: HTML_LITERAL@49..52 "div" [] []
+                3: R_ANGLE@52..53 ">" [] []
+            1: HTML_SELF_CLOSING_ELEMENT@53..56
+              0: L_ANGLE@53..55 "<" [Newline("\n")] []
+              1: (empty)
+              2: HTML_ATTRIBUTE_LIST@55..55
+              3: SLASH@55..56 "/" [] []
+              4: (empty)
+            2: HTML_CONTENT@56..64
+              0: HTML_LITERAL@56..64 "template" [] []
+            3: HTML_CONTENT@64..65
+              0: HTML_LITERAL@64..65 ">" [] []
+          2: (empty)
+      2: (empty)
+  4: EOF@65..66 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+missing_block_closing.gjs:4:2 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected an element name but instead found '/'.
+  
+    2 │   {{#if condition}}
+    3 │     <div>Content</div>
+  > 4 │ </template>
+      │  ^
+    5 │ 
+  
+  i Expected an element name here.
+  
+    2 │   {{#if condition}}
+    3 │     <div>Content</div>
+  > 4 │ </template>
+      │  ^
+    5 │ 
+  
+missing_block_closing.gjs:4:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `>` but instead found `template`
+  
+    2 │   {{#if condition}}
+    3 │     <div>Content</div>
+  > 4 │ </template>
+      │   ^^^^^^^^
+    5 │ 
+  
+  i Remove template
+  
+missing_block_closing.gjs:5:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected closing tag for block helper
+  
+    3 │     <div>Content</div>
+    4 │ </template>
+  > 5 │ 
+      │ 
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html
new file mode 100644
index 000000000000..b02f2b09e8c8
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html
@@ -0,0 +1,9 @@
+<div>
+  {{{unsafe content
+  <span>Next element</span>
+</div>
+
+<div>
+  {{{unsafe content}}}
+  <span>Valid</span>
+</div>
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html.snap b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html.snap
new file mode 100644
index 000000000000..95945c963d83
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/missing_triple_closing.html.snap
@@ -0,0 +1,289 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+<div>
+  {{{unsafe content
+  <span>Next element</span>
+</div>
+
+<div>
+  {{{unsafe content}}}
+  <span>Valid</span>
+</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlBogusElement {
+            items: [
+                HtmlOpeningElement {
+                    l_angle_token: L_ANGLE@0..1 "<" [] [],
+                    name: HtmlTagName {
+                        value_token: HTML_LITERAL@1..4 "div" [] [],
+                    },
+                    attributes: HtmlAttributeList [],
+                    r_angle_token: R_ANGLE@4..5 ">" [] [],
+                },
+                HtmlElementList [
+                    HtmlBogusElement {
+                        items: [
+                            L_TRIPLE_CURLY@5..11 "{{{" [Newline("\n"), Whitespace("  ")] [],
+                            GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@11..18 "unsafe" [] [Whitespace(" ")],
+                                    },
+                                ],
+                            },
+                            GlimmerArgumentList [
+                                GlimmerPositionalArgument {
+                                    value: GlimmerPath {
+                                        at_token_token: missing (optional),
+                                        segments: GlimmerPathSegmentList [
+                                            GlimmerPathSegment {
+                                                value_token_token: IDENT@18..25 "content" [] [],
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                            ERROR_TOKEN@25..29 "<" [Newline("\n"), Whitespace("  ")] [],
+                            HTML_LITERAL@29..46 "span>Next element" [] [],
+                        ],
+                    },
+                ],
+                HtmlBogusElement {
+                    items: [
+                        L_ANGLE@46..47 "<" [] [],
+                        SLASH@47..48 "/" [] [],
+                        HtmlTagName {
+                            value_token: HTML_LITERAL@48..52 "span" [] [],
+                        },
+                        R_ANGLE@52..53 ">" [] [],
+                    ],
+                },
+                HtmlElementList [],
+                HtmlClosingElement {
+                    l_angle_token: L_ANGLE@53..55 "<" [Newline("\n")] [],
+                    slash_token: SLASH@55..56 "/" [] [],
+                    name: HtmlTagName {
+                        value_token: HTML_LITERAL@56..59 "div" [] [],
+                    },
+                    r_angle_token: R_ANGLE@59..60 ">" [] [],
+                },
+            ],
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@60..63 "<" [Newline("\n"), Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@63..66 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@66..67 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerTripleStashExpression {
+                    l_curly3_token_token: L_TRIPLE_CURLY@67..73 "{{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: missing (optional),
+                        segments: GlimmerPathSegmentList [
+                            GlimmerPathSegment {
+                                value_token_token: IDENT@73..80 "unsafe" [] [Whitespace(" ")],
+                            },
+                        ],
+                    },
+                    arguments: GlimmerArgumentList [
+                        GlimmerPositionalArgument {
+                            value: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@80..87 "content" [] [],
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    r_curly3_token_token: R_TRIPLE_CURLY@87..90 "}}}" [] [],
+                },
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@90..94 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@94..98 "span" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@98..99 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        HtmlContent {
+                            value_token: HTML_LITERAL@99..104 "Valid" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@104..105 "<" [] [],
+                        slash_token: SLASH@105..106 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@106..110 "span" [] [],
+                        },
+                        r_angle_token: R_ANGLE@110..111 ">" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@111..113 "<" [Newline("\n")] [],
+                slash_token: SLASH@113..114 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@114..117 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@117..118 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@118..119 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..119
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..118
+    0: HTML_BOGUS_ELEMENT@0..60
+      0: HTML_OPENING_ELEMENT@0..5
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..4
+          0: HTML_LITERAL@1..4 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@4..4
+        3: R_ANGLE@4..5 ">" [] []
+      1: HTML_ELEMENT_LIST@5..46
+        0: HTML_BOGUS_ELEMENT@5..46
+          0: L_TRIPLE_CURLY@5..11 "{{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@11..18
+            0: (empty)
+            1: GLIMMER_PATH_SEGMENT_LIST@11..18
+              0: GLIMMER_PATH_SEGMENT@11..18
+                0: IDENT@11..18 "unsafe" [] [Whitespace(" ")]
+          2: GLIMMER_ARGUMENT_LIST@18..25
+            0: GLIMMER_POSITIONAL_ARGUMENT@18..25
+              0: GLIMMER_PATH@18..25
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@18..25
+                  0: GLIMMER_PATH_SEGMENT@18..25
+                    0: IDENT@18..25 "content" [] []
+          3: ERROR_TOKEN@25..29 "<" [Newline("\n"), Whitespace("  ")] []
+          4: HTML_LITERAL@29..46 "span>Next element" [] []
+      2: HTML_BOGUS_ELEMENT@46..53
+        0: L_ANGLE@46..47 "<" [] []
+        1: SLASH@47..48 "/" [] []
+        2: HTML_TAG_NAME@48..52
+          0: HTML_LITERAL@48..52 "span" [] []
+        3: R_ANGLE@52..53 ">" [] []
+      3: HTML_ELEMENT_LIST@53..53
+      4: HTML_CLOSING_ELEMENT@53..60
+        0: L_ANGLE@53..55 "<" [Newline("\n")] []
+        1: SLASH@55..56 "/" [] []
+        2: HTML_TAG_NAME@56..59
+          0: HTML_LITERAL@56..59 "div" [] []
+        3: R_ANGLE@59..60 ">" [] []
+    1: HTML_ELEMENT@60..118
+      0: HTML_OPENING_ELEMENT@60..67
+        0: L_ANGLE@60..63 "<" [Newline("\n"), Newline("\n")] []
+        1: HTML_TAG_NAME@63..66
+          0: HTML_LITERAL@63..66 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@66..66
+        3: R_ANGLE@66..67 ">" [] []
+      1: HTML_ELEMENT_LIST@67..111
+        0: GLIMMER_TRIPLE_STASH_EXPRESSION@67..90
+          0: L_TRIPLE_CURLY@67..73 "{{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@73..80
+            0: (empty)
+            1: GLIMMER_PATH_SEGMENT_LIST@73..80
+              0: GLIMMER_PATH_SEGMENT@73..80
+                0: IDENT@73..80 "unsafe" [] [Whitespace(" ")]
+          2: GLIMMER_ARGUMENT_LIST@80..87
+            0: GLIMMER_POSITIONAL_ARGUMENT@80..87
+              0: GLIMMER_PATH@80..87
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@80..87
+                  0: GLIMMER_PATH_SEGMENT@80..87
+                    0: IDENT@80..87 "content" [] []
+          3: R_TRIPLE_CURLY@87..90 "}}}" [] []
+        1: HTML_ELEMENT@90..111
+          0: HTML_OPENING_ELEMENT@90..99
+            0: L_ANGLE@90..94 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@94..98
+              0: HTML_LITERAL@94..98 "span" [] []
+            2: HTML_ATTRIBUTE_LIST@98..98
+            3: R_ANGLE@98..99 ">" [] []
+          1: HTML_ELEMENT_LIST@99..104
+            0: HTML_CONTENT@99..104
+              0: HTML_LITERAL@99..104 "Valid" [] []
+          2: HTML_CLOSING_ELEMENT@104..111
+            0: L_ANGLE@104..105 "<" [] []
+            1: SLASH@105..106 "/" [] []
+            2: HTML_TAG_NAME@106..110
+              0: HTML_LITERAL@106..110 "span" [] []
+            3: R_ANGLE@110..111 ">" [] []
+      2: HTML_CLOSING_ELEMENT@111..118
+        0: L_ANGLE@111..113 "<" [Newline("\n")] []
+        1: SLASH@113..114 "/" [] []
+        2: HTML_TAG_NAME@114..117
+          0: HTML_LITERAL@114..117 "div" [] []
+        3: R_ANGLE@117..118 ">" [] []
+  4: EOF@118..119 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+missing_triple_closing.html:3:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Unexpected character `<`
+  
+    1 │ <div>
+    2 │   {{{unsafe content
+  > 3 │   <span>Next element</span>
+      │   ^
+    4 │ </div>
+    5 │ 
+  
+missing_triple_closing.html:3:21 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected a matching closing tag but instead found '</span>'.
+  
+    1 │ <div>
+    2 │   {{{unsafe content
+  > 3 │   <span>Next element</span>
+      │                     ^^^^^^^
+    4 │ </div>
+    5 │ 
+  
+  i Expected a matching closing tag here.
+  
+    1 │ <div>
+    2 │   {{{unsafe content
+  > 3 │   <span>Next element</span>
+      │                     ^^^^^^^
+    4 │ </div>
+    5 │ 
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html b/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html
new file mode 100644
index 000000000000..1975786fc58e
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html
@@ -0,0 +1,9 @@
+<div>
+  {{! This comment is not closed
+  <span>Content</span>
+</div>
+
+<div>
+  {{!-- This block comment is not closed
+  <span>Content</span>
+</div>
diff --git a/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html.snap b/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html.snap
new file mode 100644
index 000000000000..f899155dd00d
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/glimmer/unterminated_comment.html.snap
@@ -0,0 +1,109 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+<div>
+  {{! This comment is not closed
+  <span>Content</span>
+</div>
+
+<div>
+  {{!-- This block comment is not closed
+  <span>Content</span>
+</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..4 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@4..5 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerMustacheComment {
+                    comment_token_token: MUSTACHE_COMMENT@5..147 "{{! This comment is not closed\n  <span>Content</span>\n</div>\n\n<div>\n  {{!-- This block comment is not closed\n  <span>Content</span>\n</div>\n" [Newline("\n"), Whitespace("  ")] [],
+                },
+            ],
+            closing_element: missing (required),
+        },
+    ],
+    eof_token: EOF@147..147 "" [] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..147
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..147
+    0: HTML_ELEMENT@0..147
+      0: HTML_OPENING_ELEMENT@0..5
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..4
+          0: HTML_LITERAL@1..4 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@4..4
+        3: R_ANGLE@4..5 ">" [] []
+      1: HTML_ELEMENT_LIST@5..147
+        0: GLIMMER_MUSTACHE_COMMENT@5..147
+          0: MUSTACHE_COMMENT@5..147 "{{! This comment is not closed\n  <span>Content</span>\n</div>\n\n<div>\n  {{!-- This block comment is not closed\n  <span>Content</span>\n</div>\n" [Newline("\n"), Whitespace("  ")] []
+      2: (empty)
+  4: EOF@147..147 "" [] []
+
+```
+
+## Diagnostics
+
+```
+unterminated_comment.html:2:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Unterminated mustache comment, expected closing '}}'
+  
+     1 │ <div>
+   > 2 │   {{! This comment is not closed
+       │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   > 3 │   <span>Content</span>
+   > 4 │ </div>
+   > 5 │ 
+   > 6 │ <div>
+   > 7 │   {{!-- This block comment is not closed
+   > 8 │   <span>Content</span>
+   > 9 │ </div>
+  > 10 │ 
+       │ 
+  
+unterminated_comment.html:10:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected a closing tag but instead found the end of the file.
+  
+     8 │   <span>Content</span>
+     9 │ </div>
+  > 10 │ 
+       │ 
+  
+  i Expected a closing tag here.
+  
+     8 │   <span>Content</span>
+     9 │ </div>
+  > 10 │ 
+       │ 
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs
new file mode 100644
index 000000000000..5e09616573c5
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs
@@ -0,0 +1,11 @@
+{{#if showTitle}}
+  <h1>{{title}}</h1>
+{{/if}}
+
+{{#each items as |item index|}}
+  <li>{{item.name}}</li>
+{{/each}}
+
+{{#with user as |u|}}
+  <p>{{u.name}}</p>
+{{/with}}
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs.snap
new file mode 100644
index 000000000000..bdd38a8750c2
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_helper.gjs.snap
@@ -0,0 +1,476 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+{{#if showTitle}}
+  <h1>{{title}}</h1>
+{{/if}}
+
+{{#each items as |item index|}}
+  <li>{{item.name}}</li>
+{{/each}}
+
+{{#with user as |u|}}
+  <p>{{u.name}}</p>
+{{/with}}
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        GlimmerBlockHelper {
+            opening: GlimmerBlockHelperOpening {
+                l_curly2_token_token: L_DOUBLE_CURLY@0..2 "{{" [] [],
+                hash_token_token: HASH@2..3 "#" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@3..6 "if" [] [Whitespace(" ")],
+                        },
+                    ],
+                },
+                arguments: GlimmerArgumentList [
+                    GlimmerPositionalArgument {
+                        value: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@6..15 "showTitle" [] [],
+                                },
+                            ],
+                        },
+                    },
+                ],
+                block_params: missing (optional),
+                r_curly2_token_token: R_DOUBLE_CURLY@15..17 "}}" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@17..21 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@21..23 "h1" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@23..24 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@24..26 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@26..31 "title" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@31..33 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@33..34 "<" [] [],
+                        slash_token: SLASH@34..35 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@35..37 "h1" [] [],
+                        },
+                        r_angle_token: R_ANGLE@37..38 ">" [] [],
+                    },
+                },
+            ],
+            closing: GlimmerBlockHelperClosing {
+                l_curly2_token_token: L_DOUBLE_CURLY@38..41 "{{" [Newline("\n")] [],
+                slash_token_token: SLASH@41..42 "/" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@42..44 "if" [] [],
+                        },
+                    ],
+                },
+                r_curly2_token_token: R_DOUBLE_CURLY@44..46 "}}" [] [],
+            },
+        },
+        GlimmerBlockHelper {
+            opening: GlimmerBlockHelperOpening {
+                l_curly2_token_token: L_DOUBLE_CURLY@46..50 "{{" [Newline("\n"), Newline("\n")] [],
+                hash_token_token: HASH@50..51 "#" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@51..56 "each" [] [Whitespace(" ")],
+                        },
+                    ],
+                },
+                arguments: GlimmerArgumentList [
+                    GlimmerPositionalArgument {
+                        value: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@56..62 "items" [] [Whitespace(" ")],
+                                },
+                            ],
+                        },
+                    },
+                ],
+                block_params: GlimmerBlockParams {
+                    as_token_token: IDENT@62..65 "as" [] [Whitespace(" ")],
+                    l_pipe_token_token: PIPE@65..66 "|" [] [],
+                    params: GlimmerBlockParamList [
+                        GlimmerBlockParam {
+                            name_token_token: IDENT@66..71 "item" [] [Whitespace(" ")],
+                        },
+                        GlimmerBlockParam {
+                            name_token_token: IDENT@71..76 "index" [] [],
+                        },
+                    ],
+                    r_pipe_token_token: PIPE@76..77 "|" [] [],
+                },
+                r_curly2_token_token: R_DOUBLE_CURLY@77..79 "}}" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@79..83 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@83..85 "li" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@85..86 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@86..88 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@88..92 "item" [] [],
+                                    },
+                                    DOT@92..93 "." [] [],
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@93..97 "name" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@97..99 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@99..100 "<" [] [],
+                        slash_token: SLASH@100..101 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@101..103 "li" [] [],
+                        },
+                        r_angle_token: R_ANGLE@103..104 ">" [] [],
+                    },
+                },
+            ],
+            closing: GlimmerBlockHelperClosing {
+                l_curly2_token_token: L_DOUBLE_CURLY@104..107 "{{" [Newline("\n")] [],
+                slash_token_token: SLASH@107..108 "/" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@108..112 "each" [] [],
+                        },
+                    ],
+                },
+                r_curly2_token_token: R_DOUBLE_CURLY@112..114 "}}" [] [],
+            },
+        },
+        GlimmerBlockHelper {
+            opening: GlimmerBlockHelperOpening {
+                l_curly2_token_token: L_DOUBLE_CURLY@114..118 "{{" [Newline("\n"), Newline("\n")] [],
+                hash_token_token: HASH@118..119 "#" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@119..124 "with" [] [Whitespace(" ")],
+                        },
+                    ],
+                },
+                arguments: GlimmerArgumentList [
+                    GlimmerPositionalArgument {
+                        value: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@124..129 "user" [] [Whitespace(" ")],
+                                },
+                            ],
+                        },
+                    },
+                ],
+                block_params: GlimmerBlockParams {
+                    as_token_token: IDENT@129..132 "as" [] [Whitespace(" ")],
+                    l_pipe_token_token: PIPE@132..133 "|" [] [],
+                    params: GlimmerBlockParamList [
+                        GlimmerBlockParam {
+                            name_token_token: IDENT@133..134 "u" [] [],
+                        },
+                    ],
+                    r_pipe_token_token: PIPE@134..135 "|" [] [],
+                },
+                r_curly2_token_token: R_DOUBLE_CURLY@135..137 "}}" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@137..141 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@141..142 "p" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@142..143 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@143..145 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@145..146 "u" [] [],
+                                    },
+                                    DOT@146..147 "." [] [],
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@147..151 "name" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@151..153 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@153..154 "<" [] [],
+                        slash_token: SLASH@154..155 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@155..156 "p" [] [],
+                        },
+                        r_angle_token: R_ANGLE@156..157 ">" [] [],
+                    },
+                },
+            ],
+            closing: GlimmerBlockHelperClosing {
+                l_curly2_token_token: L_DOUBLE_CURLY@157..160 "{{" [Newline("\n")] [],
+                slash_token_token: SLASH@160..161 "/" [] [],
+                helper: GlimmerPath {
+                    at_token_token: missing (optional),
+                    segments: GlimmerPathSegmentList [
+                        GlimmerPathSegment {
+                            value_token_token: IDENT@161..165 "with" [] [],
+                        },
+                    ],
+                },
+                r_curly2_token_token: R_DOUBLE_CURLY@165..167 "}}" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@167..168 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..168
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..167
+    0: GLIMMER_BLOCK_HELPER@0..46
+      0: GLIMMER_BLOCK_HELPER_OPENING@0..17
+        0: L_DOUBLE_CURLY@0..2 "{{" [] []
+        1: HASH@2..3 "#" [] []
+        2: GLIMMER_PATH@3..6
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@3..6
+            0: GLIMMER_PATH_SEGMENT@3..6
+              0: IDENT@3..6 "if" [] [Whitespace(" ")]
+        3: GLIMMER_ARGUMENT_LIST@6..15
+          0: GLIMMER_POSITIONAL_ARGUMENT@6..15
+            0: GLIMMER_PATH@6..15
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@6..15
+                0: GLIMMER_PATH_SEGMENT@6..15
+                  0: IDENT@6..15 "showTitle" [] []
+        4: (empty)
+        5: R_DOUBLE_CURLY@15..17 "}}" [] []
+      1: HTML_ELEMENT_LIST@17..38
+        0: HTML_ELEMENT@17..38
+          0: HTML_OPENING_ELEMENT@17..24
+            0: L_ANGLE@17..21 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@21..23
+              0: HTML_LITERAL@21..23 "h1" [] []
+            2: HTML_ATTRIBUTE_LIST@23..23
+            3: R_ANGLE@23..24 ">" [] []
+          1: HTML_ELEMENT_LIST@24..33
+            0: GLIMMER_MUSTACHE_EXPRESSION@24..33
+              0: L_DOUBLE_CURLY@24..26 "{{" [] []
+              1: GLIMMER_PATH@26..31
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@26..31
+                  0: GLIMMER_PATH_SEGMENT@26..31
+                    0: IDENT@26..31 "title" [] []
+              2: GLIMMER_ARGUMENT_LIST@31..31
+              3: R_DOUBLE_CURLY@31..33 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@33..38
+            0: L_ANGLE@33..34 "<" [] []
+            1: SLASH@34..35 "/" [] []
+            2: HTML_TAG_NAME@35..37
+              0: HTML_LITERAL@35..37 "h1" [] []
+            3: R_ANGLE@37..38 ">" [] []
+      2: GLIMMER_BLOCK_HELPER_CLOSING@38..46
+        0: L_DOUBLE_CURLY@38..41 "{{" [Newline("\n")] []
+        1: SLASH@41..42 "/" [] []
+        2: GLIMMER_PATH@42..44
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@42..44
+            0: GLIMMER_PATH_SEGMENT@42..44
+              0: IDENT@42..44 "if" [] []
+        3: R_DOUBLE_CURLY@44..46 "}}" [] []
+    1: GLIMMER_BLOCK_HELPER@46..114
+      0: GLIMMER_BLOCK_HELPER_OPENING@46..79
+        0: L_DOUBLE_CURLY@46..50 "{{" [Newline("\n"), Newline("\n")] []
+        1: HASH@50..51 "#" [] []
+        2: GLIMMER_PATH@51..56
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@51..56
+            0: GLIMMER_PATH_SEGMENT@51..56
+              0: IDENT@51..56 "each" [] [Whitespace(" ")]
+        3: GLIMMER_ARGUMENT_LIST@56..62
+          0: GLIMMER_POSITIONAL_ARGUMENT@56..62
+            0: GLIMMER_PATH@56..62
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@56..62
+                0: GLIMMER_PATH_SEGMENT@56..62
+                  0: IDENT@56..62 "items" [] [Whitespace(" ")]
+        4: GLIMMER_BLOCK_PARAMS@62..77
+          0: IDENT@62..65 "as" [] [Whitespace(" ")]
+          1: PIPE@65..66 "|" [] []
+          2: GLIMMER_BLOCK_PARAM_LIST@66..76
+            0: GLIMMER_BLOCK_PARAM@66..71
+              0: IDENT@66..71 "item" [] [Whitespace(" ")]
+            1: GLIMMER_BLOCK_PARAM@71..76
+              0: IDENT@71..76 "index" [] []
+          3: PIPE@76..77 "|" [] []
+        5: R_DOUBLE_CURLY@77..79 "}}" [] []
+      1: HTML_ELEMENT_LIST@79..104
+        0: HTML_ELEMENT@79..104
+          0: HTML_OPENING_ELEMENT@79..86
+            0: L_ANGLE@79..83 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@83..85
+              0: HTML_LITERAL@83..85 "li" [] []
+            2: HTML_ATTRIBUTE_LIST@85..85
+            3: R_ANGLE@85..86 ">" [] []
+          1: HTML_ELEMENT_LIST@86..99
+            0: GLIMMER_MUSTACHE_EXPRESSION@86..99
+              0: L_DOUBLE_CURLY@86..88 "{{" [] []
+              1: GLIMMER_PATH@88..97
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@88..97
+                  0: GLIMMER_PATH_SEGMENT@88..92
+                    0: IDENT@88..92 "item" [] []
+                  1: DOT@92..93 "." [] []
+                  2: GLIMMER_PATH_SEGMENT@93..97
+                    0: IDENT@93..97 "name" [] []
+              2: GLIMMER_ARGUMENT_LIST@97..97
+              3: R_DOUBLE_CURLY@97..99 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@99..104
+            0: L_ANGLE@99..100 "<" [] []
+            1: SLASH@100..101 "/" [] []
+            2: HTML_TAG_NAME@101..103
+              0: HTML_LITERAL@101..103 "li" [] []
+            3: R_ANGLE@103..104 ">" [] []
+      2: GLIMMER_BLOCK_HELPER_CLOSING@104..114
+        0: L_DOUBLE_CURLY@104..107 "{{" [Newline("\n")] []
+        1: SLASH@107..108 "/" [] []
+        2: GLIMMER_PATH@108..112
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@108..112
+            0: GLIMMER_PATH_SEGMENT@108..112
+              0: IDENT@108..112 "each" [] []
+        3: R_DOUBLE_CURLY@112..114 "}}" [] []
+    2: GLIMMER_BLOCK_HELPER@114..167
+      0: GLIMMER_BLOCK_HELPER_OPENING@114..137
+        0: L_DOUBLE_CURLY@114..118 "{{" [Newline("\n"), Newline("\n")] []
+        1: HASH@118..119 "#" [] []
+        2: GLIMMER_PATH@119..124
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@119..124
+            0: GLIMMER_PATH_SEGMENT@119..124
+              0: IDENT@119..124 "with" [] [Whitespace(" ")]
+        3: GLIMMER_ARGUMENT_LIST@124..129
+          0: GLIMMER_POSITIONAL_ARGUMENT@124..129
+            0: GLIMMER_PATH@124..129
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@124..129
+                0: GLIMMER_PATH_SEGMENT@124..129
+                  0: IDENT@124..129 "user" [] [Whitespace(" ")]
+        4: GLIMMER_BLOCK_PARAMS@129..135
+          0: IDENT@129..132 "as" [] [Whitespace(" ")]
+          1: PIPE@132..133 "|" [] []
+          2: GLIMMER_BLOCK_PARAM_LIST@133..134
+            0: GLIMMER_BLOCK_PARAM@133..134
+              0: IDENT@133..134 "u" [] []
+          3: PIPE@134..135 "|" [] []
+        5: R_DOUBLE_CURLY@135..137 "}}" [] []
+      1: HTML_ELEMENT_LIST@137..157
+        0: HTML_ELEMENT@137..157
+          0: HTML_OPENING_ELEMENT@137..143
+            0: L_ANGLE@137..141 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@141..142
+              0: HTML_LITERAL@141..142 "p" [] []
+            2: HTML_ATTRIBUTE_LIST@142..142
+            3: R_ANGLE@142..143 ">" [] []
+          1: HTML_ELEMENT_LIST@143..153
+            0: GLIMMER_MUSTACHE_EXPRESSION@143..153
+              0: L_DOUBLE_CURLY@143..145 "{{" [] []
+              1: GLIMMER_PATH@145..151
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@145..151
+                  0: GLIMMER_PATH_SEGMENT@145..146
+                    0: IDENT@145..146 "u" [] []
+                  1: DOT@146..147 "." [] []
+                  2: GLIMMER_PATH_SEGMENT@147..151
+                    0: IDENT@147..151 "name" [] []
+              2: GLIMMER_ARGUMENT_LIST@151..151
+              3: R_DOUBLE_CURLY@151..153 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@153..157
+            0: L_ANGLE@153..154 "<" [] []
+            1: SLASH@154..155 "/" [] []
+            2: HTML_TAG_NAME@155..156
+              0: HTML_LITERAL@155..156 "p" [] []
+            3: R_ANGLE@156..157 ">" [] []
+      2: GLIMMER_BLOCK_HELPER_CLOSING@157..167
+        0: L_DOUBLE_CURLY@157..160 "{{" [Newline("\n")] []
+        1: SLASH@160..161 "/" [] []
+        2: GLIMMER_PATH@161..165
+          0: (empty)
+          1: GLIMMER_PATH_SEGMENT_LIST@161..165
+            0: GLIMMER_PATH_SEGMENT@161..165
+              0: IDENT@161..165 "with" [] []
+        3: R_DOUBLE_CURLY@165..167 "}}" [] []
+  4: EOF@167..168 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs
new file mode 100644
index 000000000000..3c75517c5e21
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs
@@ -0,0 +1,9 @@
+<template>
+  {{#each items as |item|}}
+    {{item}}
+  {{/each}}
+
+  {{#let value as |v|}}
+    {{v}}
+  {{/let}}
+</template>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs.snap
new file mode 100644
index 000000000000..a2a4bace641e
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/block_params_with_as.gjs.snap
@@ -0,0 +1,294 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+<template>
+  {{#each items as |item|}}
+    {{item}}
+  {{/each}}
+
+  {{#let value as |v|}}
+    {{v}}
+  {{/let}}
+</template>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerBlockHelper {
+                    opening: GlimmerBlockHelperOpening {
+                        l_curly2_token_token: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] [],
+                        hash_token_token: HASH@15..16 "#" [] [],
+                        helper: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@16..21 "each" [] [Whitespace(" ")],
+                                },
+                            ],
+                        },
+                        arguments: GlimmerArgumentList [
+                            GlimmerPositionalArgument {
+                                value: GlimmerPath {
+                                    at_token_token: missing (optional),
+                                    segments: GlimmerPathSegmentList [
+                                        GlimmerPathSegment {
+                                            value_token_token: IDENT@21..27 "items" [] [Whitespace(" ")],
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        block_params: GlimmerBlockParams {
+                            as_token_token: IDENT@27..30 "as" [] [Whitespace(" ")],
+                            l_pipe_token_token: PIPE@30..31 "|" [] [],
+                            params: GlimmerBlockParamList [
+                                GlimmerBlockParam {
+                                    name_token_token: IDENT@31..35 "item" [] [],
+                                },
+                            ],
+                            r_pipe_token_token: PIPE@35..36 "|" [] [],
+                        },
+                        r_curly2_token_token: R_DOUBLE_CURLY@36..38 "}}" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@38..45 "{{" [Newline("\n"), Whitespace("    ")] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@45..49 "item" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@49..51 "}}" [] [],
+                        },
+                    ],
+                    closing: GlimmerBlockHelperClosing {
+                        l_curly2_token_token: L_DOUBLE_CURLY@51..56 "{{" [Newline("\n"), Whitespace("  ")] [],
+                        slash_token_token: SLASH@56..57 "/" [] [],
+                        helper: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@57..61 "each" [] [],
+                                },
+                            ],
+                        },
+                        r_curly2_token_token: R_DOUBLE_CURLY@61..63 "}}" [] [],
+                    },
+                },
+                GlimmerBlockHelper {
+                    opening: GlimmerBlockHelperOpening {
+                        l_curly2_token_token: L_DOUBLE_CURLY@63..69 "{{" [Newline("\n"), Newline("\n"), Whitespace("  ")] [],
+                        hash_token_token: HASH@69..70 "#" [] [],
+                        helper: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@70..74 "let" [] [Whitespace(" ")],
+                                },
+                            ],
+                        },
+                        arguments: GlimmerArgumentList [
+                            GlimmerPositionalArgument {
+                                value: GlimmerPath {
+                                    at_token_token: missing (optional),
+                                    segments: GlimmerPathSegmentList [
+                                        GlimmerPathSegment {
+                                            value_token_token: IDENT@74..80 "value" [] [Whitespace(" ")],
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        block_params: GlimmerBlockParams {
+                            as_token_token: IDENT@80..83 "as" [] [Whitespace(" ")],
+                            l_pipe_token_token: PIPE@83..84 "|" [] [],
+                            params: GlimmerBlockParamList [
+                                GlimmerBlockParam {
+                                    name_token_token: IDENT@84..85 "v" [] [],
+                                },
+                            ],
+                            r_pipe_token_token: PIPE@85..86 "|" [] [],
+                        },
+                        r_curly2_token_token: R_DOUBLE_CURLY@86..88 "}}" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@88..95 "{{" [Newline("\n"), Whitespace("    ")] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@95..96 "v" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@96..98 "}}" [] [],
+                        },
+                    ],
+                    closing: GlimmerBlockHelperClosing {
+                        l_curly2_token_token: L_DOUBLE_CURLY@98..103 "{{" [Newline("\n"), Whitespace("  ")] [],
+                        slash_token_token: SLASH@103..104 "/" [] [],
+                        helper: GlimmerPath {
+                            at_token_token: missing (optional),
+                            segments: GlimmerPathSegmentList [
+                                GlimmerPathSegment {
+                                    value_token_token: IDENT@104..107 "let" [] [],
+                                },
+                            ],
+                        },
+                        r_curly2_token_token: R_DOUBLE_CURLY@107..109 "}}" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@109..111 "<" [Newline("\n")] [],
+                slash_token: SLASH@111..112 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@112..120 "template" [] [],
+                },
+                r_angle_token: R_ANGLE@120..121 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@121..122 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..122
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..121
+    0: HTML_ELEMENT@0..121
+      0: HTML_OPENING_ELEMENT@0..10
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..9
+          0: HTML_LITERAL@1..9 "template" [] []
+        2: HTML_ATTRIBUTE_LIST@9..9
+        3: R_ANGLE@9..10 ">" [] []
+      1: HTML_ELEMENT_LIST@10..109
+        0: GLIMMER_BLOCK_HELPER@10..63
+          0: GLIMMER_BLOCK_HELPER_OPENING@10..38
+            0: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] []
+            1: HASH@15..16 "#" [] []
+            2: GLIMMER_PATH@16..21
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@16..21
+                0: GLIMMER_PATH_SEGMENT@16..21
+                  0: IDENT@16..21 "each" [] [Whitespace(" ")]
+            3: GLIMMER_ARGUMENT_LIST@21..27
+              0: GLIMMER_POSITIONAL_ARGUMENT@21..27
+                0: GLIMMER_PATH@21..27
+                  0: (empty)
+                  1: GLIMMER_PATH_SEGMENT_LIST@21..27
+                    0: GLIMMER_PATH_SEGMENT@21..27
+                      0: IDENT@21..27 "items" [] [Whitespace(" ")]
+            4: GLIMMER_BLOCK_PARAMS@27..36
+              0: IDENT@27..30 "as" [] [Whitespace(" ")]
+              1: PIPE@30..31 "|" [] []
+              2: GLIMMER_BLOCK_PARAM_LIST@31..35
+                0: GLIMMER_BLOCK_PARAM@31..35
+                  0: IDENT@31..35 "item" [] []
+              3: PIPE@35..36 "|" [] []
+            5: R_DOUBLE_CURLY@36..38 "}}" [] []
+          1: HTML_ELEMENT_LIST@38..51
+            0: GLIMMER_MUSTACHE_EXPRESSION@38..51
+              0: L_DOUBLE_CURLY@38..45 "{{" [Newline("\n"), Whitespace("    ")] []
+              1: GLIMMER_PATH@45..49
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@45..49
+                  0: GLIMMER_PATH_SEGMENT@45..49
+                    0: IDENT@45..49 "item" [] []
+              2: GLIMMER_ARGUMENT_LIST@49..49
+              3: R_DOUBLE_CURLY@49..51 "}}" [] []
+          2: GLIMMER_BLOCK_HELPER_CLOSING@51..63
+            0: L_DOUBLE_CURLY@51..56 "{{" [Newline("\n"), Whitespace("  ")] []
+            1: SLASH@56..57 "/" [] []
+            2: GLIMMER_PATH@57..61
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@57..61
+                0: GLIMMER_PATH_SEGMENT@57..61
+                  0: IDENT@57..61 "each" [] []
+            3: R_DOUBLE_CURLY@61..63 "}}" [] []
+        1: GLIMMER_BLOCK_HELPER@63..109
+          0: GLIMMER_BLOCK_HELPER_OPENING@63..88
+            0: L_DOUBLE_CURLY@63..69 "{{" [Newline("\n"), Newline("\n"), Whitespace("  ")] []
+            1: HASH@69..70 "#" [] []
+            2: GLIMMER_PATH@70..74
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@70..74
+                0: GLIMMER_PATH_SEGMENT@70..74
+                  0: IDENT@70..74 "let" [] [Whitespace(" ")]
+            3: GLIMMER_ARGUMENT_LIST@74..80
+              0: GLIMMER_POSITIONAL_ARGUMENT@74..80
+                0: GLIMMER_PATH@74..80
+                  0: (empty)
+                  1: GLIMMER_PATH_SEGMENT_LIST@74..80
+                    0: GLIMMER_PATH_SEGMENT@74..80
+                      0: IDENT@74..80 "value" [] [Whitespace(" ")]
+            4: GLIMMER_BLOCK_PARAMS@80..86
+              0: IDENT@80..83 "as" [] [Whitespace(" ")]
+              1: PIPE@83..84 "|" [] []
+              2: GLIMMER_BLOCK_PARAM_LIST@84..85
+                0: GLIMMER_BLOCK_PARAM@84..85
+                  0: IDENT@84..85 "v" [] []
+              3: PIPE@85..86 "|" [] []
+            5: R_DOUBLE_CURLY@86..88 "}}" [] []
+          1: HTML_ELEMENT_LIST@88..98
+            0: GLIMMER_MUSTACHE_EXPRESSION@88..98
+              0: L_DOUBLE_CURLY@88..95 "{{" [Newline("\n"), Whitespace("    ")] []
+              1: GLIMMER_PATH@95..96
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@95..96
+                  0: GLIMMER_PATH_SEGMENT@95..96
+                    0: IDENT@95..96 "v" [] []
+              2: GLIMMER_ARGUMENT_LIST@96..96
+              3: R_DOUBLE_CURLY@96..98 "}}" [] []
+          2: GLIMMER_BLOCK_HELPER_CLOSING@98..109
+            0: L_DOUBLE_CURLY@98..103 "{{" [Newline("\n"), Whitespace("  ")] []
+            1: SLASH@103..104 "/" [] []
+            2: GLIMMER_PATH@104..107
+              0: (empty)
+              1: GLIMMER_PATH_SEGMENT_LIST@104..107
+                0: GLIMMER_PATH_SEGMENT@104..107
+                  0: IDENT@104..107 "let" [] []
+            3: R_DOUBLE_CURLY@107..109 "}}" [] []
+      2: HTML_CLOSING_ELEMENT@109..121
+        0: L_ANGLE@109..111 "<" [Newline("\n")] []
+        1: SLASH@111..112 "/" [] []
+        2: HTML_TAG_NAME@112..120
+          0: HTML_LITERAL@112..120 "template" [] []
+        3: R_ANGLE@120..121 ">" [] []
+  4: EOF@121..122 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs b/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs
new file mode 100644
index 000000000000..f2c718be8018
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs
@@ -0,0 +1,4 @@
+<template>
+  {{doctype}}
+  {{DOCTYPE}}
+</template>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs.snap
new file mode 100644
index 000000000000..636cb7dc63fb
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/doctype_identifier.gjs.snap
@@ -0,0 +1,117 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+<template>
+  {{doctype}}
+  {{DOCTYPE}}
+</template>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..9 "template" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@9..10 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerMustacheExpression {
+                    l_curly2_token_token: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: missing (optional),
+                        segments: GlimmerPathSegmentList [
+                            GlimmerPathSegment {
+                                value_token_token: IDENT@15..22 "doctype" [] [],
+                            },
+                        ],
+                    },
+                    arguments: GlimmerArgumentList [],
+                    r_curly2_token_token: R_DOUBLE_CURLY@22..24 "}}" [] [],
+                },
+                GlimmerMustacheExpression {
+                    l_curly2_token_token: L_DOUBLE_CURLY@24..29 "{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: missing (optional),
+                        segments: GlimmerPathSegmentList [
+                            GlimmerPathSegment {
+                                value_token_token: IDENT@29..36 "DOCTYPE" [] [],
+                            },
+                        ],
+                    },
+                    arguments: GlimmerArgumentList [],
+                    r_curly2_token_token: R_DOUBLE_CURLY@36..38 "}}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@38..40 "<" [Newline("\n")] [],
+                slash_token: SLASH@40..41 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@41..49 "template" [] [],
+                },
+                r_angle_token: R_ANGLE@49..50 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@50..51 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..51
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..50
+    0: HTML_ELEMENT@0..50
+      0: HTML_OPENING_ELEMENT@0..10
+        0: L_ANGLE@0..1 "<" [] []
+        1: HTML_TAG_NAME@1..9
+          0: HTML_LITERAL@1..9 "template" [] []
+        2: HTML_ATTRIBUTE_LIST@9..9
+        3: R_ANGLE@9..10 ">" [] []
+      1: HTML_ELEMENT_LIST@10..38
+        0: GLIMMER_MUSTACHE_EXPRESSION@10..24
+          0: L_DOUBLE_CURLY@10..15 "{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@15..22
+            0: (empty)
+            1: GLIMMER_PATH_SEGMENT_LIST@15..22
+              0: GLIMMER_PATH_SEGMENT@15..22
+                0: IDENT@15..22 "doctype" [] []
+          2: GLIMMER_ARGUMENT_LIST@22..22
+          3: R_DOUBLE_CURLY@22..24 "}}" [] []
+        1: GLIMMER_MUSTACHE_EXPRESSION@24..38
+          0: L_DOUBLE_CURLY@24..29 "{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@29..36
+            0: (empty)
+            1: GLIMMER_PATH_SEGMENT_LIST@29..36
+              0: GLIMMER_PATH_SEGMENT@29..36
+                0: IDENT@29..36 "DOCTYPE" [] []
+          2: GLIMMER_ARGUMENT_LIST@36..36
+          3: R_DOUBLE_CURLY@36..38 "}}" [] []
+      2: HTML_CLOSING_ELEMENT@38..50
+        0: L_ANGLE@38..40 "<" [Newline("\n")] []
+        1: SLASH@40..41 "/" [] []
+        2: HTML_TAG_NAME@41..49
+          0: HTML_LITERAL@41..49 "template" [] []
+        3: R_ANGLE@49..50 ">" [] []
+  4: EOF@50..51 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs
new file mode 100644
index 000000000000..77965fe122e1
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs
@@ -0,0 +1,6 @@
+{{this.title}}
+<div>
+  <h1>{{@name}}</h1>
+  <p>{{greeting "World"}}</p>
+  <span>{{helper arg1 arg2 key=value}}</span>
+</div>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs.snap
new file mode 100644
index 000000000000..efe00b70b4dc
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache.gjs.snap
@@ -0,0 +1,334 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+{{this.title}}
+<div>
+  <h1>{{@name}}</h1>
+  <p>{{greeting "World"}}</p>
+  <span>{{helper arg1 arg2 key=value}}</span>
+</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        GlimmerMustacheExpression {
+            l_curly2_token_token: L_DOUBLE_CURLY@0..2 "{{" [] [],
+            path: GlimmerPath {
+                at_token_token: missing (optional),
+                segments: GlimmerPathSegmentList [
+                    GlimmerPathSegment {
+                        value_token_token: IDENT@2..6 "this" [] [],
+                    },
+                    DOT@6..7 "." [] [],
+                    GlimmerPathSegment {
+                        value_token_token: IDENT@7..12 "title" [] [],
+                    },
+                ],
+            },
+            arguments: GlimmerArgumentList [],
+            r_curly2_token_token: R_DOUBLE_CURLY@12..14 "}}" [] [],
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@14..16 "<" [Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@16..19 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@19..20 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@20..24 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@24..26 "h1" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@26..27 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@27..29 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: AT@29..30 "@" [] [],
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@30..34 "name" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly2_token_token: R_DOUBLE_CURLY@34..36 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@36..37 "<" [] [],
+                        slash_token: SLASH@37..38 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@38..40 "h1" [] [],
+                        },
+                        r_angle_token: R_ANGLE@40..41 ">" [] [],
+                    },
+                },
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@41..45 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@45..46 "p" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@46..47 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@47..49 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@49..58 "greeting" [] [Whitespace(" ")],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [
+                                GlimmerPositionalArgument {
+                                    value: GlimmerStringLiteral {
+                                        value_token_token: HTML_STRING_LITERAL@58..65 "\"World\"" [] [],
+                                    },
+                                },
+                            ],
+                            r_curly2_token_token: R_DOUBLE_CURLY@65..67 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@67..68 "<" [] [],
+                        slash_token: SLASH@68..69 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@69..70 "p" [] [],
+                        },
+                        r_angle_token: R_ANGLE@70..71 ">" [] [],
+                    },
+                },
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@71..75 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@75..79 "span" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@79..80 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerMustacheExpression {
+                            l_curly2_token_token: L_DOUBLE_CURLY@80..82 "{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@82..89 "helper" [] [Whitespace(" ")],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [
+                                GlimmerPositionalArgument {
+                                    value: GlimmerPath {
+                                        at_token_token: missing (optional),
+                                        segments: GlimmerPathSegmentList [
+                                            GlimmerPathSegment {
+                                                value_token_token: IDENT@89..94 "arg1" [] [Whitespace(" ")],
+                                            },
+                                        ],
+                                    },
+                                },
+                                GlimmerPositionalArgument {
+                                    value: GlimmerPath {
+                                        at_token_token: missing (optional),
+                                        segments: GlimmerPathSegmentList [
+                                            GlimmerPathSegment {
+                                                value_token_token: IDENT@94..99 "arg2" [] [Whitespace(" ")],
+                                            },
+                                        ],
+                                    },
+                                },
+                                GlimmerNamedArgument {
+                                    name_token_token: IDENT@99..102 "key" [] [],
+                                    eq_token_token: EQ@102..103 "=" [] [],
+                                    value: GlimmerPath {
+                                        at_token_token: missing (optional),
+                                        segments: GlimmerPathSegmentList [
+                                            GlimmerPathSegment {
+                                                value_token_token: IDENT@103..108 "value" [] [],
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                            r_curly2_token_token: R_DOUBLE_CURLY@108..110 "}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@110..111 "<" [] [],
+                        slash_token: SLASH@111..112 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@112..116 "span" [] [],
+                        },
+                        r_angle_token: R_ANGLE@116..117 ">" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@117..119 "<" [Newline("\n")] [],
+                slash_token: SLASH@119..120 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@120..123 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@123..124 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@124..125 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..125
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..124
+    0: GLIMMER_MUSTACHE_EXPRESSION@0..14
+      0: L_DOUBLE_CURLY@0..2 "{{" [] []
+      1: GLIMMER_PATH@2..12
+        0: (empty)
+        1: GLIMMER_PATH_SEGMENT_LIST@2..12
+          0: GLIMMER_PATH_SEGMENT@2..6
+            0: IDENT@2..6 "this" [] []
+          1: DOT@6..7 "." [] []
+          2: GLIMMER_PATH_SEGMENT@7..12
+            0: IDENT@7..12 "title" [] []
+      2: GLIMMER_ARGUMENT_LIST@12..12
+      3: R_DOUBLE_CURLY@12..14 "}}" [] []
+    1: HTML_ELEMENT@14..124
+      0: HTML_OPENING_ELEMENT@14..20
+        0: L_ANGLE@14..16 "<" [Newline("\n")] []
+        1: HTML_TAG_NAME@16..19
+          0: HTML_LITERAL@16..19 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@19..19
+        3: R_ANGLE@19..20 ">" [] []
+      1: HTML_ELEMENT_LIST@20..117
+        0: HTML_ELEMENT@20..41
+          0: HTML_OPENING_ELEMENT@20..27
+            0: L_ANGLE@20..24 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@24..26
+              0: HTML_LITERAL@24..26 "h1" [] []
+            2: HTML_ATTRIBUTE_LIST@26..26
+            3: R_ANGLE@26..27 ">" [] []
+          1: HTML_ELEMENT_LIST@27..36
+            0: GLIMMER_MUSTACHE_EXPRESSION@27..36
+              0: L_DOUBLE_CURLY@27..29 "{{" [] []
+              1: GLIMMER_PATH@29..34
+                0: AT@29..30 "@" [] []
+                1: GLIMMER_PATH_SEGMENT_LIST@30..34
+                  0: GLIMMER_PATH_SEGMENT@30..34
+                    0: IDENT@30..34 "name" [] []
+              2: GLIMMER_ARGUMENT_LIST@34..34
+              3: R_DOUBLE_CURLY@34..36 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@36..41
+            0: L_ANGLE@36..37 "<" [] []
+            1: SLASH@37..38 "/" [] []
+            2: HTML_TAG_NAME@38..40
+              0: HTML_LITERAL@38..40 "h1" [] []
+            3: R_ANGLE@40..41 ">" [] []
+        1: HTML_ELEMENT@41..71
+          0: HTML_OPENING_ELEMENT@41..47
+            0: L_ANGLE@41..45 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@45..46
+              0: HTML_LITERAL@45..46 "p" [] []
+            2: HTML_ATTRIBUTE_LIST@46..46
+            3: R_ANGLE@46..47 ">" [] []
+          1: HTML_ELEMENT_LIST@47..67
+            0: GLIMMER_MUSTACHE_EXPRESSION@47..67
+              0: L_DOUBLE_CURLY@47..49 "{{" [] []
+              1: GLIMMER_PATH@49..58
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@49..58
+                  0: GLIMMER_PATH_SEGMENT@49..58
+                    0: IDENT@49..58 "greeting" [] [Whitespace(" ")]
+              2: GLIMMER_ARGUMENT_LIST@58..65
+                0: GLIMMER_POSITIONAL_ARGUMENT@58..65
+                  0: GLIMMER_STRING_LITERAL@58..65
+                    0: HTML_STRING_LITERAL@58..65 "\"World\"" [] []
+              3: R_DOUBLE_CURLY@65..67 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@67..71
+            0: L_ANGLE@67..68 "<" [] []
+            1: SLASH@68..69 "/" [] []
+            2: HTML_TAG_NAME@69..70
+              0: HTML_LITERAL@69..70 "p" [] []
+            3: R_ANGLE@70..71 ">" [] []
+        2: HTML_ELEMENT@71..117
+          0: HTML_OPENING_ELEMENT@71..80
+            0: L_ANGLE@71..75 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@75..79
+              0: HTML_LITERAL@75..79 "span" [] []
+            2: HTML_ATTRIBUTE_LIST@79..79
+            3: R_ANGLE@79..80 ">" [] []
+          1: HTML_ELEMENT_LIST@80..110
+            0: GLIMMER_MUSTACHE_EXPRESSION@80..110
+              0: L_DOUBLE_CURLY@80..82 "{{" [] []
+              1: GLIMMER_PATH@82..89
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@82..89
+                  0: GLIMMER_PATH_SEGMENT@82..89
+                    0: IDENT@82..89 "helper" [] [Whitespace(" ")]
+              2: GLIMMER_ARGUMENT_LIST@89..108
+                0: GLIMMER_POSITIONAL_ARGUMENT@89..94
+                  0: GLIMMER_PATH@89..94
+                    0: (empty)
+                    1: GLIMMER_PATH_SEGMENT_LIST@89..94
+                      0: GLIMMER_PATH_SEGMENT@89..94
+                        0: IDENT@89..94 "arg1" [] [Whitespace(" ")]
+                1: GLIMMER_POSITIONAL_ARGUMENT@94..99
+                  0: GLIMMER_PATH@94..99
+                    0: (empty)
+                    1: GLIMMER_PATH_SEGMENT_LIST@94..99
+                      0: GLIMMER_PATH_SEGMENT@94..99
+                        0: IDENT@94..99 "arg2" [] [Whitespace(" ")]
+                2: GLIMMER_NAMED_ARGUMENT@99..108
+                  0: IDENT@99..102 "key" [] []
+                  1: EQ@102..103 "=" [] []
+                  2: GLIMMER_PATH@103..108
+                    0: (empty)
+                    1: GLIMMER_PATH_SEGMENT_LIST@103..108
+                      0: GLIMMER_PATH_SEGMENT@103..108
+                        0: IDENT@103..108 "value" [] []
+              3: R_DOUBLE_CURLY@108..110 "}}" [] []
+          2: HTML_CLOSING_ELEMENT@110..117
+            0: L_ANGLE@110..111 "<" [] []
+            1: SLASH@111..112 "/" [] []
+            2: HTML_TAG_NAME@112..116
+              0: HTML_LITERAL@112..116 "span" [] []
+            3: R_ANGLE@116..117 ">" [] []
+      2: HTML_CLOSING_ELEMENT@117..124
+        0: L_ANGLE@117..119 "<" [Newline("\n")] []
+        1: SLASH@119..120 "/" [] []
+        2: HTML_TAG_NAME@120..123
+          0: HTML_LITERAL@120..123 "div" [] []
+        3: R_ANGLE@123..124 ">" [] []
+  4: EOF@124..125 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html
new file mode 100644
index 000000000000..18fa86a0ab10
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html
@@ -0,0 +1,7 @@
+{{! This is a single-line comment }}
+<div>
+  {{!-- This is a multi-line comment
+    that spans multiple lines
+  --}}
+  <p>Hello World</p>
+</div>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html.snap
new file mode 100644
index 000000000000..9c62af184843
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/mustache_comment.html.snap
@@ -0,0 +1,125 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+{{! This is a single-line comment }}
+<div>
+  {{!-- This is a multi-line comment
+    that spans multiple lines
+  --}}
+  <p>Hello World</p>
+</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        GlimmerMustacheComment {
+            comment_token_token: MUSTACHE_COMMENT@0..36 "{{! This is a single-line comment }}" [] [],
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@36..38 "<" [Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@38..41 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@41..42 ">" [] [],
+            },
+            children: HtmlElementList [
+                GlimmerMustacheComment {
+                    comment_token_token: MUSTACHE_COMMENT@42..116 "{{!-- This is a multi-line comment\n    that spans multiple lines\n  --}}" [Newline("\n"), Whitespace("  ")] [],
+                },
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@116..120 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@120..121 "p" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@121..122 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        HtmlContent {
+                            value_token: HTML_LITERAL@122..133 "Hello World" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@133..134 "<" [] [],
+                        slash_token: SLASH@134..135 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@135..136 "p" [] [],
+                        },
+                        r_angle_token: R_ANGLE@136..137 ">" [] [],
+                    },
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@137..139 "<" [Newline("\n")] [],
+                slash_token: SLASH@139..140 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@140..143 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@143..144 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@144..145 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..145
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..144
+    0: GLIMMER_MUSTACHE_COMMENT@0..36
+      0: MUSTACHE_COMMENT@0..36 "{{! This is a single-line comment }}" [] []
+    1: HTML_ELEMENT@36..144
+      0: HTML_OPENING_ELEMENT@36..42
+        0: L_ANGLE@36..38 "<" [Newline("\n")] []
+        1: HTML_TAG_NAME@38..41
+          0: HTML_LITERAL@38..41 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@41..41
+        3: R_ANGLE@41..42 ">" [] []
+      1: HTML_ELEMENT_LIST@42..137
+        0: GLIMMER_MUSTACHE_COMMENT@42..116
+          0: MUSTACHE_COMMENT@42..116 "{{!-- This is a multi-line comment\n    that spans multiple lines\n  --}}" [Newline("\n"), Whitespace("  ")] []
+        1: HTML_ELEMENT@116..137
+          0: HTML_OPENING_ELEMENT@116..122
+            0: L_ANGLE@116..120 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@120..121
+              0: HTML_LITERAL@120..121 "p" [] []
+            2: HTML_ATTRIBUTE_LIST@121..121
+            3: R_ANGLE@121..122 ">" [] []
+          1: HTML_ELEMENT_LIST@122..133
+            0: HTML_CONTENT@122..133
+              0: HTML_LITERAL@122..133 "Hello World" [] []
+          2: HTML_CLOSING_ELEMENT@133..137
+            0: L_ANGLE@133..134 "<" [] []
+            1: SLASH@134..135 "/" [] []
+            2: HTML_TAG_NAME@135..136
+              0: HTML_LITERAL@135..136 "p" [] []
+            3: R_ANGLE@136..137 ">" [] []
+      2: HTML_CLOSING_ELEMENT@137..144
+        0: L_ANGLE@137..139 "<" [Newline("\n")] []
+        1: SLASH@139..140 "/" [] []
+        2: HTML_TAG_NAME@140..143
+          0: HTML_LITERAL@140..143 "div" [] []
+        3: R_ANGLE@143..144 ">" [] []
+  4: EOF@144..145 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs b/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs
new file mode 100644
index 000000000000..372940d1ca15
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs
@@ -0,0 +1,5 @@
+{{{this.htmlContent}}}
+<div>
+  <p>{{{userProvidedHtml}}}</p>
+  {{{helper "argument"}}}
+</div>
diff --git a/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs.snap b/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs.snap
new file mode 100644
index 000000000000..a20400ba2795
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/glimmer/triple_stash.gjs.snap
@@ -0,0 +1,190 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```glimmer
+{{{this.htmlContent}}}
+<div>
+  <p>{{{userProvidedHtml}}}</p>
+  {{{helper "argument"}}}
+</div>
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        GlimmerTripleStashExpression {
+            l_curly3_token_token: L_TRIPLE_CURLY@0..3 "{{{" [] [],
+            path: GlimmerPath {
+                at_token_token: missing (optional),
+                segments: GlimmerPathSegmentList [
+                    GlimmerPathSegment {
+                        value_token_token: IDENT@3..7 "this" [] [],
+                    },
+                    DOT@7..8 "." [] [],
+                    GlimmerPathSegment {
+                        value_token_token: IDENT@8..19 "htmlContent" [] [],
+                    },
+                ],
+            },
+            arguments: GlimmerArgumentList [],
+            r_curly3_token_token: R_TRIPLE_CURLY@19..22 "}}}" [] [],
+        },
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@22..24 "<" [Newline("\n")] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@24..27 "div" [] [],
+                },
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@27..28 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlElement {
+                    opening_element: HtmlOpeningElement {
+                        l_angle_token: L_ANGLE@28..32 "<" [Newline("\n"), Whitespace("  ")] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@32..33 "p" [] [],
+                        },
+                        attributes: HtmlAttributeList [],
+                        r_angle_token: R_ANGLE@33..34 ">" [] [],
+                    },
+                    children: HtmlElementList [
+                        GlimmerTripleStashExpression {
+                            l_curly3_token_token: L_TRIPLE_CURLY@34..37 "{{{" [] [],
+                            path: GlimmerPath {
+                                at_token_token: missing (optional),
+                                segments: GlimmerPathSegmentList [
+                                    GlimmerPathSegment {
+                                        value_token_token: IDENT@37..53 "userProvidedHtml" [] [],
+                                    },
+                                ],
+                            },
+                            arguments: GlimmerArgumentList [],
+                            r_curly3_token_token: R_TRIPLE_CURLY@53..56 "}}}" [] [],
+                        },
+                    ],
+                    closing_element: HtmlClosingElement {
+                        l_angle_token: L_ANGLE@56..57 "<" [] [],
+                        slash_token: SLASH@57..58 "/" [] [],
+                        name: HtmlTagName {
+                            value_token: HTML_LITERAL@58..59 "p" [] [],
+                        },
+                        r_angle_token: R_ANGLE@59..60 ">" [] [],
+                    },
+                },
+                GlimmerTripleStashExpression {
+                    l_curly3_token_token: L_TRIPLE_CURLY@60..66 "{{{" [Newline("\n"), Whitespace("  ")] [],
+                    path: GlimmerPath {
+                        at_token_token: missing (optional),
+                        segments: GlimmerPathSegmentList [
+                            GlimmerPathSegment {
+                                value_token_token: IDENT@66..73 "helper" [] [Whitespace(" ")],
+                            },
+                        ],
+                    },
+                    arguments: GlimmerArgumentList [
+                        GlimmerPositionalArgument {
+                            value: GlimmerStringLiteral {
+                                value_token_token: HTML_STRING_LITERAL@73..83 "\"argument\"" [] [],
+                            },
+                        },
+                    ],
+                    r_curly3_token_token: R_TRIPLE_CURLY@83..86 "}}}" [] [],
+                },
+            ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@86..88 "<" [Newline("\n")] [],
+                slash_token: SLASH@88..89 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@89..92 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@92..93 ">" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@93..94 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..94
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..93
+    0: GLIMMER_TRIPLE_STASH_EXPRESSION@0..22
+      0: L_TRIPLE_CURLY@0..3 "{{{" [] []
+      1: GLIMMER_PATH@3..19
+        0: (empty)
+        1: GLIMMER_PATH_SEGMENT_LIST@3..19
+          0: GLIMMER_PATH_SEGMENT@3..7
+            0: IDENT@3..7 "this" [] []
+          1: DOT@7..8 "." [] []
+          2: GLIMMER_PATH_SEGMENT@8..19
+            0: IDENT@8..19 "htmlContent" [] []
+      2: GLIMMER_ARGUMENT_LIST@19..19
+      3: R_TRIPLE_CURLY@19..22 "}}}" [] []
+    1: HTML_ELEMENT@22..93
+      0: HTML_OPENING_ELEMENT@22..28
+        0: L_ANGLE@22..24 "<" [Newline("\n")] []
+        1: HTML_TAG_NAME@24..27
+          0: HTML_LITERAL@24..27 "div" [] []
+        2: HTML_ATTRIBUTE_LIST@27..27
+        3: R_ANGLE@27..28 ">" [] []
+      1: HTML_ELEMENT_LIST@28..86
+        0: HTML_ELEMENT@28..60
+          0: HTML_OPENING_ELEMENT@28..34
+            0: L_ANGLE@28..32 "<" [Newline("\n"), Whitespace("  ")] []
+            1: HTML_TAG_NAME@32..33
+              0: HTML_LITERAL@32..33 "p" [] []
+            2: HTML_ATTRIBUTE_LIST@33..33
+            3: R_ANGLE@33..34 ">" [] []
+          1: HTML_ELEMENT_LIST@34..56
+            0: GLIMMER_TRIPLE_STASH_EXPRESSION@34..56
+              0: L_TRIPLE_CURLY@34..37 "{{{" [] []
+              1: GLIMMER_PATH@37..53
+                0: (empty)
+                1: GLIMMER_PATH_SEGMENT_LIST@37..53
+                  0: GLIMMER_PATH_SEGMENT@37..53
+                    0: IDENT@37..53 "userProvidedHtml" [] []
+              2: GLIMMER_ARGUMENT_LIST@53..53
+              3: R_TRIPLE_CURLY@53..56 "}}}" [] []
+          2: HTML_CLOSING_ELEMENT@56..60
+            0: L_ANGLE@56..57 "<" [] []
+            1: SLASH@57..58 "/" [] []
+            2: HTML_TAG_NAME@58..59
+              0: HTML_LITERAL@58..59 "p" [] []
+            3: R_ANGLE@59..60 ">" [] []
+        1: GLIMMER_TRIPLE_STASH_EXPRESSION@60..86
+          0: L_TRIPLE_CURLY@60..66 "{{{" [Newline("\n"), Whitespace("  ")] []
+          1: GLIMMER_PATH@66..73
+            0: (empty)
+            1: GLIMMER_PATH_SEGMENT_LIST@66..73
+              0: GLIMMER_PATH_SEGMENT@66..73
+                0: IDENT@66..73 "helper" [] [Whitespace(" ")]
+          2: GLIMMER_ARGUMENT_LIST@73..83
+            0: GLIMMER_POSITIONAL_ARGUMENT@73..83
+              0: GLIMMER_STRING_LITERAL@73..83
+                0: HTML_STRING_LITERAL@73..83 "\"argument\"" [] []
+          3: R_TRIPLE_CURLY@83..86 "}}}" [] []
+      2: HTML_CLOSING_ELEMENT@86..93
+        0: L_ANGLE@86..88 "<" [Newline("\n")] []
+        1: SLASH@88..89 "/" [] []
+        2: HTML_TAG_NAME@89..92
+          0: HTML_LITERAL@89..92 "div" [] []
+        3: R_ANGLE@92..93 ">" [] []
+  4: EOF@93..94 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/spec_test.rs b/crates/biome_html_parser/tests/spec_test.rs
index 8cd3853bae03..036a89960f53 100644
--- a/crates/biome_html_parser/tests/spec_test.rs
+++ b/crates/biome_html_parser/tests/spec_test.rs
@@ -44,6 +44,7 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
         HtmlVariant::Astro => "astro",
         HtmlVariant::Vue => "vue",
         HtmlVariant::Svelte => "svelte",
+        HtmlVariant::Glimmer => "glimmer",
     };
     writeln!(
         snapshot,
@@ -142,10 +143,10 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
 #[ignore]
 #[test]
 pub fn quick_test() {
-    let code = r#"{@debug something, something, something}
+    let code = r#"{{{this.htmlContent}}}
     "#;
 
-    let root = parse_html(code, (&HtmlFileSource::svelte()).into());
+    let root = parse_html(code, (&HtmlFileSource::glimmer()).into());
     let syntax = root.syntax();
     dbg!(&syntax, root.diagnostics(), root.has_errors());
     if has_bogus_nodes_or_empty_slots(&syntax) {
diff --git a/crates/biome_html_parser/tests/spec_tests.rs b/crates/biome_html_parser/tests/spec_tests.rs
index 67a3919c310b..1951f8151371 100644
--- a/crates/biome_html_parser/tests/spec_tests.rs
+++ b/crates/biome_html_parser/tests/spec_tests.rs
@@ -6,11 +6,11 @@ use biome_html_syntax::ScriptType;
 use biome_rowan::AstNode;
 
 mod ok {
-    tests_macros::gen_tests! {"tests/html_specs/ok/**/*.{html,astro,vue,svelte}", crate::spec_test::run, "ok"}
+    tests_macros::gen_tests! {"tests/html_specs/ok/**/*.{html,astro,vue,svelte,gjs,gts}", crate::spec_test::run, "ok"}
 }
 
 mod error {
-    tests_macros::gen_tests! {"tests/html_specs/error/**/*.{html,astro,vue,svelte}", crate::spec_test::run, "error"}
+    tests_macros::gen_tests! {"tests/html_specs/error/**/*.{html,astro,vue,svelte,gjs,gts}", crate::spec_test::run, "error"}
 }
 
 #[test]
diff --git a/crates/biome_html_syntax/src/element_ext.rs b/crates/biome_html_syntax/src/element_ext.rs
index c3e08d5ef87e..378a0f0451bc 100644
--- a/crates/biome_html_syntax/src/element_ext.rs
+++ b/crates/biome_html_syntax/src/element_ext.rs
@@ -28,7 +28,9 @@ impl AnyHtmlElement {
             Self::AnyHtmlContent(_)
             | Self::HtmlBogusElement(_)
             | Self::HtmlSelfClosingElement(_)
-            | Self::HtmlCdataSection(_) => false,
+            | Self::HtmlCdataSection(_)
+            | Self::GlimmerMustacheComment(_)
+            | Self::GlimmerTripleStashExpression(_) => false,
             Self::HtmlElement(element) => element.is_javascript_tag(),
         }
     }
@@ -38,7 +40,9 @@ impl AnyHtmlElement {
             Self::AnyHtmlContent(_)
             | Self::HtmlBogusElement(_)
             | Self::HtmlSelfClosingElement(_)
-            | Self::HtmlCdataSection(_) => false,
+            | Self::HtmlCdataSection(_)
+            | Self::GlimmerMustacheComment(_)
+            | Self::GlimmerTripleStashExpression(_) => false,
             Self::HtmlElement(element) => element.is_style_tag(),
         }
     }
@@ -48,7 +52,11 @@ impl AnyHtmlElement {
             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,
+            Self::AnyHtmlContent(_)
+            | Self::HtmlBogusElement(_)
+            | Self::HtmlCdataSection(_)
+            | Self::GlimmerMustacheComment(_)
+            | Self::GlimmerTripleStashExpression(_) => None,
         }
     }
 
diff --git a/crates/biome_html_syntax/src/file_source.rs b/crates/biome_html_syntax/src/file_source.rs
index 2328c417f8d4..e5ea6027a085 100644
--- a/crates/biome_html_syntax/src/file_source.rs
+++ b/crates/biome_html_syntax/src/file_source.rs
@@ -31,6 +31,8 @@ pub enum HtmlVariant {
     Vue,
     /// Use this variant to parse a Svelte file
     Svelte,
+    /// Use this variant to parse a Glimmer file (.gjs, .gts)
+    Glimmer,
 }
 
 impl Default for HtmlVariant {
@@ -99,6 +101,16 @@ impl HtmlFileSource {
         }
     }
 
+    pub fn glimmer() -> Self {
+        Self {
+            variant: HtmlVariant::Glimmer,
+        }
+    }
+
+    pub const fn is_glimmer(&self) -> bool {
+        matches!(self.variant, HtmlVariant::Glimmer)
+    }
+
     /// Try to return the HTML file source corresponding to this file name from well-known files
     pub fn try_from_well_known(path: &Utf8Path) -> Result<Self, FileSourceError> {
         let Some(extension) = path.extension() else {
@@ -116,6 +128,7 @@ impl HtmlFileSource {
             "astro" => Ok(Self::astro()),
             "vue" => Ok(Self::vue()),
             "svelte" => Ok(Self::svelte()),
+            "gjs" | "gts" => Ok(Self::glimmer()),
             _ => Err(FileSourceError::UnknownExtension),
         }
     }
@@ -135,6 +148,7 @@ impl HtmlFileSource {
             "astro" => Ok(Self::astro()),
             "vuejs" | "vue" => Ok(Self::vue()),
             "svelte" => Ok(Self::svelte()),
+            "glimmer" | "glimmer-js" | "glimmer-ts" => Ok(Self::glimmer()),
             _ => Err(FileSourceError::UnknownLanguageId),
         }
     }
@@ -156,3 +170,44 @@ impl TryFrom<&Utf8Path> for HtmlFileSource {
         Self::try_from_extension(&extension.to_ascii_lowercase_cow())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_glimmer_variant() {
+        let glimmer_source = HtmlFileSource::glimmer();
+        assert!(glimmer_source.is_glimmer());
+        assert!(!glimmer_source.is_html());
+        assert!(!glimmer_source.is_vue());
+        assert!(!glimmer_source.is_svelte());
+        assert!(!glimmer_source.is_astro());
+    }
+
+    #[test]
+    fn test_glimmer_from_extension() {
+        let result = HtmlFileSource::try_from_extension("gjs");
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_glimmer());
+
+        let result = HtmlFileSource::try_from_extension("gts");
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_glimmer());
+    }
+
+    #[test]
+    fn test_glimmer_from_language_id() {
+        let result = HtmlFileSource::try_from_language_id("glimmer");
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_glimmer());
+
+        let result = HtmlFileSource::try_from_language_id("glimmer-js");
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_glimmer());
+
+        let result = HtmlFileSource::try_from_language_id("glimmer-ts");
+        assert!(result.is_ok());
+        assert!(result.unwrap().is_glimmer());
+    }
+}
diff --git a/crates/biome_html_syntax/src/generated/kind.rs b/crates/biome_html_syntax/src/generated/kind.rs
index abf41fbd3280..e1803eaeab78 100644
--- a/crates/biome_html_syntax/src/generated/kind.rs
+++ b/crates/biome_html_syntax/src/generated/kind.rs
@@ -30,6 +30,14 @@ pub enum HtmlSyntaxKind {
     SV_CURLY_SLASH,
     SV_CURLY_COLON,
     COMMA,
+    HASH,
+    DOT,
+    PIPE,
+    AT,
+    DOTDOTDOT,
+    L_PAREN,
+    R_PAREN,
+    COLON,
     NULL_KW,
     TRUE_KW,
     FALSE_KW,
@@ -44,6 +52,9 @@ pub enum HtmlSyntaxKind {
     IDENT,
     HTML_IDENT,
     SVELTE_IDENT,
+    MUSTACHE_COMMENT,
+    L_TRIPLE_CURLY,
+    R_TRIPLE_CURLY,
     HTML_ROOT,
     HTML_DIRECTIVE,
     HTML_SELF_CLOSING_TAG,
@@ -70,12 +81,36 @@ pub enum HtmlSyntaxKind {
     SVELTE_DEBUG_BLOCK,
     SVELTE_BINDING_LIST,
     SVELTE_NAME,
+    GLIMMER_MUSTACHE_EXPRESSION,
+    GLIMMER_MUSTACHE_COMMENT,
+    GLIMMER_TRIPLE_STASH_EXPRESSION,
+    GLIMMER_BLOCK_HELPER,
+    GLIMMER_BLOCK_HELPER_OPENING,
+    GLIMMER_BLOCK_HELPER_CLOSING,
+    GLIMMER_BLOCK_PARAMS,
+    GLIMMER_BLOCK_PARAM_LIST,
+    GLIMMER_BLOCK_PARAM,
+    GLIMMER_PATH,
+    GLIMMER_PATH_SEGMENT_LIST,
+    GLIMMER_PATH_SEGMENT,
+    GLIMMER_ARGUMENT_LIST,
+    GLIMMER_POSITIONAL_ARGUMENT,
+    GLIMMER_NAMED_ARGUMENT,
+    GLIMMER_SUBEXPRESSION,
+    GLIMMER_STRING_LITERAL,
+    GLIMMER_LITERAL,
+    GLIMMER_SPLATTRIBUTE,
+    GLIMMER_ELEMENT_MODIFIER,
+    GLIMMER_NAMED_BLOCK,
+    GLIMMER_NAMED_BLOCK_OPENING,
+    GLIMMER_NAMED_BLOCK_CLOSING,
     HTML_BOGUS,
     HTML_BOGUS_ELEMENT,
     HTML_BOGUS_ATTRIBUTE,
     HTML_BOGUS_TEXT_EXPRESSION,
     ASTRO_BOGUS_FRONTMATTER,
     SVELTE_BOGUS_BLOCK,
+    GLIMMER_BOGUS_EXPRESSION,
     #[doc(hidden)]
     __LAST,
 }
@@ -102,6 +137,14 @@ impl HtmlSyntaxKind {
                 | SV_CURLY_SLASH
                 | SV_CURLY_COLON
                 | COMMA
+                | HASH
+                | DOT
+                | PIPE
+                | AT
+                | DOTDOTDOT
+                | L_PAREN
+                | R_PAREN
+                | COLON
         )
     }
     pub const fn is_literal(self) -> bool {
@@ -110,7 +153,12 @@ impl HtmlSyntaxKind {
     pub const fn is_list(self) -> bool {
         matches!(
             self,
-            HTML_ELEMENT_LIST | HTML_ATTRIBUTE_LIST | SVELTE_BINDING_LIST
+            HTML_ELEMENT_LIST
+                | HTML_ATTRIBUTE_LIST
+                | SVELTE_BINDING_LIST
+                | GLIMMER_BLOCK_PARAM_LIST
+                | GLIMMER_PATH_SEGMENT_LIST
+                | GLIMMER_ARGUMENT_LIST
         )
     }
     pub fn from_keyword(ident: &str) -> Option<Self> {
@@ -145,6 +193,14 @@ impl HtmlSyntaxKind {
             SV_CURLY_SLASH => "{/",
             SV_CURLY_COLON => "{:",
             COMMA => ",",
+            HASH => "#",
+            DOT => ".",
+            PIPE => "|",
+            AT => "@",
+            DOTDOTDOT => "...",
+            L_PAREN => "(",
+            R_PAREN => ")",
+            COLON => ":",
             NULL_KW => "null",
             TRUE_KW => "true",
             FALSE_KW => "false",
@@ -160,4 +216,4 @@ impl HtmlSyntaxKind {
 }
 #[doc = r" Utility macro for creating a SyntaxKind through simple macro syntax"]
 #[macro_export]
-macro_rules ! T { [<] => { $ crate :: HtmlSyntaxKind :: L_ANGLE } ; [>] => { $ crate :: HtmlSyntaxKind :: R_ANGLE } ; [/] => { $ crate :: HtmlSyntaxKind :: SLASH } ; [=] => { $ crate :: HtmlSyntaxKind :: EQ } ; [!] => { $ crate :: HtmlSyntaxKind :: BANG } ; [-] => { $ crate :: HtmlSyntaxKind :: MINUS } ; ["<![CDATA["] => { $ crate :: HtmlSyntaxKind :: CDATA_START } ; ["]]>"] => { $ crate :: HtmlSyntaxKind :: CDATA_END } ; [---] => { $ crate :: HtmlSyntaxKind :: FENCE } ; ['{'] => { $ crate :: HtmlSyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: HtmlSyntaxKind :: R_CURLY } ; ["{{"] => { $ crate :: HtmlSyntaxKind :: L_DOUBLE_CURLY } ; ["}}"] => { $ crate :: HtmlSyntaxKind :: R_DOUBLE_CURLY } ; ["{@"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_AT } ; ["{#"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_HASH } ; ["{/"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_SLASH } ; ["{:"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_COLON } ; [,] => { $ crate :: HtmlSyntaxKind :: COMMA } ; [null] => { $ crate :: HtmlSyntaxKind :: NULL_KW } ; [true] => { $ crate :: HtmlSyntaxKind :: TRUE_KW } ; [false] => { $ crate :: HtmlSyntaxKind :: FALSE_KW } ; [doctype] => { $ crate :: HtmlSyntaxKind :: DOCTYPE_KW } ; [html] => { $ crate :: HtmlSyntaxKind :: HTML_KW } ; [debug] => { $ crate :: HtmlSyntaxKind :: DEBUG_KW } ; [ident] => { $ crate :: HtmlSyntaxKind :: IDENT } ; [EOF] => { $ crate :: HtmlSyntaxKind :: EOF } ; [UNICODE_BOM] => { $ crate :: HtmlSyntaxKind :: UNICODE_BOM } ; [#] => { $ crate :: HtmlSyntaxKind :: HASH } ; }
+macro_rules ! T { [<] => { $ crate :: HtmlSyntaxKind :: L_ANGLE } ; [>] => { $ crate :: HtmlSyntaxKind :: R_ANGLE } ; [/] => { $ crate :: HtmlSyntaxKind :: SLASH } ; [=] => { $ crate :: HtmlSyntaxKind :: EQ } ; [!] => { $ crate :: HtmlSyntaxKind :: BANG } ; [-] => { $ crate :: HtmlSyntaxKind :: MINUS } ; ["<![CDATA["] => { $ crate :: HtmlSyntaxKind :: CDATA_START } ; ["]]>"] => { $ crate :: HtmlSyntaxKind :: CDATA_END } ; [---] => { $ crate :: HtmlSyntaxKind :: FENCE } ; ['{'] => { $ crate :: HtmlSyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: HtmlSyntaxKind :: R_CURLY } ; ["{{"] => { $ crate :: HtmlSyntaxKind :: L_DOUBLE_CURLY } ; ["}}"] => { $ crate :: HtmlSyntaxKind :: R_DOUBLE_CURLY } ; ["{@"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_AT } ; ["{#"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_HASH } ; ["{/"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_SLASH } ; ["{:"] => { $ crate :: HtmlSyntaxKind :: SV_CURLY_COLON } ; [,] => { $ crate :: HtmlSyntaxKind :: COMMA } ; [#] => { $ crate :: HtmlSyntaxKind :: HASH } ; [.] => { $ crate :: HtmlSyntaxKind :: DOT } ; [|] => { $ crate :: HtmlSyntaxKind :: PIPE } ; [@] => { $ crate :: HtmlSyntaxKind :: AT } ; [...] => { $ crate :: HtmlSyntaxKind :: DOTDOTDOT } ; ['('] => { $ crate :: HtmlSyntaxKind :: L_PAREN } ; [')'] => { $ crate :: HtmlSyntaxKind :: R_PAREN } ; [:] => { $ crate :: HtmlSyntaxKind :: COLON } ; [null] => { $ crate :: HtmlSyntaxKind :: NULL_KW } ; [true] => { $ crate :: HtmlSyntaxKind :: TRUE_KW } ; [false] => { $ crate :: HtmlSyntaxKind :: FALSE_KW } ; [doctype] => { $ crate :: HtmlSyntaxKind :: DOCTYPE_KW } ; [html] => { $ crate :: HtmlSyntaxKind :: HTML_KW } ; [debug] => { $ crate :: HtmlSyntaxKind :: DEBUG_KW } ; [ident] => { $ crate :: HtmlSyntaxKind :: IDENT } ; [EOF] => { $ crate :: HtmlSyntaxKind :: EOF } ; [UNICODE_BOM] => { $ crate :: HtmlSyntaxKind :: UNICODE_BOM } ; [#] => { $ crate :: HtmlSyntaxKind :: HASH } ; }
diff --git a/crates/biome_html_syntax/src/generated/macros.rs b/crates/biome_html_syntax/src/generated/macros.rs
index 104c566738e0..0a039462d9ac 100644
--- a/crates/biome_html_syntax/src/generated/macros.rs
+++ b/crates/biome_html_syntax/src/generated/macros.rs
@@ -24,6 +24,91 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::AstroFrontmatterElement::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_HELPER => {
+                    let $pattern = unsafe { $crate::GlimmerBlockHelper::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_HELPER_CLOSING => {
+                    let $pattern =
+                        unsafe { $crate::GlimmerBlockHelperClosing::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_HELPER_OPENING => {
+                    let $pattern =
+                        unsafe { $crate::GlimmerBlockHelperOpening::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_PARAM => {
+                    let $pattern = unsafe { $crate::GlimmerBlockParam::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_PARAMS => {
+                    let $pattern = unsafe { $crate::GlimmerBlockParams::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_ELEMENT_MODIFIER => {
+                    let $pattern = unsafe { $crate::GlimmerElementModifier::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_LITERAL => {
+                    let $pattern = unsafe { $crate::GlimmerLiteral::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_MUSTACHE_COMMENT => {
+                    let $pattern = unsafe { $crate::GlimmerMustacheComment::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_MUSTACHE_EXPRESSION => {
+                    let $pattern =
+                        unsafe { $crate::GlimmerMustacheExpression::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_NAMED_ARGUMENT => {
+                    let $pattern = unsafe { $crate::GlimmerNamedArgument::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_NAMED_BLOCK => {
+                    let $pattern = unsafe { $crate::GlimmerNamedBlock::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_NAMED_BLOCK_CLOSING => {
+                    let $pattern = unsafe { $crate::GlimmerNamedBlockClosing::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_NAMED_BLOCK_OPENING => {
+                    let $pattern = unsafe { $crate::GlimmerNamedBlockOpening::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_PATH => {
+                    let $pattern = unsafe { $crate::GlimmerPath::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_PATH_SEGMENT => {
+                    let $pattern = unsafe { $crate::GlimmerPathSegment::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_POSITIONAL_ARGUMENT => {
+                    let $pattern =
+                        unsafe { $crate::GlimmerPositionalArgument::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_SPLATTRIBUTE => {
+                    let $pattern = unsafe { $crate::GlimmerSplattribute::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_STRING_LITERAL => {
+                    let $pattern = unsafe { $crate::GlimmerStringLiteral::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_SUBEXPRESSION => {
+                    let $pattern = unsafe { $crate::GlimmerSubexpression::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_TRIPLE_STASH_EXPRESSION => {
+                    let $pattern =
+                        unsafe { $crate::GlimmerTripleStashExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_ATTRIBUTE => {
                     let $pattern = unsafe { $crate::HtmlAttribute::new_unchecked(node) };
                     $body
@@ -105,6 +190,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::AstroBogusFrontmatter::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::GLIMMER_BOGUS_EXPRESSION => {
+                    let $pattern = unsafe { $crate::GlimmerBogusExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_BOGUS => {
                     let $pattern = unsafe { $crate::HtmlBogus::new_unchecked(node) };
                     $body
@@ -125,6 +214,18 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::SvelteBogusBlock::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::GLIMMER_ARGUMENT_LIST => {
+                    let $pattern = unsafe { $crate::GlimmerArgumentList::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_BLOCK_PARAM_LIST => {
+                    let $pattern = unsafe { $crate::GlimmerBlockParamList::new_unchecked(node) };
+                    $body
+                }
+                $crate::HtmlSyntaxKind::GLIMMER_PATH_SEGMENT_LIST => {
+                    let $pattern = unsafe { $crate::GlimmerPathSegmentList::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_ATTRIBUTE_LIST => {
                     let $pattern = unsafe { $crate::HtmlAttributeList::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 188d31eeada9..199a8fa33098 100644
--- a/crates/biome_html_syntax/src/generated/nodes.rs
+++ b/crates/biome_html_syntax/src/generated/nodes.rs
@@ -100,10 +100,10 @@ pub struct AstroFrontmatterElementFields {
     pub r_fence_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlAttribute {
+pub struct GlimmerBlockHelper {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlAttribute {
+impl GlimmerBlockHelper {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -113,20 +113,24 @@ impl HtmlAttribute {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlAttributeFields {
-        HtmlAttributeFields {
-            name: self.name(),
-            initializer: self.initializer(),
+    pub fn as_fields(&self) -> GlimmerBlockHelperFields {
+        GlimmerBlockHelperFields {
+            opening: self.opening(),
+            children: self.children(),
+            closing: self.closing(),
         }
     }
-    pub fn name(&self) -> SyntaxResult<HtmlAttributeName> {
+    pub fn opening(&self) -> SyntaxResult<GlimmerBlockHelperOpening> {
         support::required_node(&self.syntax, 0usize)
     }
-    pub fn initializer(&self) -> Option<HtmlAttributeInitializerClause> {
-        support::node(&self.syntax, 1usize)
+    pub fn children(&self) -> HtmlElementList {
+        support::list(&self.syntax, 1usize)
+    }
+    pub fn closing(&self) -> SyntaxResult<GlimmerBlockHelperClosing> {
+        support::required_node(&self.syntax, 2usize)
     }
 }
-impl Serialize for HtmlAttribute {
+impl Serialize for GlimmerBlockHelper {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -135,15 +139,16 @@ impl Serialize for HtmlAttribute {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlAttributeFields {
-    pub name: SyntaxResult<HtmlAttributeName>,
-    pub initializer: Option<HtmlAttributeInitializerClause>,
+pub struct GlimmerBlockHelperFields {
+    pub opening: SyntaxResult<GlimmerBlockHelperOpening>,
+    pub children: HtmlElementList,
+    pub closing: SyntaxResult<GlimmerBlockHelperClosing>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlAttributeInitializerClause {
+pub struct GlimmerBlockHelperClosing {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlAttributeInitializerClause {
+impl GlimmerBlockHelperClosing {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -153,20 +158,28 @@ impl HtmlAttributeInitializerClause {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlAttributeInitializerClauseFields {
-        HtmlAttributeInitializerClauseFields {
-            eq_token: self.eq_token(),
-            value: self.value(),
+    pub fn as_fields(&self) -> GlimmerBlockHelperClosingFields {
+        GlimmerBlockHelperClosingFields {
+            l_curly2_token_token: self.l_curly2_token_token(),
+            slash_token_token: self.slash_token_token(),
+            helper: self.helper(),
+            r_curly2_token_token: self.r_curly2_token_token(),
         }
     }
-    pub fn eq_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn value(&self) -> SyntaxResult<AnyHtmlAttributeInitializer> {
-        support::required_node(&self.syntax, 1usize)
+    pub fn slash_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn helper(&self) -> SyntaxResult<GlimmerPath> {
+        support::required_node(&self.syntax, 2usize)
+    }
+    pub fn r_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
     }
 }
-impl Serialize for HtmlAttributeInitializerClause {
+impl Serialize for GlimmerBlockHelperClosing {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -175,15 +188,17 @@ impl Serialize for HtmlAttributeInitializerClause {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlAttributeInitializerClauseFields {
-    pub eq_token: SyntaxResult<SyntaxToken>,
-    pub value: SyntaxResult<AnyHtmlAttributeInitializer>,
+pub struct GlimmerBlockHelperClosingFields {
+    pub l_curly2_token_token: SyntaxResult<SyntaxToken>,
+    pub slash_token_token: SyntaxResult<SyntaxToken>,
+    pub helper: SyntaxResult<GlimmerPath>,
+    pub r_curly2_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlAttributeName {
+pub struct GlimmerBlockHelperOpening {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlAttributeName {
+impl GlimmerBlockHelperOpening {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -193,16 +208,36 @@ impl HtmlAttributeName {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlAttributeNameFields {
-        HtmlAttributeNameFields {
-            value_token: self.value_token(),
+    pub fn as_fields(&self) -> GlimmerBlockHelperOpeningFields {
+        GlimmerBlockHelperOpeningFields {
+            l_curly2_token_token: self.l_curly2_token_token(),
+            hash_token_token: self.hash_token_token(),
+            helper: self.helper(),
+            arguments: self.arguments(),
+            block_params: self.block_params(),
+            r_curly2_token_token: self.r_curly2_token_token(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
+    pub fn hash_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn helper(&self) -> SyntaxResult<GlimmerPath> {
+        support::required_node(&self.syntax, 2usize)
+    }
+    pub fn arguments(&self) -> GlimmerArgumentList {
+        support::list(&self.syntax, 3usize)
+    }
+    pub fn block_params(&self) -> Option<GlimmerBlockParams> {
+        support::node(&self.syntax, 4usize)
+    }
+    pub fn r_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 5usize)
+    }
 }
-impl Serialize for HtmlAttributeName {
+impl Serialize for GlimmerBlockHelperOpening {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -211,14 +246,19 @@ impl Serialize for HtmlAttributeName {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlAttributeNameFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerBlockHelperOpeningFields {
+    pub l_curly2_token_token: SyntaxResult<SyntaxToken>,
+    pub hash_token_token: SyntaxResult<SyntaxToken>,
+    pub helper: SyntaxResult<GlimmerPath>,
+    pub arguments: GlimmerArgumentList,
+    pub block_params: Option<GlimmerBlockParams>,
+    pub r_curly2_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlCdataSection {
+pub struct GlimmerBlockParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlCdataSection {
+impl GlimmerBlockParam {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -228,24 +268,16 @@ impl HtmlCdataSection {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlCdataSectionFields {
-        HtmlCdataSectionFields {
-            cdata_start_token: self.cdata_start_token(),
-            content_token: self.content_token(),
-            cdata_end_token: self.cdata_end_token(),
+    pub fn as_fields(&self) -> GlimmerBlockParamFields {
+        GlimmerBlockParamFields {
+            name_token_token: self.name_token_token(),
         }
     }
-    pub fn cdata_start_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn name_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn content_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 1usize)
-    }
-    pub fn cdata_end_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
-    }
 }
-impl Serialize for HtmlCdataSection {
+impl Serialize for GlimmerBlockParam {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -254,16 +286,14 @@ impl Serialize for HtmlCdataSection {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlCdataSectionFields {
-    pub cdata_start_token: SyntaxResult<SyntaxToken>,
-    pub content_token: SyntaxResult<SyntaxToken>,
-    pub cdata_end_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerBlockParamFields {
+    pub name_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlClosingElement {
+pub struct GlimmerBlockParams {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlClosingElement {
+impl GlimmerBlockParams {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -273,28 +303,28 @@ impl HtmlClosingElement {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlClosingElementFields {
-        HtmlClosingElementFields {
-            l_angle_token: self.l_angle_token(),
-            slash_token: self.slash_token(),
-            name: self.name(),
-            r_angle_token: self.r_angle_token(),
+    pub fn as_fields(&self) -> GlimmerBlockParamsFields {
+        GlimmerBlockParamsFields {
+            as_token_token: self.as_token_token(),
+            l_pipe_token_token: self.l_pipe_token_token(),
+            params: self.params(),
+            r_pipe_token_token: self.r_pipe_token_token(),
         }
     }
-    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn as_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn slash_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_pipe_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 1usize)
     }
-    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
-        support::required_node(&self.syntax, 2usize)
+    pub fn params(&self) -> GlimmerBlockParamList {
+        support::list(&self.syntax, 2usize)
     }
-    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn r_pipe_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 3usize)
     }
 }
-impl Serialize for HtmlClosingElement {
+impl Serialize for GlimmerBlockParams {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -303,17 +333,17 @@ impl Serialize for HtmlClosingElement {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlClosingElementFields {
-    pub l_angle_token: SyntaxResult<SyntaxToken>,
-    pub slash_token: SyntaxResult<SyntaxToken>,
-    pub name: SyntaxResult<HtmlTagName>,
-    pub r_angle_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerBlockParamsFields {
+    pub as_token_token: SyntaxResult<SyntaxToken>,
+    pub l_pipe_token_token: SyntaxResult<SyntaxToken>,
+    pub params: GlimmerBlockParamList,
+    pub r_pipe_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlContent {
+pub struct GlimmerElementModifier {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlContent {
+impl GlimmerElementModifier {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -323,16 +353,28 @@ impl HtmlContent {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlContentFields {
-        HtmlContentFields {
-            value_token: self.value_token(),
+    pub fn as_fields(&self) -> GlimmerElementModifierFields {
+        GlimmerElementModifierFields {
+            l_curly2_token_token: self.l_curly2_token_token(),
+            path: self.path(),
+            arguments: self.arguments(),
+            r_curly2_token_token: self.r_curly2_token_token(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
+    pub fn path(&self) -> SyntaxResult<GlimmerPath> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn arguments(&self) -> GlimmerArgumentList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn r_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
+    }
 }
-impl Serialize for HtmlContent {
+impl Serialize for GlimmerElementModifier {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -341,14 +383,17 @@ impl Serialize for HtmlContent {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlContentFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerElementModifierFields {
+    pub l_curly2_token_token: SyntaxResult<SyntaxToken>,
+    pub path: SyntaxResult<GlimmerPath>,
+    pub arguments: GlimmerArgumentList,
+    pub r_curly2_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlDirective {
+pub struct GlimmerLiteral {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlDirective {
+impl GlimmerLiteral {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -358,44 +403,51 @@ impl HtmlDirective {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlDirectiveFields {
-        HtmlDirectiveFields {
-            l_angle_token: self.l_angle_token(),
-            excl_token: self.excl_token(),
-            doctype_token: self.doctype_token(),
-            html_token: self.html_token(),
-            quirk_token: self.quirk_token(),
-            public_id_token: self.public_id_token(),
-            system_id_token: self.system_id_token(),
-            r_angle_token: self.r_angle_token(),
+    pub fn as_fields(&self) -> GlimmerLiteralFields {
+        GlimmerLiteralFields {
+            value_token_token: self.value_token_token(),
         }
     }
-    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn value_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn excl_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 1usize)
-    }
-    pub fn doctype_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
-    }
-    pub fn html_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 3usize)
-    }
-    pub fn quirk_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 4usize)
+}
+impl Serialize for GlimmerLiteral {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
     }
-    pub fn public_id_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 5usize)
+}
+#[derive(Serialize)]
+pub struct GlimmerLiteralFields {
+    pub value_token_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct GlimmerMustacheComment {
+    pub(crate) syntax: SyntaxNode,
+}
+impl GlimmerMustacheComment {
+    #[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 system_id_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 6usize)
+    pub fn as_fields(&self) -> GlimmerMustacheCommentFields {
+        GlimmerMustacheCommentFields {
+            comment_token_token: self.comment_token_token(),
+        }
     }
-    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 7usize)
+    pub fn comment_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
     }
 }
-impl Serialize for HtmlDirective {
+impl Serialize for GlimmerMustacheComment {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -404,21 +456,14 @@ impl Serialize for HtmlDirective {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlDirectiveFields {
-    pub l_angle_token: SyntaxResult<SyntaxToken>,
-    pub excl_token: SyntaxResult<SyntaxToken>,
-    pub doctype_token: SyntaxResult<SyntaxToken>,
-    pub html_token: Option<SyntaxToken>,
-    pub quirk_token: Option<SyntaxToken>,
-    pub public_id_token: Option<SyntaxToken>,
-    pub system_id_token: Option<SyntaxToken>,
-    pub r_angle_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerMustacheCommentFields {
+    pub comment_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlDoubleTextExpression {
+pub struct GlimmerMustacheExpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlDoubleTextExpression {
+impl GlimmerMustacheExpression {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -428,24 +473,28 @@ impl HtmlDoubleTextExpression {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlDoubleTextExpressionFields {
-        HtmlDoubleTextExpressionFields {
-            l_double_curly_token: self.l_double_curly_token(),
-            expression: self.expression(),
-            r_double_curly_token: self.r_double_curly_token(),
+    pub fn as_fields(&self) -> GlimmerMustacheExpressionFields {
+        GlimmerMustacheExpressionFields {
+            l_curly2_token_token: self.l_curly2_token_token(),
+            path: self.path(),
+            arguments: self.arguments(),
+            r_curly2_token_token: self.r_curly2_token_token(),
         }
     }
-    pub fn l_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+    pub fn path(&self) -> SyntaxResult<GlimmerPath> {
         support::required_node(&self.syntax, 1usize)
     }
-    pub fn r_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
+    pub fn arguments(&self) -> GlimmerArgumentList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn r_curly2_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
     }
 }
-impl Serialize for HtmlDoubleTextExpression {
+impl Serialize for GlimmerMustacheExpression {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -454,16 +503,17 @@ impl Serialize for HtmlDoubleTextExpression {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlDoubleTextExpressionFields {
-    pub l_double_curly_token: SyntaxResult<SyntaxToken>,
-    pub expression: SyntaxResult<HtmlTextExpression>,
-    pub r_double_curly_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerMustacheExpressionFields {
+    pub l_curly2_token_token: SyntaxResult<SyntaxToken>,
+    pub path: SyntaxResult<GlimmerPath>,
+    pub arguments: GlimmerArgumentList,
+    pub r_curly2_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlElement {
+pub struct GlimmerNamedArgument {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlElement {
+impl GlimmerNamedArgument {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -473,24 +523,24 @@ impl HtmlElement {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlElementFields {
-        HtmlElementFields {
-            opening_element: self.opening_element(),
-            children: self.children(),
-            closing_element: self.closing_element(),
+    pub fn as_fields(&self) -> GlimmerNamedArgumentFields {
+        GlimmerNamedArgumentFields {
+            name_token_token: self.name_token_token(),
+            eq_token_token: self.eq_token_token(),
+            value: self.value(),
         }
     }
-    pub fn opening_element(&self) -> SyntaxResult<HtmlOpeningElement> {
-        support::required_node(&self.syntax, 0usize)
+    pub fn name_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
     }
-    pub fn children(&self) -> HtmlElementList {
-        support::list(&self.syntax, 1usize)
+    pub fn eq_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
     }
-    pub fn closing_element(&self) -> SyntaxResult<HtmlClosingElement> {
+    pub fn value(&self) -> SyntaxResult<AnyGlimmerArgumentValue> {
         support::required_node(&self.syntax, 2usize)
     }
 }
-impl Serialize for HtmlElement {
+impl Serialize for GlimmerNamedArgument {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -499,16 +549,16 @@ impl Serialize for HtmlElement {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlElementFields {
-    pub opening_element: SyntaxResult<HtmlOpeningElement>,
-    pub children: HtmlElementList,
-    pub closing_element: SyntaxResult<HtmlClosingElement>,
+pub struct GlimmerNamedArgumentFields {
+    pub name_token_token: SyntaxResult<SyntaxToken>,
+    pub eq_token_token: SyntaxResult<SyntaxToken>,
+    pub value: SyntaxResult<AnyGlimmerArgumentValue>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlEmbeddedContent {
+pub struct GlimmerNamedBlock {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlEmbeddedContent {
+impl GlimmerNamedBlock {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -518,16 +568,24 @@ impl HtmlEmbeddedContent {
     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 as_fields(&self) -> GlimmerNamedBlockFields {
+        GlimmerNamedBlockFields {
+            opening: self.opening(),
+            children: self.children(),
+            closing: self.closing(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 0usize)
+    pub fn opening(&self) -> SyntaxResult<GlimmerNamedBlockOpening> {
+        support::required_node(&self.syntax, 0usize)
+    }
+    pub fn children(&self) -> HtmlElementList {
+        support::list(&self.syntax, 1usize)
+    }
+    pub fn closing(&self) -> SyntaxResult<GlimmerNamedBlockClosing> {
+        support::required_node(&self.syntax, 2usize)
     }
 }
-impl Serialize for HtmlEmbeddedContent {
+impl Serialize for GlimmerNamedBlock {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -536,14 +594,16 @@ impl Serialize for HtmlEmbeddedContent {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlEmbeddedContentFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerNamedBlockFields {
+    pub opening: SyntaxResult<GlimmerNamedBlockOpening>,
+    pub children: HtmlElementList,
+    pub closing: SyntaxResult<GlimmerNamedBlockClosing>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlOpeningElement {
+pub struct GlimmerNamedBlockClosing {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlOpeningElement {
+impl GlimmerNamedBlockClosing {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -553,28 +613,32 @@ impl HtmlOpeningElement {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlOpeningElementFields {
-        HtmlOpeningElementFields {
-            l_angle_token: self.l_angle_token(),
-            name: self.name(),
-            attributes: self.attributes(),
-            r_angle_token: self.r_angle_token(),
+    pub fn as_fields(&self) -> GlimmerNamedBlockClosingFields {
+        GlimmerNamedBlockClosingFields {
+            l_angle_token_token: self.l_angle_token_token(),
+            slash_token_token: self.slash_token_token(),
+            colon_token_token: self.colon_token_token(),
+            name_token_token: self.name_token_token(),
+            r_angle_token_token: self.r_angle_token_token(),
         }
     }
-    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_angle_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
-        support::required_node(&self.syntax, 1usize)
+    pub fn slash_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
     }
-    pub fn attributes(&self) -> HtmlAttributeList {
-        support::list(&self.syntax, 2usize)
+    pub fn colon_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
     }
-    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn name_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 3usize)
     }
+    pub fn r_angle_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 4usize)
+    }
 }
-impl Serialize for HtmlOpeningElement {
+impl Serialize for GlimmerNamedBlockClosing {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -583,17 +647,18 @@ impl Serialize for HtmlOpeningElement {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlOpeningElementFields {
-    pub l_angle_token: SyntaxResult<SyntaxToken>,
-    pub name: SyntaxResult<HtmlTagName>,
-    pub attributes: HtmlAttributeList,
-    pub r_angle_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerNamedBlockClosingFields {
+    pub l_angle_token_token: SyntaxResult<SyntaxToken>,
+    pub slash_token_token: SyntaxResult<SyntaxToken>,
+    pub colon_token_token: SyntaxResult<SyntaxToken>,
+    pub name_token_token: SyntaxResult<SyntaxToken>,
+    pub r_angle_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlRoot {
+pub struct GlimmerNamedBlockOpening {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlRoot {
+impl GlimmerNamedBlockOpening {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -603,32 +668,32 @@ impl HtmlRoot {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlRootFields {
-        HtmlRootFields {
-            bom_token: self.bom_token(),
-            frontmatter: self.frontmatter(),
-            directive: self.directive(),
-            html: self.html(),
-            eof_token: self.eof_token(),
+    pub fn as_fields(&self) -> GlimmerNamedBlockOpeningFields {
+        GlimmerNamedBlockOpeningFields {
+            l_angle_token_token: self.l_angle_token_token(),
+            colon_token_token: self.colon_token_token(),
+            name_token_token: self.name_token_token(),
+            attributes: self.attributes(),
+            r_angle_token_token: self.r_angle_token_token(),
         }
     }
-    pub fn bom_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 0usize)
+    pub fn l_angle_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
     }
-    pub fn frontmatter(&self) -> Option<AnyAstroFrontmatterElement> {
-        support::node(&self.syntax, 1usize)
+    pub fn colon_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
     }
-    pub fn directive(&self) -> Option<HtmlDirective> {
-        support::node(&self.syntax, 2usize)
+    pub fn name_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
     }
-    pub fn html(&self) -> HtmlElementList {
+    pub fn attributes(&self) -> HtmlAttributeList {
         support::list(&self.syntax, 3usize)
     }
-    pub fn eof_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn r_angle_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 4usize)
     }
 }
-impl Serialize for HtmlRoot {
+impl Serialize for GlimmerNamedBlockOpening {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -637,18 +702,18 @@ impl Serialize for HtmlRoot {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlRootFields {
-    pub bom_token: Option<SyntaxToken>,
-    pub frontmatter: Option<AnyAstroFrontmatterElement>,
-    pub directive: Option<HtmlDirective>,
-    pub html: HtmlElementList,
-    pub eof_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerNamedBlockOpeningFields {
+    pub l_angle_token_token: SyntaxResult<SyntaxToken>,
+    pub colon_token_token: SyntaxResult<SyntaxToken>,
+    pub name_token_token: SyntaxResult<SyntaxToken>,
+    pub attributes: HtmlAttributeList,
+    pub r_angle_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlSelfClosingElement {
+pub struct GlimmerPath {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlSelfClosingElement {
+impl GlimmerPath {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -658,32 +723,20 @@ impl HtmlSelfClosingElement {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlSelfClosingElementFields {
-        HtmlSelfClosingElementFields {
-            l_angle_token: self.l_angle_token(),
-            name: self.name(),
-            attributes: self.attributes(),
-            slash_token: self.slash_token(),
-            r_angle_token: self.r_angle_token(),
+    pub fn as_fields(&self) -> GlimmerPathFields {
+        GlimmerPathFields {
+            at_token_token: self.at_token_token(),
+            segments: self.segments(),
         }
     }
-    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 0usize)
-    }
-    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
-        support::required_node(&self.syntax, 1usize)
-    }
-    pub fn attributes(&self) -> HtmlAttributeList {
-        support::list(&self.syntax, 2usize)
-    }
-    pub fn slash_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, 3usize)
+    pub fn at_token_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 0usize)
     }
-    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 4usize)
+    pub fn segments(&self) -> GlimmerPathSegmentList {
+        support::list(&self.syntax, 1usize)
     }
 }
-impl Serialize for HtmlSelfClosingElement {
+impl Serialize for GlimmerPath {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -692,18 +745,15 @@ impl Serialize for HtmlSelfClosingElement {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlSelfClosingElementFields {
-    pub l_angle_token: SyntaxResult<SyntaxToken>,
-    pub name: SyntaxResult<HtmlTagName>,
-    pub attributes: HtmlAttributeList,
-    pub slash_token: Option<SyntaxToken>,
-    pub r_angle_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerPathFields {
+    pub at_token_token: Option<SyntaxToken>,
+    pub segments: GlimmerPathSegmentList,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlSingleTextExpression {
+pub struct GlimmerPathSegment {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlSingleTextExpression {
+impl GlimmerPathSegment {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -713,24 +763,16 @@ impl HtmlSingleTextExpression {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlSingleTextExpressionFields {
-        HtmlSingleTextExpressionFields {
-            l_curly_token: self.l_curly_token(),
-            expression: self.expression(),
-            r_curly_token: self.r_curly_token(),
+    pub fn as_fields(&self) -> GlimmerPathSegmentFields {
+        GlimmerPathSegmentFields {
+            value_token_token: self.value_token_token(),
         }
     }
-    pub fn l_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn value_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
-        support::required_node(&self.syntax, 1usize)
-    }
-    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 2usize)
-    }
 }
-impl Serialize for HtmlSingleTextExpression {
+impl Serialize for GlimmerPathSegment {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -739,16 +781,14 @@ impl Serialize for HtmlSingleTextExpression {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlSingleTextExpressionFields {
-    pub l_curly_token: SyntaxResult<SyntaxToken>,
-    pub expression: SyntaxResult<HtmlTextExpression>,
-    pub r_curly_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerPathSegmentFields {
+    pub value_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlString {
+pub struct GlimmerPositionalArgument {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlString {
+impl GlimmerPositionalArgument {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -758,16 +798,16 @@ impl HtmlString {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlStringFields {
-        HtmlStringFields {
-            value_token: self.value_token(),
+    pub fn as_fields(&self) -> GlimmerPositionalArgumentFields {
+        GlimmerPositionalArgumentFields {
+            value: self.value(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 0usize)
+    pub fn value(&self) -> SyntaxResult<AnyGlimmerArgumentValue> {
+        support::required_node(&self.syntax, 0usize)
     }
 }
-impl Serialize for HtmlString {
+impl Serialize for GlimmerPositionalArgument {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -776,14 +816,14 @@ impl Serialize for HtmlString {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlStringFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerPositionalArgumentFields {
+    pub value: SyntaxResult<AnyGlimmerArgumentValue>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlTagName {
+pub struct GlimmerSplattribute {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlTagName {
+impl GlimmerSplattribute {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -793,16 +833,20 @@ impl HtmlTagName {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlTagNameFields {
-        HtmlTagNameFields {
-            value_token: self.value_token(),
+    pub fn as_fields(&self) -> GlimmerSplattributeFields {
+        GlimmerSplattributeFields {
+            dotdotdot_token_token: self.dotdotdot_token_token(),
+            attributes_token_token: self.attributes_token_token(),
         }
     }
-    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn dotdotdot_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
+    pub fn attributes_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
 }
-impl Serialize for HtmlTagName {
+impl Serialize for GlimmerSplattribute {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -811,14 +855,15 @@ impl Serialize for HtmlTagName {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlTagNameFields {
-    pub value_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerSplattributeFields {
+    pub dotdotdot_token_token: SyntaxResult<SyntaxToken>,
+    pub attributes_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct HtmlTextExpression {
+pub struct GlimmerStringLiteral {
     pub(crate) syntax: SyntaxNode,
 }
-impl HtmlTextExpression {
+impl GlimmerStringLiteral {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -828,16 +873,16 @@ impl HtmlTextExpression {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> HtmlTextExpressionFields {
-        HtmlTextExpressionFields {
-            html_literal_token: self.html_literal_token(),
+    pub fn as_fields(&self) -> GlimmerStringLiteralFields {
+        GlimmerStringLiteralFields {
+            value_token_token: self.value_token_token(),
         }
     }
-    pub fn html_literal_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn value_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
 }
-impl Serialize for HtmlTextExpression {
+impl Serialize for GlimmerStringLiteral {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -846,14 +891,14 @@ impl Serialize for HtmlTextExpression {
     }
 }
 #[derive(Serialize)]
-pub struct HtmlTextExpressionFields {
-    pub html_literal_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerStringLiteralFields {
+    pub value_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct SvelteDebugBlock {
+pub struct GlimmerSubexpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl SvelteDebugBlock {
+impl GlimmerSubexpression {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -863,28 +908,28 @@ impl SvelteDebugBlock {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> SvelteDebugBlockFields {
-        SvelteDebugBlockFields {
-            sv_curly_at_token: self.sv_curly_at_token(),
-            debug_token: self.debug_token(),
-            bindings: self.bindings(),
-            r_curly_token: self.r_curly_token(),
+    pub fn as_fields(&self) -> GlimmerSubexpressionFields {
+        GlimmerSubexpressionFields {
+            l_paren_token_token: self.l_paren_token_token(),
+            path: self.path(),
+            arguments: self.arguments(),
+            r_paren_token_token: self.r_paren_token_token(),
         }
     }
-    pub fn sv_curly_at_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_paren_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
-    pub fn debug_token(&self) -> SyntaxResult<SyntaxToken> {
-        support::required_token(&self.syntax, 1usize)
+    pub fn path(&self) -> SyntaxResult<GlimmerPath> {
+        support::required_node(&self.syntax, 1usize)
     }
-    pub fn bindings(&self) -> SvelteBindingList {
+    pub fn arguments(&self) -> GlimmerArgumentList {
         support::list(&self.syntax, 2usize)
     }
-    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn r_paren_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 3usize)
     }
 }
-impl Serialize for SvelteDebugBlock {
+impl Serialize for GlimmerSubexpression {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -893,17 +938,17 @@ impl Serialize for SvelteDebugBlock {
     }
 }
 #[derive(Serialize)]
-pub struct SvelteDebugBlockFields {
-    pub sv_curly_at_token: SyntaxResult<SyntaxToken>,
-    pub debug_token: SyntaxResult<SyntaxToken>,
-    pub bindings: SvelteBindingList,
-    pub r_curly_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerSubexpressionFields {
+    pub l_paren_token_token: SyntaxResult<SyntaxToken>,
+    pub path: SyntaxResult<GlimmerPath>,
+    pub arguments: GlimmerArgumentList,
+    pub r_paren_token_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct SvelteName {
+pub struct GlimmerTripleStashExpression {
     pub(crate) syntax: SyntaxNode,
 }
-impl SvelteName {
+impl GlimmerTripleStashExpression {
     #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
     #[doc = r""]
     #[doc = r" # Safety"]
@@ -913,16 +958,28 @@ impl SvelteName {
     pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
         Self { syntax }
     }
-    pub fn as_fields(&self) -> SvelteNameFields {
-        SvelteNameFields {
-            svelte_ident_token: self.svelte_ident_token(),
+    pub fn as_fields(&self) -> GlimmerTripleStashExpressionFields {
+        GlimmerTripleStashExpressionFields {
+            l_curly3_token_token: self.l_curly3_token_token(),
+            path: self.path(),
+            arguments: self.arguments(),
+            r_curly3_token_token: self.r_curly3_token_token(),
         }
     }
-    pub fn svelte_ident_token(&self) -> SyntaxResult<SyntaxToken> {
+    pub fn l_curly3_token_token(&self) -> SyntaxResult<SyntaxToken> {
         support::required_token(&self.syntax, 0usize)
     }
+    pub fn path(&self) -> SyntaxResult<GlimmerPath> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn arguments(&self) -> GlimmerArgumentList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn r_curly3_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
+    }
 }
-impl Serialize for SvelteName {
+impl Serialize for GlimmerTripleStashExpression {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -931,204 +988,2209 @@ impl Serialize for SvelteName {
     }
 }
 #[derive(Serialize)]
-pub struct SvelteNameFields {
-    pub svelte_ident_token: SyntaxResult<SyntaxToken>,
+pub struct GlimmerTripleStashExpressionFields {
+    pub l_curly3_token_token: SyntaxResult<SyntaxToken>,
+    pub path: SyntaxResult<GlimmerPath>,
+    pub arguments: GlimmerArgumentList,
+    pub r_curly3_token_token: SyntaxResult<SyntaxToken>,
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyAstroFrontmatterElement {
-    AstroBogusFrontmatter(AstroBogusFrontmatter),
-    AstroFrontmatterElement(AstroFrontmatterElement),
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlAttribute {
+    pub(crate) syntax: SyntaxNode,
 }
-impl AnyAstroFrontmatterElement {
-    pub fn as_astro_bogus_frontmatter(&self) -> Option<&AstroBogusFrontmatter> {
-        match &self {
-            Self::AstroBogusFrontmatter(item) => Some(item),
-            _ => None,
-        }
-    }
-    pub fn as_astro_frontmatter_element(&self) -> Option<&AstroFrontmatterElement> {
-        match &self {
-            Self::AstroFrontmatterElement(item) => Some(item),
-            _ => None,
-        }
+impl HtmlAttribute {
+    #[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 }
     }
-}
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyHtmlAttribute {
-    HtmlAttribute(HtmlAttribute),
-    HtmlBogusAttribute(HtmlBogusAttribute),
-    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
-    HtmlSingleTextExpression(HtmlSingleTextExpression),
-}
-impl AnyHtmlAttribute {
-    pub fn as_html_attribute(&self) -> Option<&HtmlAttribute> {
-        match &self {
-            Self::HtmlAttribute(item) => Some(item),
-            _ => None,
+    pub fn as_fields(&self) -> HtmlAttributeFields {
+        HtmlAttributeFields {
+            name: self.name(),
+            initializer: self.initializer(),
         }
     }
-    pub fn as_html_bogus_attribute(&self) -> Option<&HtmlBogusAttribute> {
-        match &self {
-            Self::HtmlBogusAttribute(item) => Some(item),
-            _ => None,
-        }
+    pub fn name(&self) -> SyntaxResult<HtmlAttributeName> {
+        support::required_node(&self.syntax, 0usize)
     }
-    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
-        match &self {
-            Self::HtmlDoubleTextExpression(item) => Some(item),
-            _ => None,
-        }
+    pub fn initializer(&self) -> Option<HtmlAttributeInitializerClause> {
+        support::node(&self.syntax, 1usize)
     }
-    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
-        match &self {
-            Self::HtmlSingleTextExpression(item) => Some(item),
-            _ => None,
-        }
+}
+impl Serialize for HtmlAttribute {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
     }
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyHtmlAttributeInitializer {
-    HtmlSingleTextExpression(HtmlSingleTextExpression),
-    HtmlString(HtmlString),
+#[derive(Serialize)]
+pub struct HtmlAttributeFields {
+    pub name: SyntaxResult<HtmlAttributeName>,
+    pub initializer: Option<HtmlAttributeInitializerClause>,
 }
-impl AnyHtmlAttributeInitializer {
-    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
-        match &self {
-            Self::HtmlSingleTextExpression(item) => Some(item),
-            _ => None,
-        }
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlAttributeInitializerClause {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlAttributeInitializerClause {
+    #[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_html_string(&self) -> Option<&HtmlString> {
-        match &self {
-            Self::HtmlString(item) => Some(item),
-            _ => None,
+    pub fn as_fields(&self) -> HtmlAttributeInitializerClauseFields {
+        HtmlAttributeInitializerClauseFields {
+            eq_token: self.eq_token(),
+            value: self.value(),
         }
     }
+    pub fn eq_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn value(&self) -> SyntaxResult<AnyHtmlAttributeInitializer> {
+        support::required_node(&self.syntax, 1usize)
+    }
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyHtmlContent {
+impl Serialize for HtmlAttributeInitializerClause {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlAttributeInitializerClauseFields {
+    pub eq_token: SyntaxResult<SyntaxToken>,
+    pub value: SyntaxResult<AnyHtmlAttributeInitializer>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlAttributeName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlAttributeName {
+    #[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) -> HtmlAttributeNameFields {
+        HtmlAttributeNameFields {
+            value_token: self.value_token(),
+        }
+    }
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlAttributeName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlAttributeNameFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlCdataSection {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlCdataSection {
+    #[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) -> HtmlCdataSectionFields {
+        HtmlCdataSectionFields {
+            cdata_start_token: self.cdata_start_token(),
+            content_token: self.content_token(),
+            cdata_end_token: self.cdata_end_token(),
+        }
+    }
+    pub fn cdata_start_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn content_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn cdata_end_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlCdataSection {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlCdataSectionFields {
+    pub cdata_start_token: SyntaxResult<SyntaxToken>,
+    pub content_token: SyntaxResult<SyntaxToken>,
+    pub cdata_end_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlClosingElement {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlClosingElement {
+    #[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) -> HtmlClosingElementFields {
+        HtmlClosingElementFields {
+            l_angle_token: self.l_angle_token(),
+            slash_token: self.slash_token(),
+            name: self.name(),
+            r_angle_token: self.r_angle_token(),
+        }
+    }
+    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn slash_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
+        support::required_node(&self.syntax, 2usize)
+    }
+    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
+    }
+}
+impl Serialize for HtmlClosingElement {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlClosingElementFields {
+    pub l_angle_token: SyntaxResult<SyntaxToken>,
+    pub slash_token: SyntaxResult<SyntaxToken>,
+    pub name: SyntaxResult<HtmlTagName>,
+    pub r_angle_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlContent {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlContent {
+    #[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) -> HtmlContentFields {
+        HtmlContentFields {
+            value_token: self.value_token(),
+        }
+    }
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlContent {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlContentFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlDirective {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlDirective {
+    #[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) -> HtmlDirectiveFields {
+        HtmlDirectiveFields {
+            l_angle_token: self.l_angle_token(),
+            excl_token: self.excl_token(),
+            doctype_token: self.doctype_token(),
+            html_token: self.html_token(),
+            quirk_token: self.quirk_token(),
+            public_id_token: self.public_id_token(),
+            system_id_token: self.system_id_token(),
+            r_angle_token: self.r_angle_token(),
+        }
+    }
+    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn excl_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn doctype_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+    pub fn html_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 3usize)
+    }
+    pub fn quirk_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 4usize)
+    }
+    pub fn public_id_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 5usize)
+    }
+    pub fn system_id_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 6usize)
+    }
+    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 7usize)
+    }
+}
+impl Serialize for HtmlDirective {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlDirectiveFields {
+    pub l_angle_token: SyntaxResult<SyntaxToken>,
+    pub excl_token: SyntaxResult<SyntaxToken>,
+    pub doctype_token: SyntaxResult<SyntaxToken>,
+    pub html_token: Option<SyntaxToken>,
+    pub quirk_token: Option<SyntaxToken>,
+    pub public_id_token: Option<SyntaxToken>,
+    pub system_id_token: Option<SyntaxToken>,
+    pub r_angle_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlDoubleTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlDoubleTextExpression {
+    #[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) -> HtmlDoubleTextExpressionFields {
+        HtmlDoubleTextExpressionFields {
+            l_double_curly_token: self.l_double_curly_token(),
+            expression: self.expression(),
+            r_double_curly_token: self.r_double_curly_token(),
+        }
+    }
+    pub fn l_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlDoubleTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlDoubleTextExpressionFields {
+    pub l_double_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_double_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlElement {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlElement {
+    #[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) -> HtmlElementFields {
+        HtmlElementFields {
+            opening_element: self.opening_element(),
+            children: self.children(),
+            closing_element: self.closing_element(),
+        }
+    }
+    pub fn opening_element(&self) -> SyntaxResult<HtmlOpeningElement> {
+        support::required_node(&self.syntax, 0usize)
+    }
+    pub fn children(&self) -> HtmlElementList {
+        support::list(&self.syntax, 1usize)
+    }
+    pub fn closing_element(&self) -> SyntaxResult<HtmlClosingElement> {
+        support::required_node(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlElement {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlElementFields {
+    pub opening_element: SyntaxResult<HtmlOpeningElement>,
+    pub children: HtmlElementList,
+    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,
+}
+impl HtmlOpeningElement {
+    #[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) -> HtmlOpeningElementFields {
+        HtmlOpeningElementFields {
+            l_angle_token: self.l_angle_token(),
+            name: self.name(),
+            attributes: self.attributes(),
+            r_angle_token: self.r_angle_token(),
+        }
+    }
+    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn attributes(&self) -> HtmlAttributeList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
+    }
+}
+impl Serialize for HtmlOpeningElement {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlOpeningElementFields {
+    pub l_angle_token: SyntaxResult<SyntaxToken>,
+    pub name: SyntaxResult<HtmlTagName>,
+    pub attributes: HtmlAttributeList,
+    pub r_angle_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlRoot {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlRoot {
+    #[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) -> HtmlRootFields {
+        HtmlRootFields {
+            bom_token: self.bom_token(),
+            frontmatter: self.frontmatter(),
+            directive: self.directive(),
+            html: self.html(),
+            eof_token: self.eof_token(),
+        }
+    }
+    pub fn bom_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 0usize)
+    }
+    pub fn frontmatter(&self) -> Option<AnyAstroFrontmatterElement> {
+        support::node(&self.syntax, 1usize)
+    }
+    pub fn directive(&self) -> Option<HtmlDirective> {
+        support::node(&self.syntax, 2usize)
+    }
+    pub fn html(&self) -> HtmlElementList {
+        support::list(&self.syntax, 3usize)
+    }
+    pub fn eof_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 4usize)
+    }
+}
+impl Serialize for HtmlRoot {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlRootFields {
+    pub bom_token: Option<SyntaxToken>,
+    pub frontmatter: Option<AnyAstroFrontmatterElement>,
+    pub directive: Option<HtmlDirective>,
+    pub html: HtmlElementList,
+    pub eof_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlSelfClosingElement {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlSelfClosingElement {
+    #[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) -> HtmlSelfClosingElementFields {
+        HtmlSelfClosingElementFields {
+            l_angle_token: self.l_angle_token(),
+            name: self.name(),
+            attributes: self.attributes(),
+            slash_token: self.slash_token(),
+            r_angle_token: self.r_angle_token(),
+        }
+    }
+    pub fn l_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn name(&self) -> SyntaxResult<HtmlTagName> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn attributes(&self) -> HtmlAttributeList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn slash_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, 3usize)
+    }
+    pub fn r_angle_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 4usize)
+    }
+}
+impl Serialize for HtmlSelfClosingElement {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlSelfClosingElementFields {
+    pub l_angle_token: SyntaxResult<SyntaxToken>,
+    pub name: SyntaxResult<HtmlTagName>,
+    pub attributes: HtmlAttributeList,
+    pub slash_token: Option<SyntaxToken>,
+    pub r_angle_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlSingleTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlSingleTextExpression {
+    #[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) -> HtmlSingleTextExpressionFields {
+        HtmlSingleTextExpressionFields {
+            l_curly_token: self.l_curly_token(),
+            expression: self.expression(),
+            r_curly_token: self.r_curly_token(),
+        }
+    }
+    pub fn l_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlSingleTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlSingleTextExpressionFields {
+    pub l_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlString {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlString {
+    #[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) -> HtmlStringFields {
+        HtmlStringFields {
+            value_token: self.value_token(),
+        }
+    }
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlString {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlStringFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlTagName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlTagName {
+    #[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) -> HtmlTagNameFields {
+        HtmlTagNameFields {
+            value_token: self.value_token(),
+        }
+    }
+    pub fn value_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlTagName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlTagNameFields {
+    pub value_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlTextExpression {
+    #[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) -> HtmlTextExpressionFields {
+        HtmlTextExpressionFields {
+            html_literal_token: self.html_literal_token(),
+        }
+    }
+    pub fn html_literal_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for HtmlTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlTextExpressionFields {
+    pub html_literal_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct SvelteDebugBlock {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SvelteDebugBlock {
+    #[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) -> SvelteDebugBlockFields {
+        SvelteDebugBlockFields {
+            sv_curly_at_token: self.sv_curly_at_token(),
+            debug_token: self.debug_token(),
+            bindings: self.bindings(),
+            r_curly_token: self.r_curly_token(),
+        }
+    }
+    pub fn sv_curly_at_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn debug_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 1usize)
+    }
+    pub fn bindings(&self) -> SvelteBindingList {
+        support::list(&self.syntax, 2usize)
+    }
+    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 3usize)
+    }
+}
+impl Serialize for SvelteDebugBlock {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct SvelteDebugBlockFields {
+    pub sv_curly_at_token: SyntaxResult<SyntaxToken>,
+    pub debug_token: SyntaxResult<SyntaxToken>,
+    pub bindings: SvelteBindingList,
+    pub r_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct SvelteName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl SvelteName {
+    #[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) -> SvelteNameFields {
+        SvelteNameFields {
+            svelte_ident_token: self.svelte_ident_token(),
+        }
+    }
+    pub fn svelte_ident_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for SvelteName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct SvelteNameFields {
+    pub svelte_ident_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyAstroFrontmatterElement {
+    AstroBogusFrontmatter(AstroBogusFrontmatter),
+    AstroFrontmatterElement(AstroFrontmatterElement),
+}
+impl AnyAstroFrontmatterElement {
+    pub fn as_astro_bogus_frontmatter(&self) -> Option<&AstroBogusFrontmatter> {
+        match &self {
+            Self::AstroBogusFrontmatter(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_astro_frontmatter_element(&self) -> Option<&AstroFrontmatterElement> {
+        match &self {
+            Self::AstroFrontmatterElement(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyGlimmerArgument {
+    GlimmerNamedArgument(GlimmerNamedArgument),
+    GlimmerPositionalArgument(GlimmerPositionalArgument),
+}
+impl AnyGlimmerArgument {
+    pub fn as_glimmer_named_argument(&self) -> Option<&GlimmerNamedArgument> {
+        match &self {
+            Self::GlimmerNamedArgument(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_positional_argument(&self) -> Option<&GlimmerPositionalArgument> {
+        match &self {
+            Self::GlimmerPositionalArgument(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyGlimmerArgumentValue {
+    GlimmerLiteral(GlimmerLiteral),
+    GlimmerPath(GlimmerPath),
+    GlimmerStringLiteral(GlimmerStringLiteral),
+    GlimmerSubexpression(GlimmerSubexpression),
+}
+impl AnyGlimmerArgumentValue {
+    pub fn as_glimmer_literal(&self) -> Option<&GlimmerLiteral> {
+        match &self {
+            Self::GlimmerLiteral(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_path(&self) -> Option<&GlimmerPath> {
+        match &self {
+            Self::GlimmerPath(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_string_literal(&self) -> Option<&GlimmerStringLiteral> {
+        match &self {
+            Self::GlimmerStringLiteral(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_subexpression(&self) -> Option<&GlimmerSubexpression> {
+        match &self {
+            Self::GlimmerSubexpression(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyGlimmerExpression {
+    GlimmerBlockHelper(GlimmerBlockHelper),
+    GlimmerBogusExpression(GlimmerBogusExpression),
+    GlimmerMustacheComment(GlimmerMustacheComment),
+    GlimmerMustacheExpression(GlimmerMustacheExpression),
+    GlimmerNamedBlock(GlimmerNamedBlock),
+    GlimmerTripleStashExpression(GlimmerTripleStashExpression),
+}
+impl AnyGlimmerExpression {
+    pub fn as_glimmer_block_helper(&self) -> Option<&GlimmerBlockHelper> {
+        match &self {
+            Self::GlimmerBlockHelper(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_bogus_expression(&self) -> Option<&GlimmerBogusExpression> {
+        match &self {
+            Self::GlimmerBogusExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_mustache_comment(&self) -> Option<&GlimmerMustacheComment> {
+        match &self {
+            Self::GlimmerMustacheComment(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_mustache_expression(&self) -> Option<&GlimmerMustacheExpression> {
+        match &self {
+            Self::GlimmerMustacheExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_named_block(&self) -> Option<&GlimmerNamedBlock> {
+        match &self {
+            Self::GlimmerNamedBlock(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_triple_stash_expression(&self) -> Option<&GlimmerTripleStashExpression> {
+        match &self {
+            Self::GlimmerTripleStashExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyHtmlAttribute {
+    GlimmerElementModifier(GlimmerElementModifier),
+    GlimmerSplattribute(GlimmerSplattribute),
+    HtmlAttribute(HtmlAttribute),
+    HtmlBogusAttribute(HtmlBogusAttribute),
+    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
+    HtmlSingleTextExpression(HtmlSingleTextExpression),
+}
+impl AnyHtmlAttribute {
+    pub fn as_glimmer_element_modifier(&self) -> Option<&GlimmerElementModifier> {
+        match &self {
+            Self::GlimmerElementModifier(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_splattribute(&self) -> Option<&GlimmerSplattribute> {
+        match &self {
+            Self::GlimmerSplattribute(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_attribute(&self) -> Option<&HtmlAttribute> {
+        match &self {
+            Self::HtmlAttribute(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_bogus_attribute(&self) -> Option<&HtmlBogusAttribute> {
+        match &self {
+            Self::HtmlBogusAttribute(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
+        match &self {
+            Self::HtmlDoubleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+        match &self {
+            Self::HtmlSingleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyHtmlAttributeInitializer {
+    HtmlSingleTextExpression(HtmlSingleTextExpression),
+    HtmlString(HtmlString),
+}
+impl AnyHtmlAttributeInitializer {
+    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+        match &self {
+            Self::HtmlSingleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_string(&self) -> Option<&HtmlString> {
+        match &self {
+            Self::HtmlString(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyHtmlContent {
+    AnyGlimmerExpression(AnyGlimmerExpression),
     AnyHtmlTextExpression(AnyHtmlTextExpression),
     HtmlContent(HtmlContent),
     HtmlEmbeddedContent(HtmlEmbeddedContent),
 }
-impl AnyHtmlContent {
-    pub fn as_any_html_text_expression(&self) -> Option<&AnyHtmlTextExpression> {
-        match &self {
-            Self::AnyHtmlTextExpression(item) => Some(item),
-            _ => None,
+impl AnyHtmlContent {
+    pub fn as_any_glimmer_expression(&self) -> Option<&AnyGlimmerExpression> {
+        match &self {
+            Self::AnyGlimmerExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_any_html_text_expression(&self) -> Option<&AnyHtmlTextExpression> {
+        match &self {
+            Self::AnyHtmlTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_content(&self) -> Option<&HtmlContent> {
+        match &self {
+            Self::HtmlContent(item) => Some(item),
+            _ => 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 {
+    AnyHtmlContent(AnyHtmlContent),
+    GlimmerMustacheComment(GlimmerMustacheComment),
+    GlimmerTripleStashExpression(GlimmerTripleStashExpression),
+    HtmlBogusElement(HtmlBogusElement),
+    HtmlCdataSection(HtmlCdataSection),
+    HtmlElement(HtmlElement),
+    HtmlSelfClosingElement(HtmlSelfClosingElement),
+}
+impl AnyHtmlElement {
+    pub fn as_any_html_content(&self) -> Option<&AnyHtmlContent> {
+        match &self {
+            Self::AnyHtmlContent(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_mustache_comment(&self) -> Option<&GlimmerMustacheComment> {
+        match &self {
+            Self::GlimmerMustacheComment(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_glimmer_triple_stash_expression(&self) -> Option<&GlimmerTripleStashExpression> {
+        match &self {
+            Self::GlimmerTripleStashExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_bogus_element(&self) -> Option<&HtmlBogusElement> {
+        match &self {
+            Self::HtmlBogusElement(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_cdata_section(&self) -> Option<&HtmlCdataSection> {
+        match &self {
+            Self::HtmlCdataSection(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_element(&self) -> Option<&HtmlElement> {
+        match &self {
+            Self::HtmlElement(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_self_closing_element(&self) -> Option<&HtmlSelfClosingElement> {
+        match &self {
+            Self::HtmlSelfClosingElement(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnyHtmlTextExpression {
+    AnySvelteBlock(AnySvelteBlock),
+    HtmlBogusTextExpression(HtmlBogusTextExpression),
+    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
+    HtmlSingleTextExpression(HtmlSingleTextExpression),
+}
+impl AnyHtmlTextExpression {
+    pub fn as_any_svelte_block(&self) -> Option<&AnySvelteBlock> {
+        match &self {
+            Self::AnySvelteBlock(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_bogus_text_expression(&self) -> Option<&HtmlBogusTextExpression> {
+        match &self {
+            Self::HtmlBogusTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
+        match &self {
+            Self::HtmlDoubleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+        match &self {
+            Self::HtmlSingleTextExpression(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub enum AnySvelteBlock {
+    SvelteBogusBlock(SvelteBogusBlock),
+    SvelteDebugBlock(SvelteDebugBlock),
+}
+impl AnySvelteBlock {
+    pub fn as_svelte_bogus_block(&self) -> Option<&SvelteBogusBlock> {
+        match &self {
+            Self::SvelteBogusBlock(item) => Some(item),
+            _ => None,
+        }
+    }
+    pub fn as_svelte_debug_block(&self) -> Option<&SvelteDebugBlock> {
+        match &self {
+            Self::SvelteDebugBlock(item) => Some(item),
+            _ => None,
+        }
+    }
+}
+impl AstNode for AstroEmbeddedContent {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(ASTRO_EMBEDDED_CONTENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == ASTRO_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 AstroEmbeddedContent {
+    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("AstroEmbeddedContent")
+                .field(
+                    "content_token",
+                    &support::DebugOptionalElement(self.content_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("AstroEmbeddedContent").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<AstroEmbeddedContent> for SyntaxNode {
+    fn from(n: AstroEmbeddedContent) -> Self {
+        n.syntax
+    }
+}
+impl From<AstroEmbeddedContent> for SyntaxElement {
+    fn from(n: AstroEmbeddedContent) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for AstroFrontmatterElement {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(ASTRO_FRONTMATTER_ELEMENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == ASTRO_FRONTMATTER_ELEMENT
+    }
+    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 AstroFrontmatterElement {
+    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("AstroFrontmatterElement")
+                .field(
+                    "l_fence_token",
+                    &support::DebugSyntaxResult(self.l_fence_token()),
+                )
+                .field("content", &support::DebugSyntaxResult(self.content()))
+                .field(
+                    "r_fence_token",
+                    &support::DebugSyntaxResult(self.r_fence_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("AstroFrontmatterElement").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<AstroFrontmatterElement> for SyntaxNode {
+    fn from(n: AstroFrontmatterElement) -> Self {
+        n.syntax
+    }
+}
+impl From<AstroFrontmatterElement> for SyntaxElement {
+    fn from(n: AstroFrontmatterElement) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerBlockHelper {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_HELPER as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_HELPER
+    }
+    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 GlimmerBlockHelper {
+    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("GlimmerBlockHelper")
+                .field("opening", &support::DebugSyntaxResult(self.opening()))
+                .field("children", &self.children())
+                .field("closing", &support::DebugSyntaxResult(self.closing()))
+                .finish()
+        } else {
+            f.debug_struct("GlimmerBlockHelper").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerBlockHelper> for SyntaxNode {
+    fn from(n: GlimmerBlockHelper) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBlockHelper> for SyntaxElement {
+    fn from(n: GlimmerBlockHelper) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerBlockHelperClosing {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_HELPER_CLOSING as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_HELPER_CLOSING
+    }
+    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 GlimmerBlockHelperClosing {
+    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("GlimmerBlockHelperClosing")
+                .field(
+                    "l_curly2_token_token",
+                    &support::DebugSyntaxResult(self.l_curly2_token_token()),
+                )
+                .field(
+                    "slash_token_token",
+                    &support::DebugSyntaxResult(self.slash_token_token()),
+                )
+                .field("helper", &support::DebugSyntaxResult(self.helper()))
+                .field(
+                    "r_curly2_token_token",
+                    &support::DebugSyntaxResult(self.r_curly2_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerBlockHelperClosing").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerBlockHelperClosing> for SyntaxNode {
+    fn from(n: GlimmerBlockHelperClosing) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBlockHelperClosing> for SyntaxElement {
+    fn from(n: GlimmerBlockHelperClosing) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerBlockHelperOpening {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_HELPER_OPENING as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_HELPER_OPENING
+    }
+    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 GlimmerBlockHelperOpening {
+    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("GlimmerBlockHelperOpening")
+                .field(
+                    "l_curly2_token_token",
+                    &support::DebugSyntaxResult(self.l_curly2_token_token()),
+                )
+                .field(
+                    "hash_token_token",
+                    &support::DebugSyntaxResult(self.hash_token_token()),
+                )
+                .field("helper", &support::DebugSyntaxResult(self.helper()))
+                .field("arguments", &self.arguments())
+                .field(
+                    "block_params",
+                    &support::DebugOptionalElement(self.block_params()),
+                )
+                .field(
+                    "r_curly2_token_token",
+                    &support::DebugSyntaxResult(self.r_curly2_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerBlockHelperOpening").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerBlockHelperOpening> for SyntaxNode {
+    fn from(n: GlimmerBlockHelperOpening) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBlockHelperOpening> for SyntaxElement {
+    fn from(n: GlimmerBlockHelperOpening) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerBlockParam {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_PARAM as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_PARAM
+    }
+    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 GlimmerBlockParam {
+    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("GlimmerBlockParam")
+                .field(
+                    "name_token_token",
+                    &support::DebugSyntaxResult(self.name_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerBlockParam").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerBlockParam> for SyntaxNode {
+    fn from(n: GlimmerBlockParam) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBlockParam> for SyntaxElement {
+    fn from(n: GlimmerBlockParam) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerBlockParams {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_PARAMS as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_PARAMS
+    }
+    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 GlimmerBlockParams {
+    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("GlimmerBlockParams")
+                .field(
+                    "as_token_token",
+                    &support::DebugSyntaxResult(self.as_token_token()),
+                )
+                .field(
+                    "l_pipe_token_token",
+                    &support::DebugSyntaxResult(self.l_pipe_token_token()),
+                )
+                .field("params", &self.params())
+                .field(
+                    "r_pipe_token_token",
+                    &support::DebugSyntaxResult(self.r_pipe_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerBlockParams").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerBlockParams> for SyntaxNode {
+    fn from(n: GlimmerBlockParams) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBlockParams> for SyntaxElement {
+    fn from(n: GlimmerBlockParams) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerElementModifier {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_ELEMENT_MODIFIER as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_ELEMENT_MODIFIER
+    }
+    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 GlimmerElementModifier {
+    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("GlimmerElementModifier")
+                .field(
+                    "l_curly2_token_token",
+                    &support::DebugSyntaxResult(self.l_curly2_token_token()),
+                )
+                .field("path", &support::DebugSyntaxResult(self.path()))
+                .field("arguments", &self.arguments())
+                .field(
+                    "r_curly2_token_token",
+                    &support::DebugSyntaxResult(self.r_curly2_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerElementModifier").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerElementModifier> for SyntaxNode {
+    fn from(n: GlimmerElementModifier) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerElementModifier> for SyntaxElement {
+    fn from(n: GlimmerElementModifier) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerLiteral {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_LITERAL as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_LITERAL
+    }
+    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 GlimmerLiteral {
+    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("GlimmerLiteral")
+                .field(
+                    "value_token_token",
+                    &support::DebugSyntaxResult(self.value_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerLiteral").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerLiteral> for SyntaxNode {
+    fn from(n: GlimmerLiteral) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerLiteral> for SyntaxElement {
+    fn from(n: GlimmerLiteral) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerMustacheComment {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_MUSTACHE_COMMENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_MUSTACHE_COMMENT
+    }
+    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 GlimmerMustacheComment {
+    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("GlimmerMustacheComment")
+                .field(
+                    "comment_token_token",
+                    &support::DebugSyntaxResult(self.comment_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerMustacheComment").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerMustacheComment> for SyntaxNode {
+    fn from(n: GlimmerMustacheComment) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerMustacheComment> for SyntaxElement {
+    fn from(n: GlimmerMustacheComment) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerMustacheExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_MUSTACHE_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_MUSTACHE_EXPRESSION
+    }
+    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 GlimmerMustacheExpression {
+    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("GlimmerMustacheExpression")
+                .field(
+                    "l_curly2_token_token",
+                    &support::DebugSyntaxResult(self.l_curly2_token_token()),
+                )
+                .field("path", &support::DebugSyntaxResult(self.path()))
+                .field("arguments", &self.arguments())
+                .field(
+                    "r_curly2_token_token",
+                    &support::DebugSyntaxResult(self.r_curly2_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerMustacheExpression").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerMustacheExpression> for SyntaxNode {
+    fn from(n: GlimmerMustacheExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerMustacheExpression> for SyntaxElement {
+    fn from(n: GlimmerMustacheExpression) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerNamedArgument {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_NAMED_ARGUMENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_NAMED_ARGUMENT
+    }
+    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 GlimmerNamedArgument {
+    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("GlimmerNamedArgument")
+                .field(
+                    "name_token_token",
+                    &support::DebugSyntaxResult(self.name_token_token()),
+                )
+                .field(
+                    "eq_token_token",
+                    &support::DebugSyntaxResult(self.eq_token_token()),
+                )
+                .field("value", &support::DebugSyntaxResult(self.value()))
+                .finish()
+        } else {
+            f.debug_struct("GlimmerNamedArgument").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerNamedArgument> for SyntaxNode {
+    fn from(n: GlimmerNamedArgument) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerNamedArgument> for SyntaxElement {
+    fn from(n: GlimmerNamedArgument) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerNamedBlock {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_NAMED_BLOCK as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_NAMED_BLOCK
+    }
+    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 GlimmerNamedBlock {
+    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("GlimmerNamedBlock")
+                .field("opening", &support::DebugSyntaxResult(self.opening()))
+                .field("children", &self.children())
+                .field("closing", &support::DebugSyntaxResult(self.closing()))
+                .finish()
+        } else {
+            f.debug_struct("GlimmerNamedBlock").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerNamedBlock> for SyntaxNode {
+    fn from(n: GlimmerNamedBlock) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerNamedBlock> for SyntaxElement {
+    fn from(n: GlimmerNamedBlock) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerNamedBlockClosing {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_NAMED_BLOCK_CLOSING as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_NAMED_BLOCK_CLOSING
+    }
+    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 GlimmerNamedBlockClosing {
+    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("GlimmerNamedBlockClosing")
+                .field(
+                    "l_angle_token_token",
+                    &support::DebugSyntaxResult(self.l_angle_token_token()),
+                )
+                .field(
+                    "slash_token_token",
+                    &support::DebugSyntaxResult(self.slash_token_token()),
+                )
+                .field(
+                    "colon_token_token",
+                    &support::DebugSyntaxResult(self.colon_token_token()),
+                )
+                .field(
+                    "name_token_token",
+                    &support::DebugSyntaxResult(self.name_token_token()),
+                )
+                .field(
+                    "r_angle_token_token",
+                    &support::DebugSyntaxResult(self.r_angle_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerNamedBlockClosing").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerNamedBlockClosing> for SyntaxNode {
+    fn from(n: GlimmerNamedBlockClosing) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerNamedBlockClosing> for SyntaxElement {
+    fn from(n: GlimmerNamedBlockClosing) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerNamedBlockOpening {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_NAMED_BLOCK_OPENING as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_NAMED_BLOCK_OPENING
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
         }
     }
-    pub fn as_html_content(&self) -> Option<&HtmlContent> {
-        match &self {
-            Self::HtmlContent(item) => Some(item),
-            _ => None,
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for GlimmerNamedBlockOpening {
+    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("GlimmerNamedBlockOpening")
+                .field(
+                    "l_angle_token_token",
+                    &support::DebugSyntaxResult(self.l_angle_token_token()),
+                )
+                .field(
+                    "colon_token_token",
+                    &support::DebugSyntaxResult(self.colon_token_token()),
+                )
+                .field(
+                    "name_token_token",
+                    &support::DebugSyntaxResult(self.name_token_token()),
+                )
+                .field("attributes", &self.attributes())
+                .field(
+                    "r_angle_token_token",
+                    &support::DebugSyntaxResult(self.r_angle_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerNamedBlockOpening").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerNamedBlockOpening> for SyntaxNode {
+    fn from(n: GlimmerNamedBlockOpening) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerNamedBlockOpening> for SyntaxElement {
+    fn from(n: GlimmerNamedBlockOpening) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerPath {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_PATH as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_PATH
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
         }
     }
-    pub fn as_html_embedded_content(&self) -> Option<&HtmlEmbeddedContent> {
-        match &self {
-            Self::HtmlEmbeddedContent(item) => Some(item),
-            _ => None,
-        }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
     }
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyHtmlElement {
-    AnyHtmlContent(AnyHtmlContent),
-    HtmlBogusElement(HtmlBogusElement),
-    HtmlCdataSection(HtmlCdataSection),
-    HtmlElement(HtmlElement),
-    HtmlSelfClosingElement(HtmlSelfClosingElement),
+impl std::fmt::Debug for GlimmerPath {
+    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("GlimmerPath")
+                .field(
+                    "at_token_token",
+                    &support::DebugOptionalElement(self.at_token_token()),
+                )
+                .field("segments", &self.segments())
+                .finish()
+        } else {
+            f.debug_struct("GlimmerPath").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
 }
-impl AnyHtmlElement {
-    pub fn as_any_html_content(&self) -> Option<&AnyHtmlContent> {
-        match &self {
-            Self::AnyHtmlContent(item) => Some(item),
-            _ => None,
-        }
+impl From<GlimmerPath> for SyntaxNode {
+    fn from(n: GlimmerPath) -> Self {
+        n.syntax
     }
-    pub fn as_html_bogus_element(&self) -> Option<&HtmlBogusElement> {
-        match &self {
-            Self::HtmlBogusElement(item) => Some(item),
-            _ => None,
-        }
+}
+impl From<GlimmerPath> for SyntaxElement {
+    fn from(n: GlimmerPath) -> Self {
+        n.syntax.into()
     }
-    pub fn as_html_cdata_section(&self) -> Option<&HtmlCdataSection> {
-        match &self {
-            Self::HtmlCdataSection(item) => Some(item),
-            _ => None,
-        }
+}
+impl AstNode for GlimmerPathSegment {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_PATH_SEGMENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_PATH_SEGMENT
     }
-    pub fn as_html_element(&self) -> Option<&HtmlElement> {
-        match &self {
-            Self::HtmlElement(item) => Some(item),
-            _ => None,
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
         }
     }
-    pub fn as_html_self_closing_element(&self) -> Option<&HtmlSelfClosingElement> {
-        match &self {
-            Self::HtmlSelfClosingElement(item) => Some(item),
-            _ => None,
-        }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
     }
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnyHtmlTextExpression {
-    AnySvelteBlock(AnySvelteBlock),
-    HtmlBogusTextExpression(HtmlBogusTextExpression),
-    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
-    HtmlSingleTextExpression(HtmlSingleTextExpression),
+impl std::fmt::Debug for GlimmerPathSegment {
+    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("GlimmerPathSegment")
+                .field(
+                    "value_token_token",
+                    &support::DebugSyntaxResult(self.value_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerPathSegment").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
 }
-impl AnyHtmlTextExpression {
-    pub fn as_any_svelte_block(&self) -> Option<&AnySvelteBlock> {
-        match &self {
-            Self::AnySvelteBlock(item) => Some(item),
-            _ => None,
-        }
+impl From<GlimmerPathSegment> for SyntaxNode {
+    fn from(n: GlimmerPathSegment) -> Self {
+        n.syntax
     }
-    pub fn as_html_bogus_text_expression(&self) -> Option<&HtmlBogusTextExpression> {
-        match &self {
-            Self::HtmlBogusTextExpression(item) => Some(item),
-            _ => None,
-        }
+}
+impl From<GlimmerPathSegment> for SyntaxElement {
+    fn from(n: GlimmerPathSegment) -> Self {
+        n.syntax.into()
     }
-    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
-        match &self {
-            Self::HtmlDoubleTextExpression(item) => Some(item),
-            _ => None,
-        }
+}
+impl AstNode for GlimmerPositionalArgument {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_POSITIONAL_ARGUMENT as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_POSITIONAL_ARGUMENT
     }
-    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
-        match &self {
-            Self::HtmlSingleTextExpression(item) => Some(item),
-            _ => None,
+    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
+    }
 }
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub enum AnySvelteBlock {
-    SvelteBogusBlock(SvelteBogusBlock),
-    SvelteDebugBlock(SvelteDebugBlock),
+impl std::fmt::Debug for GlimmerPositionalArgument {
+    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("GlimmerPositionalArgument")
+                .field("value", &support::DebugSyntaxResult(self.value()))
+                .finish()
+        } else {
+            f.debug_struct("GlimmerPositionalArgument").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
 }
-impl AnySvelteBlock {
-    pub fn as_svelte_bogus_block(&self) -> Option<&SvelteBogusBlock> {
-        match &self {
-            Self::SvelteBogusBlock(item) => Some(item),
-            _ => None,
-        }
+impl From<GlimmerPositionalArgument> for SyntaxNode {
+    fn from(n: GlimmerPositionalArgument) -> Self {
+        n.syntax
     }
-    pub fn as_svelte_debug_block(&self) -> Option<&SvelteDebugBlock> {
-        match &self {
-            Self::SvelteDebugBlock(item) => Some(item),
-            _ => None,
+}
+impl From<GlimmerPositionalArgument> for SyntaxElement {
+    fn from(n: GlimmerPositionalArgument) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerSplattribute {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_SPLATTRIBUTE as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_SPLATTRIBUTE
+    }
+    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 AstNode for AstroEmbeddedContent {
+impl std::fmt::Debug for GlimmerSplattribute {
+    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("GlimmerSplattribute")
+                .field(
+                    "dotdotdot_token_token",
+                    &support::DebugSyntaxResult(self.dotdotdot_token_token()),
+                )
+                .field(
+                    "attributes_token_token",
+                    &support::DebugSyntaxResult(self.attributes_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerSplattribute").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerSplattribute> for SyntaxNode {
+    fn from(n: GlimmerSplattribute) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerSplattribute> for SyntaxElement {
+    fn from(n: GlimmerSplattribute) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerStringLiteral {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(ASTRO_EMBEDDED_CONTENT as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_STRING_LITERAL as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == ASTRO_EMBEDDED_CONTENT
+        kind == GLIMMER_STRING_LITERAL
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1144,41 +3206,97 @@ impl AstNode for AstroEmbeddedContent {
         self.syntax
     }
 }
-impl std::fmt::Debug for AstroEmbeddedContent {
+impl std::fmt::Debug for GlimmerStringLiteral {
     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("AstroEmbeddedContent")
+            f.debug_struct("GlimmerStringLiteral")
                 .field(
-                    "content_token",
-                    &support::DebugOptionalElement(self.content_token()),
+                    "value_token_token",
+                    &support::DebugSyntaxResult(self.value_token_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("AstroEmbeddedContent").finish()
+            f.debug_struct("GlimmerStringLiteral").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<AstroEmbeddedContent> for SyntaxNode {
-    fn from(n: AstroEmbeddedContent) -> Self {
+impl From<GlimmerStringLiteral> for SyntaxNode {
+    fn from(n: GlimmerStringLiteral) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerStringLiteral> for SyntaxElement {
+    fn from(n: GlimmerStringLiteral) -> Self {
+        n.syntax.into()
+    }
+}
+impl AstNode for GlimmerSubexpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_SUBEXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_SUBEXPRESSION
+    }
+    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 GlimmerSubexpression {
+    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("GlimmerSubexpression")
+                .field(
+                    "l_paren_token_token",
+                    &support::DebugSyntaxResult(self.l_paren_token_token()),
+                )
+                .field("path", &support::DebugSyntaxResult(self.path()))
+                .field("arguments", &self.arguments())
+                .field(
+                    "r_paren_token_token",
+                    &support::DebugSyntaxResult(self.r_paren_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("GlimmerSubexpression").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<GlimmerSubexpression> for SyntaxNode {
+    fn from(n: GlimmerSubexpression) -> Self {
         n.syntax
     }
 }
-impl From<AstroEmbeddedContent> for SyntaxElement {
-    fn from(n: AstroEmbeddedContent) -> Self {
+impl From<GlimmerSubexpression> for SyntaxElement {
+    fn from(n: GlimmerSubexpression) -> Self {
         n.syntax.into()
     }
 }
-impl AstNode for AstroFrontmatterElement {
+impl AstNode for GlimmerTripleStashExpression {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        SyntaxKindSet::from_raw(RawSyntaxKind(ASTRO_FRONTMATTER_ELEMENT as u16));
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_TRIPLE_STASH_EXPRESSION as u16));
     fn can_cast(kind: SyntaxKind) -> bool {
-        kind == ASTRO_FRONTMATTER_ELEMENT
+        kind == GLIMMER_TRIPLE_STASH_EXPRESSION
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         if Self::can_cast(syntax.kind()) {
@@ -1194,37 +3312,38 @@ impl AstNode for AstroFrontmatterElement {
         self.syntax
     }
 }
-impl std::fmt::Debug for AstroFrontmatterElement {
+impl std::fmt::Debug for GlimmerTripleStashExpression {
     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("AstroFrontmatterElement")
+            f.debug_struct("GlimmerTripleStashExpression")
                 .field(
-                    "l_fence_token",
-                    &support::DebugSyntaxResult(self.l_fence_token()),
+                    "l_curly3_token_token",
+                    &support::DebugSyntaxResult(self.l_curly3_token_token()),
                 )
-                .field("content", &support::DebugSyntaxResult(self.content()))
+                .field("path", &support::DebugSyntaxResult(self.path()))
+                .field("arguments", &self.arguments())
                 .field(
-                    "r_fence_token",
-                    &support::DebugSyntaxResult(self.r_fence_token()),
+                    "r_curly3_token_token",
+                    &support::DebugSyntaxResult(self.r_curly3_token_token()),
                 )
                 .finish()
         } else {
-            f.debug_struct("AstroFrontmatterElement").finish()
+            f.debug_struct("GlimmerTripleStashExpression").finish()
         };
         DEPTH.set(current_depth);
         result
     }
 }
-impl From<AstroFrontmatterElement> for SyntaxNode {
-    fn from(n: AstroFrontmatterElement) -> Self {
+impl From<GlimmerTripleStashExpression> for SyntaxNode {
+    fn from(n: GlimmerTripleStashExpression) -> Self {
         n.syntax
     }
 }
-impl From<AstroFrontmatterElement> for SyntaxElement {
-    fn from(n: AstroFrontmatterElement) -> Self {
+impl From<GlimmerTripleStashExpression> for SyntaxElement {
+    fn from(n: GlimmerTripleStashExpression) -> Self {
         n.syntax.into()
     }
 }
@@ -2333,6 +4452,283 @@ impl From<AnyAstroFrontmatterElement> for SyntaxElement {
         node.into()
     }
 }
+impl From<GlimmerNamedArgument> for AnyGlimmerArgument {
+    fn from(node: GlimmerNamedArgument) -> Self {
+        Self::GlimmerNamedArgument(node)
+    }
+}
+impl From<GlimmerPositionalArgument> for AnyGlimmerArgument {
+    fn from(node: GlimmerPositionalArgument) -> Self {
+        Self::GlimmerPositionalArgument(node)
+    }
+}
+impl AstNode for AnyGlimmerArgument {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        GlimmerNamedArgument::KIND_SET.union(GlimmerPositionalArgument::KIND_SET);
+    fn can_cast(kind: SyntaxKind) -> bool {
+        matches!(kind, GLIMMER_NAMED_ARGUMENT | GLIMMER_POSITIONAL_ARGUMENT)
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            GLIMMER_NAMED_ARGUMENT => Self::GlimmerNamedArgument(GlimmerNamedArgument { syntax }),
+            GLIMMER_POSITIONAL_ARGUMENT => {
+                Self::GlimmerPositionalArgument(GlimmerPositionalArgument { syntax })
+            }
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Self::GlimmerNamedArgument(it) => &it.syntax,
+            Self::GlimmerPositionalArgument(it) => &it.syntax,
+        }
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        match self {
+            Self::GlimmerNamedArgument(it) => it.syntax,
+            Self::GlimmerPositionalArgument(it) => it.syntax,
+        }
+    }
+}
+impl std::fmt::Debug for AnyGlimmerArgument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::GlimmerNamedArgument(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerPositionalArgument(it) => std::fmt::Debug::fmt(it, f),
+        }
+    }
+}
+impl From<AnyGlimmerArgument> for SyntaxNode {
+    fn from(n: AnyGlimmerArgument) -> Self {
+        match n {
+            AnyGlimmerArgument::GlimmerNamedArgument(it) => it.into(),
+            AnyGlimmerArgument::GlimmerPositionalArgument(it) => it.into(),
+        }
+    }
+}
+impl From<AnyGlimmerArgument> for SyntaxElement {
+    fn from(n: AnyGlimmerArgument) -> Self {
+        let node: SyntaxNode = n.into();
+        node.into()
+    }
+}
+impl From<GlimmerLiteral> for AnyGlimmerArgumentValue {
+    fn from(node: GlimmerLiteral) -> Self {
+        Self::GlimmerLiteral(node)
+    }
+}
+impl From<GlimmerPath> for AnyGlimmerArgumentValue {
+    fn from(node: GlimmerPath) -> Self {
+        Self::GlimmerPath(node)
+    }
+}
+impl From<GlimmerStringLiteral> for AnyGlimmerArgumentValue {
+    fn from(node: GlimmerStringLiteral) -> Self {
+        Self::GlimmerStringLiteral(node)
+    }
+}
+impl From<GlimmerSubexpression> for AnyGlimmerArgumentValue {
+    fn from(node: GlimmerSubexpression) -> Self {
+        Self::GlimmerSubexpression(node)
+    }
+}
+impl AstNode for AnyGlimmerArgumentValue {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> = GlimmerLiteral::KIND_SET
+        .union(GlimmerPath::KIND_SET)
+        .union(GlimmerStringLiteral::KIND_SET)
+        .union(GlimmerSubexpression::KIND_SET);
+    fn can_cast(kind: SyntaxKind) -> bool {
+        matches!(
+            kind,
+            GLIMMER_LITERAL | GLIMMER_PATH | GLIMMER_STRING_LITERAL | GLIMMER_SUBEXPRESSION
+        )
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            GLIMMER_LITERAL => Self::GlimmerLiteral(GlimmerLiteral { syntax }),
+            GLIMMER_PATH => Self::GlimmerPath(GlimmerPath { syntax }),
+            GLIMMER_STRING_LITERAL => Self::GlimmerStringLiteral(GlimmerStringLiteral { syntax }),
+            GLIMMER_SUBEXPRESSION => Self::GlimmerSubexpression(GlimmerSubexpression { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Self::GlimmerLiteral(it) => &it.syntax,
+            Self::GlimmerPath(it) => &it.syntax,
+            Self::GlimmerStringLiteral(it) => &it.syntax,
+            Self::GlimmerSubexpression(it) => &it.syntax,
+        }
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        match self {
+            Self::GlimmerLiteral(it) => it.syntax,
+            Self::GlimmerPath(it) => it.syntax,
+            Self::GlimmerStringLiteral(it) => it.syntax,
+            Self::GlimmerSubexpression(it) => it.syntax,
+        }
+    }
+}
+impl std::fmt::Debug for AnyGlimmerArgumentValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::GlimmerLiteral(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerPath(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerStringLiteral(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerSubexpression(it) => std::fmt::Debug::fmt(it, f),
+        }
+    }
+}
+impl From<AnyGlimmerArgumentValue> for SyntaxNode {
+    fn from(n: AnyGlimmerArgumentValue) -> Self {
+        match n {
+            AnyGlimmerArgumentValue::GlimmerLiteral(it) => it.into(),
+            AnyGlimmerArgumentValue::GlimmerPath(it) => it.into(),
+            AnyGlimmerArgumentValue::GlimmerStringLiteral(it) => it.into(),
+            AnyGlimmerArgumentValue::GlimmerSubexpression(it) => it.into(),
+        }
+    }
+}
+impl From<AnyGlimmerArgumentValue> for SyntaxElement {
+    fn from(n: AnyGlimmerArgumentValue) -> Self {
+        let node: SyntaxNode = n.into();
+        node.into()
+    }
+}
+impl From<GlimmerBlockHelper> for AnyGlimmerExpression {
+    fn from(node: GlimmerBlockHelper) -> Self {
+        Self::GlimmerBlockHelper(node)
+    }
+}
+impl From<GlimmerBogusExpression> for AnyGlimmerExpression {
+    fn from(node: GlimmerBogusExpression) -> Self {
+        Self::GlimmerBogusExpression(node)
+    }
+}
+impl From<GlimmerMustacheComment> for AnyGlimmerExpression {
+    fn from(node: GlimmerMustacheComment) -> Self {
+        Self::GlimmerMustacheComment(node)
+    }
+}
+impl From<GlimmerMustacheExpression> for AnyGlimmerExpression {
+    fn from(node: GlimmerMustacheExpression) -> Self {
+        Self::GlimmerMustacheExpression(node)
+    }
+}
+impl From<GlimmerNamedBlock> for AnyGlimmerExpression {
+    fn from(node: GlimmerNamedBlock) -> Self {
+        Self::GlimmerNamedBlock(node)
+    }
+}
+impl From<GlimmerTripleStashExpression> for AnyGlimmerExpression {
+    fn from(node: GlimmerTripleStashExpression) -> Self {
+        Self::GlimmerTripleStashExpression(node)
+    }
+}
+impl AstNode for AnyGlimmerExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> = GlimmerBlockHelper::KIND_SET
+        .union(GlimmerBogusExpression::KIND_SET)
+        .union(GlimmerMustacheComment::KIND_SET)
+        .union(GlimmerMustacheExpression::KIND_SET)
+        .union(GlimmerNamedBlock::KIND_SET)
+        .union(GlimmerTripleStashExpression::KIND_SET);
+    fn can_cast(kind: SyntaxKind) -> bool {
+        matches!(
+            kind,
+            GLIMMER_BLOCK_HELPER
+                | GLIMMER_BOGUS_EXPRESSION
+                | GLIMMER_MUSTACHE_COMMENT
+                | GLIMMER_MUSTACHE_EXPRESSION
+                | GLIMMER_NAMED_BLOCK
+                | GLIMMER_TRIPLE_STASH_EXPRESSION
+        )
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        let res = match syntax.kind() {
+            GLIMMER_BLOCK_HELPER => Self::GlimmerBlockHelper(GlimmerBlockHelper { syntax }),
+            GLIMMER_BOGUS_EXPRESSION => {
+                Self::GlimmerBogusExpression(GlimmerBogusExpression { syntax })
+            }
+            GLIMMER_MUSTACHE_COMMENT => {
+                Self::GlimmerMustacheComment(GlimmerMustacheComment { syntax })
+            }
+            GLIMMER_MUSTACHE_EXPRESSION => {
+                Self::GlimmerMustacheExpression(GlimmerMustacheExpression { syntax })
+            }
+            GLIMMER_NAMED_BLOCK => Self::GlimmerNamedBlock(GlimmerNamedBlock { syntax }),
+            GLIMMER_TRIPLE_STASH_EXPRESSION => {
+                Self::GlimmerTripleStashExpression(GlimmerTripleStashExpression { syntax })
+            }
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Self::GlimmerBlockHelper(it) => &it.syntax,
+            Self::GlimmerBogusExpression(it) => &it.syntax,
+            Self::GlimmerMustacheComment(it) => &it.syntax,
+            Self::GlimmerMustacheExpression(it) => &it.syntax,
+            Self::GlimmerNamedBlock(it) => &it.syntax,
+            Self::GlimmerTripleStashExpression(it) => &it.syntax,
+        }
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        match self {
+            Self::GlimmerBlockHelper(it) => it.syntax,
+            Self::GlimmerBogusExpression(it) => it.syntax,
+            Self::GlimmerMustacheComment(it) => it.syntax,
+            Self::GlimmerMustacheExpression(it) => it.syntax,
+            Self::GlimmerNamedBlock(it) => it.syntax,
+            Self::GlimmerTripleStashExpression(it) => it.syntax,
+        }
+    }
+}
+impl std::fmt::Debug for AnyGlimmerExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::GlimmerBlockHelper(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerBogusExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerMustacheComment(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerMustacheExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerNamedBlock(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerTripleStashExpression(it) => std::fmt::Debug::fmt(it, f),
+        }
+    }
+}
+impl From<AnyGlimmerExpression> for SyntaxNode {
+    fn from(n: AnyGlimmerExpression) -> Self {
+        match n {
+            AnyGlimmerExpression::GlimmerBlockHelper(it) => it.into(),
+            AnyGlimmerExpression::GlimmerBogusExpression(it) => it.into(),
+            AnyGlimmerExpression::GlimmerMustacheComment(it) => it.into(),
+            AnyGlimmerExpression::GlimmerMustacheExpression(it) => it.into(),
+            AnyGlimmerExpression::GlimmerNamedBlock(it) => it.into(),
+            AnyGlimmerExpression::GlimmerTripleStashExpression(it) => it.into(),
+        }
+    }
+}
+impl From<AnyGlimmerExpression> for SyntaxElement {
+    fn from(n: AnyGlimmerExpression) -> Self {
+        let node: SyntaxNode = n.into();
+        node.into()
+    }
+}
+impl From<GlimmerElementModifier> for AnyHtmlAttribute {
+    fn from(node: GlimmerElementModifier) -> Self {
+        Self::GlimmerElementModifier(node)
+    }
+}
+impl From<GlimmerSplattribute> for AnyHtmlAttribute {
+    fn from(node: GlimmerSplattribute) -> Self {
+        Self::GlimmerSplattribute(node)
+    }
+}
 impl From<HtmlAttribute> for AnyHtmlAttribute {
     fn from(node: HtmlAttribute) -> Self {
         Self::HtmlAttribute(node)
@@ -2355,14 +4751,18 @@ impl From<HtmlSingleTextExpression> for AnyHtmlAttribute {
 }
 impl AstNode for AnyHtmlAttribute {
     type Language = Language;
-    const KIND_SET: SyntaxKindSet<Language> = HtmlAttribute::KIND_SET
+    const KIND_SET: SyntaxKindSet<Language> = GlimmerElementModifier::KIND_SET
+        .union(GlimmerSplattribute::KIND_SET)
+        .union(HtmlAttribute::KIND_SET)
         .union(HtmlBogusAttribute::KIND_SET)
         .union(HtmlDoubleTextExpression::KIND_SET)
         .union(HtmlSingleTextExpression::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
-            HTML_ATTRIBUTE
+            GLIMMER_ELEMENT_MODIFIER
+                | GLIMMER_SPLATTRIBUTE
+                | HTML_ATTRIBUTE
                 | HTML_BOGUS_ATTRIBUTE
                 | HTML_DOUBLE_TEXT_EXPRESSION
                 | HTML_SINGLE_TEXT_EXPRESSION
@@ -2370,6 +4770,10 @@ impl AstNode for AnyHtmlAttribute {
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
+            GLIMMER_ELEMENT_MODIFIER => {
+                Self::GlimmerElementModifier(GlimmerElementModifier { syntax })
+            }
+            GLIMMER_SPLATTRIBUTE => Self::GlimmerSplattribute(GlimmerSplattribute { syntax }),
             HTML_ATTRIBUTE => Self::HtmlAttribute(HtmlAttribute { syntax }),
             HTML_BOGUS_ATTRIBUTE => Self::HtmlBogusAttribute(HtmlBogusAttribute { syntax }),
             HTML_DOUBLE_TEXT_EXPRESSION => {
@@ -2384,6 +4788,8 @@ impl AstNode for AnyHtmlAttribute {
     }
     fn syntax(&self) -> &SyntaxNode {
         match self {
+            Self::GlimmerElementModifier(it) => &it.syntax,
+            Self::GlimmerSplattribute(it) => &it.syntax,
             Self::HtmlAttribute(it) => &it.syntax,
             Self::HtmlBogusAttribute(it) => &it.syntax,
             Self::HtmlDoubleTextExpression(it) => &it.syntax,
@@ -2392,6 +4798,8 @@ impl AstNode for AnyHtmlAttribute {
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
+            Self::GlimmerElementModifier(it) => it.syntax,
+            Self::GlimmerSplattribute(it) => it.syntax,
             Self::HtmlAttribute(it) => it.syntax,
             Self::HtmlBogusAttribute(it) => it.syntax,
             Self::HtmlDoubleTextExpression(it) => it.syntax,
@@ -2402,6 +4810,8 @@ impl AstNode for AnyHtmlAttribute {
 impl std::fmt::Debug for AnyHtmlAttribute {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Self::GlimmerElementModifier(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerSplattribute(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlAttribute(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlBogusAttribute(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlDoubleTextExpression(it) => std::fmt::Debug::fmt(it, f),
@@ -2412,6 +4822,8 @@ impl std::fmt::Debug for AnyHtmlAttribute {
 impl From<AnyHtmlAttribute> for SyntaxNode {
     fn from(n: AnyHtmlAttribute) -> Self {
         match n {
+            AnyHtmlAttribute::GlimmerElementModifier(it) => it.into(),
+            AnyHtmlAttribute::GlimmerSplattribute(it) => it.into(),
             AnyHtmlAttribute::HtmlAttribute(it) => it.into(),
             AnyHtmlAttribute::HtmlBogusAttribute(it) => it.into(),
             AnyHtmlAttribute::HtmlDoubleTextExpression(it) => it.into(),
@@ -2499,12 +4911,14 @@ impl From<HtmlEmbeddedContent> for AnyHtmlContent {
 }
 impl AstNode for AnyHtmlContent {
     type Language = Language;
-    const KIND_SET: SyntaxKindSet<Language> = AnyHtmlTextExpression::KIND_SET
+    const KIND_SET: SyntaxKindSet<Language> = AnyGlimmerExpression::KIND_SET
+        .union(AnyHtmlTextExpression::KIND_SET)
         .union(HtmlContent::KIND_SET)
         .union(HtmlEmbeddedContent::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
             HTML_CONTENT | HTML_EMBEDDED_CONTENT => true,
+            k if AnyGlimmerExpression::can_cast(k) => true,
             k if AnyHtmlTextExpression::can_cast(k) => true,
             _ => false,
         }
@@ -2514,6 +4928,12 @@ impl AstNode for AnyHtmlContent {
             HTML_CONTENT => Self::HtmlContent(HtmlContent { syntax }),
             HTML_EMBEDDED_CONTENT => Self::HtmlEmbeddedContent(HtmlEmbeddedContent { syntax }),
             _ => {
+                let syntax = match AnyGlimmerExpression::try_cast(syntax) {
+                    Ok(any_glimmer_expression) => {
+                        return Some(Self::AnyGlimmerExpression(any_glimmer_expression));
+                    }
+                    Err(syntax) => syntax,
+                };
                 if let Some(any_html_text_expression) = AnyHtmlTextExpression::cast(syntax) {
                     return Some(Self::AnyHtmlTextExpression(any_html_text_expression));
                 }
@@ -2526,6 +4946,7 @@ impl AstNode for AnyHtmlContent {
         match self {
             Self::HtmlContent(it) => &it.syntax,
             Self::HtmlEmbeddedContent(it) => &it.syntax,
+            Self::AnyGlimmerExpression(it) => it.syntax(),
             Self::AnyHtmlTextExpression(it) => it.syntax(),
         }
     }
@@ -2533,6 +4954,7 @@ impl AstNode for AnyHtmlContent {
         match self {
             Self::HtmlContent(it) => it.syntax,
             Self::HtmlEmbeddedContent(it) => it.syntax,
+            Self::AnyGlimmerExpression(it) => it.into_syntax(),
             Self::AnyHtmlTextExpression(it) => it.into_syntax(),
         }
     }
@@ -2540,6 +4962,7 @@ impl AstNode for AnyHtmlContent {
 impl std::fmt::Debug for AnyHtmlContent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Self::AnyGlimmerExpression(it) => std::fmt::Debug::fmt(it, f),
             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),
@@ -2549,6 +4972,7 @@ impl std::fmt::Debug for AnyHtmlContent {
 impl From<AnyHtmlContent> for SyntaxNode {
     fn from(n: AnyHtmlContent) -> Self {
         match n {
+            AnyHtmlContent::AnyGlimmerExpression(it) => it.into(),
             AnyHtmlContent::AnyHtmlTextExpression(it) => it.into(),
             AnyHtmlContent::HtmlContent(it) => it.into(),
             AnyHtmlContent::HtmlEmbeddedContent(it) => it.into(),
@@ -2561,6 +4985,16 @@ impl From<AnyHtmlContent> for SyntaxElement {
         node.into()
     }
 }
+impl From<GlimmerMustacheComment> for AnyHtmlElement {
+    fn from(node: GlimmerMustacheComment) -> Self {
+        Self::GlimmerMustacheComment(node)
+    }
+}
+impl From<GlimmerTripleStashExpression> for AnyHtmlElement {
+    fn from(node: GlimmerTripleStashExpression) -> Self {
+        Self::GlimmerTripleStashExpression(node)
+    }
+}
 impl From<HtmlBogusElement> for AnyHtmlElement {
     fn from(node: HtmlBogusElement) -> Self {
         Self::HtmlBogusElement(node)
@@ -2584,21 +5018,32 @@ impl From<HtmlSelfClosingElement> for AnyHtmlElement {
 impl AstNode for AnyHtmlElement {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> = AnyHtmlContent::KIND_SET
+        .union(GlimmerMustacheComment::KIND_SET)
+        .union(GlimmerTripleStashExpression::KIND_SET)
         .union(HtmlBogusElement::KIND_SET)
         .union(HtmlCdataSection::KIND_SET)
         .union(HtmlElement::KIND_SET)
         .union(HtmlSelfClosingElement::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            HTML_BOGUS_ELEMENT | HTML_CDATA_SECTION | HTML_ELEMENT | HTML_SELF_CLOSING_ELEMENT => {
-                true
-            }
+            GLIMMER_MUSTACHE_COMMENT
+            | GLIMMER_TRIPLE_STASH_EXPRESSION
+            | HTML_BOGUS_ELEMENT
+            | HTML_CDATA_SECTION
+            | HTML_ELEMENT
+            | HTML_SELF_CLOSING_ELEMENT => true,
             k if AnyHtmlContent::can_cast(k) => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
+            GLIMMER_MUSTACHE_COMMENT => {
+                Self::GlimmerMustacheComment(GlimmerMustacheComment { syntax })
+            }
+            GLIMMER_TRIPLE_STASH_EXPRESSION => {
+                Self::GlimmerTripleStashExpression(GlimmerTripleStashExpression { syntax })
+            }
             HTML_BOGUS_ELEMENT => Self::HtmlBogusElement(HtmlBogusElement { syntax }),
             HTML_CDATA_SECTION => Self::HtmlCdataSection(HtmlCdataSection { syntax }),
             HTML_ELEMENT => Self::HtmlElement(HtmlElement { syntax }),
@@ -2616,6 +5061,8 @@ impl AstNode for AnyHtmlElement {
     }
     fn syntax(&self) -> &SyntaxNode {
         match self {
+            Self::GlimmerMustacheComment(it) => &it.syntax,
+            Self::GlimmerTripleStashExpression(it) => &it.syntax,
             Self::HtmlBogusElement(it) => &it.syntax,
             Self::HtmlCdataSection(it) => &it.syntax,
             Self::HtmlElement(it) => &it.syntax,
@@ -2625,6 +5072,8 @@ impl AstNode for AnyHtmlElement {
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
+            Self::GlimmerMustacheComment(it) => it.syntax,
+            Self::GlimmerTripleStashExpression(it) => it.syntax,
             Self::HtmlBogusElement(it) => it.syntax,
             Self::HtmlCdataSection(it) => it.syntax,
             Self::HtmlElement(it) => it.syntax,
@@ -2637,6 +5086,8 @@ impl std::fmt::Debug for AnyHtmlElement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::AnyHtmlContent(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerMustacheComment(it) => std::fmt::Debug::fmt(it, f),
+            Self::GlimmerTripleStashExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlBogusElement(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlCdataSection(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlElement(it) => std::fmt::Debug::fmt(it, f),
@@ -2648,6 +5099,8 @@ impl From<AnyHtmlElement> for SyntaxNode {
     fn from(n: AnyHtmlElement) -> Self {
         match n {
             AnyHtmlElement::AnyHtmlContent(it) => it.into(),
+            AnyHtmlElement::GlimmerMustacheComment(it) => it.into(),
+            AnyHtmlElement::GlimmerTripleStashExpression(it) => it.into(),
             AnyHtmlElement::HtmlBogusElement(it) => it.into(),
             AnyHtmlElement::HtmlCdataSection(it) => it.into(),
             AnyHtmlElement::HtmlElement(it) => it.into(),
@@ -2814,47 +5267,162 @@ impl From<AnySvelteBlock> for SyntaxElement {
         node.into()
     }
 }
-impl std::fmt::Display for AnyAstroFrontmatterElement {
+impl std::fmt::Display for AnyAstroFrontmatterElement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyGlimmerArgument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyGlimmerArgumentValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyGlimmerExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyHtmlAttribute {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyHtmlAttributeInitializer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyHtmlContent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyHtmlElement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnyHtmlTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AnySvelteBlock {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AstroEmbeddedContent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for AstroFrontmatterElement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerBlockHelper {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerBlockHelperClosing {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerBlockHelperOpening {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerBlockParam {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerBlockParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerElementModifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerLiteral {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerMustacheComment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerMustacheExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerNamedArgument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerNamedBlock {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnyHtmlAttribute {
+impl std::fmt::Display for GlimmerNamedBlockClosing {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnyHtmlAttributeInitializer {
+impl std::fmt::Display for GlimmerNamedBlockOpening {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnyHtmlContent {
+impl std::fmt::Display for GlimmerPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnyHtmlElement {
+impl std::fmt::Display for GlimmerPathSegment {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnyHtmlTextExpression {
+impl std::fmt::Display for GlimmerPositionalArgument {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AnySvelteBlock {
+impl std::fmt::Display for GlimmerSplattribute {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AstroEmbeddedContent {
+impl std::fmt::Display for GlimmerStringLiteral {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for AstroFrontmatterElement {
+impl std::fmt::Display for GlimmerSubexpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for GlimmerTripleStashExpression {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
     }
@@ -3011,6 +5579,62 @@ impl From<AstroBogusFrontmatter> for SyntaxElement {
     }
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub struct GlimmerBogusExpression {
+    syntax: SyntaxNode,
+}
+impl GlimmerBogusExpression {
+    #[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 items(&self) -> SyntaxElementChildren {
+        support::elements(&self.syntax)
+    }
+}
+impl AstNode for GlimmerBogusExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BOGUS_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BOGUS_EXPRESSION
+    }
+    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 GlimmerBogusExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GlimmerBogusExpression")
+            .field("items", &DebugSyntaxElementChildren(self.items()))
+            .finish()
+    }
+}
+impl From<GlimmerBogusExpression> for SyntaxNode {
+    fn from(n: GlimmerBogusExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<GlimmerBogusExpression> for SyntaxElement {
+    fn from(n: GlimmerBogusExpression) -> Self {
+        n.syntax.into()
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub struct HtmlBogus {
     syntax: SyntaxNode,
 }
@@ -3290,7 +5914,253 @@ impl From<SvelteBogusBlock> for SyntaxElement {
         n.syntax.into()
     }
 }
-biome_rowan::declare_node_union! { pub AnyHtmlBogusNode = AstroBogusFrontmatter | HtmlBogus | HtmlBogusAttribute | HtmlBogusElement | HtmlBogusTextExpression | SvelteBogusBlock }
+biome_rowan::declare_node_union! { pub AnyHtmlBogusNode = AstroBogusFrontmatter | GlimmerBogusExpression | HtmlBogus | HtmlBogusAttribute | HtmlBogusElement | HtmlBogusTextExpression | SvelteBogusBlock }
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct GlimmerArgumentList {
+    syntax_list: SyntaxList,
+}
+impl GlimmerArgumentList {
+    #[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 unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self {
+            syntax_list: syntax.into_list(),
+        }
+    }
+}
+impl AstNode for GlimmerArgumentList {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_ARGUMENT_LIST as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_ARGUMENT_LIST
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self {
+                syntax_list: syntax.into_list(),
+            })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        self.syntax_list.node()
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax_list.into_node()
+    }
+}
+impl Serialize for GlimmerArgumentList {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for e in self.iter() {
+            seq.serialize_element(&e)?;
+        }
+        seq.end()
+    }
+}
+impl AstNodeList for GlimmerArgumentList {
+    type Language = Language;
+    type Node = AnyGlimmerArgument;
+    fn syntax_list(&self) -> &SyntaxList {
+        &self.syntax_list
+    }
+    fn into_syntax_list(self) -> SyntaxList {
+        self.syntax_list
+    }
+}
+impl Debug for GlimmerArgumentList {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str("GlimmerArgumentList ")?;
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+impl IntoIterator for &GlimmerArgumentList {
+    type Item = AnyGlimmerArgument;
+    type IntoIter = AstNodeListIterator<Language, AnyGlimmerArgument>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+impl IntoIterator for GlimmerArgumentList {
+    type Item = AnyGlimmerArgument;
+    type IntoIter = AstNodeListIterator<Language, AnyGlimmerArgument>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct GlimmerBlockParamList {
+    syntax_list: SyntaxList,
+}
+impl GlimmerBlockParamList {
+    #[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 unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self {
+            syntax_list: syntax.into_list(),
+        }
+    }
+}
+impl AstNode for GlimmerBlockParamList {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_BLOCK_PARAM_LIST as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_BLOCK_PARAM_LIST
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self {
+                syntax_list: syntax.into_list(),
+            })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        self.syntax_list.node()
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax_list.into_node()
+    }
+}
+impl Serialize for GlimmerBlockParamList {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for e in self.iter() {
+            seq.serialize_element(&e)?;
+        }
+        seq.end()
+    }
+}
+impl AstNodeList for GlimmerBlockParamList {
+    type Language = Language;
+    type Node = GlimmerBlockParam;
+    fn syntax_list(&self) -> &SyntaxList {
+        &self.syntax_list
+    }
+    fn into_syntax_list(self) -> SyntaxList {
+        self.syntax_list
+    }
+}
+impl Debug for GlimmerBlockParamList {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str("GlimmerBlockParamList ")?;
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+impl IntoIterator for &GlimmerBlockParamList {
+    type Item = GlimmerBlockParam;
+    type IntoIter = AstNodeListIterator<Language, GlimmerBlockParam>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+impl IntoIterator for GlimmerBlockParamList {
+    type Item = GlimmerBlockParam;
+    type IntoIter = AstNodeListIterator<Language, GlimmerBlockParam>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct GlimmerPathSegmentList {
+    syntax_list: SyntaxList,
+}
+impl GlimmerPathSegmentList {
+    #[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 unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self {
+            syntax_list: syntax.into_list(),
+        }
+    }
+}
+impl AstNode for GlimmerPathSegmentList {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(GLIMMER_PATH_SEGMENT_LIST as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == GLIMMER_PATH_SEGMENT_LIST
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self {
+                syntax_list: syntax.into_list(),
+            })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        self.syntax_list.node()
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax_list.into_node()
+    }
+}
+impl Serialize for GlimmerPathSegmentList {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for e in self.iter() {
+            seq.serialize_element(&e)?;
+        }
+        seq.end()
+    }
+}
+impl AstSeparatedList for GlimmerPathSegmentList {
+    type Language = Language;
+    type Node = GlimmerPathSegment;
+    fn syntax_list(&self) -> &SyntaxList {
+        &self.syntax_list
+    }
+    fn into_syntax_list(self) -> SyntaxList {
+        self.syntax_list
+    }
+}
+impl Debug for GlimmerPathSegmentList {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str("GlimmerPathSegmentList ")?;
+        f.debug_list().entries(self.elements()).finish()
+    }
+}
+impl IntoIterator for GlimmerPathSegmentList {
+    type Item = SyntaxResult<GlimmerPathSegment>;
+    type IntoIter = AstSeparatedListNodesIterator<Language, GlimmerPathSegment>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+impl IntoIterator for &GlimmerPathSegmentList {
+    type Item = SyntaxResult<GlimmerPathSegment>;
+    type IntoIter = AstSeparatedListNodesIterator<Language, GlimmerPathSegment>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub struct HtmlAttributeList {
     syntax_list: SyntaxList,
diff --git a/crates/biome_html_syntax/src/generated/nodes_mut.rs b/crates/biome_html_syntax/src/generated/nodes_mut.rs
index e313d156b95e..4510e97a3dcc 100644
--- a/crates/biome_html_syntax/src/generated/nodes_mut.rs
+++ b/crates/biome_html_syntax/src/generated/nodes_mut.rs
@@ -31,6 +31,400 @@ impl AstroFrontmatterElement {
         )
     }
 }
+impl GlimmerBlockHelper {
+    pub fn with_opening(self, element: GlimmerBlockHelperOpening) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_children(self, element: HtmlElementList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_closing(self, element: GlimmerBlockHelperClosing) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+}
+impl GlimmerBlockHelperClosing {
+    pub fn with_l_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_slash_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_helper(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerBlockHelperOpening {
+    pub fn with_l_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_hash_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_helper(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_arguments(self, element: GlimmerArgumentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_block_params(self, element: Option<GlimmerBlockParams>) -> Self {
+        Self::unwrap_cast(self.syntax.splice_slots(
+            4usize..=4usize,
+            once(element.map(|element| element.into_syntax().into())),
+        ))
+    }
+    pub fn with_r_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(5usize..=5usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerBlockParam {
+    pub fn with_name_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerBlockParams {
+    pub fn with_as_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_l_pipe_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_params(self, element: GlimmerBlockParamList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_pipe_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerElementModifier {
+    pub fn with_l_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_path(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_arguments(self, element: GlimmerArgumentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerLiteral {
+    pub fn with_value_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerMustacheComment {
+    pub fn with_comment_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerMustacheExpression {
+    pub fn with_l_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_path(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_arguments(self, element: GlimmerArgumentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_curly2_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerNamedArgument {
+    pub fn with_name_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_eq_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_value(self, element: AnyGlimmerArgumentValue) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+}
+impl GlimmerNamedBlock {
+    pub fn with_opening(self, element: GlimmerNamedBlockOpening) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_children(self, element: HtmlElementList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_closing(self, element: GlimmerNamedBlockClosing) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+}
+impl GlimmerNamedBlockClosing {
+    pub fn with_l_angle_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_slash_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_colon_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_name_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_r_angle_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(4usize..=4usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerNamedBlockOpening {
+    pub fn with_l_angle_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_colon_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_name_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_attributes(self, element: HtmlAttributeList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_angle_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(4usize..=4usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerPath {
+    pub fn with_at_token_token(self, element: Option<SyntaxToken>) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(element.map(|element| element.into()))),
+        )
+    }
+    pub fn with_segments(self, element: GlimmerPathSegmentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+}
+impl GlimmerPathSegment {
+    pub fn with_value_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerPositionalArgument {
+    pub fn with_value(self, element: AnyGlimmerArgumentValue) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+}
+impl GlimmerSplattribute {
+    pub fn with_dotdotdot_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_attributes_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerStringLiteral {
+    pub fn with_value_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerSubexpression {
+    pub fn with_l_paren_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_path(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_arguments(self, element: GlimmerArgumentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_paren_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
+impl GlimmerTripleStashExpression {
+    pub fn with_l_curly3_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_path(self, element: GlimmerPath) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_arguments(self, element: GlimmerArgumentList) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_curly3_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(3usize..=3usize, once(Some(element.into()))),
+        )
+    }
+}
 impl HtmlAttribute {
     pub fn with_name(self, element: HtmlAttributeName) -> Self {
         Self::unwrap_cast(
diff --git a/crates/biome_js_analyze/src/lint/complexity/no_static_only_class.rs b/crates/biome_js_analyze/src/lint/complexity/no_static_only_class.rs
index 96506645b38f..ce1d71f49a4a 100644
--- a/crates/biome_js_analyze/src/lint/complexity/no_static_only_class.rs
+++ b/crates/biome_js_analyze/src/lint/complexity/no_static_only_class.rs
@@ -162,6 +162,7 @@ impl Rule for NoStaticOnlyClass {
             .filter_map(|member| match member {
                 AnyJsClassMember::JsBogusMember(_)
                 | AnyJsClassMember::JsMetavariable(_)
+                | AnyJsClassMember::JsGlimmerTemplate(_)
                 | AnyJsClassMember::JsEmptyClassMember(_) => None,
                 AnyJsClassMember::JsConstructorClassMember(_) => Some(false), // See GH#4482: Constructors are not regarded as static
                 AnyJsClassMember::TsConstructorSignatureClassMember(_) => Some(false), // See GH#4482: Constructors are not regarded as static
diff --git a/crates/biome_js_analyze/src/lint/correctness/no_invalid_constructor_super.rs b/crates/biome_js_analyze/src/lint/correctness/no_invalid_constructor_super.rs
index d57aa1da8eee..f2638b3bc871 100644
--- a/crates/biome_js_analyze/src/lint/correctness/no_invalid_constructor_super.rs
+++ b/crates/biome_js_analyze/src/lint/correctness/no_invalid_constructor_super.rs
@@ -226,6 +226,7 @@ fn is_valid_constructor(expression: AnyJsExpression) -> Option<bool> {
         | AnyJsExpression::JsBinaryExpression(_)
         | AnyJsExpression::JsBogusExpression(_)
         | AnyJsExpression::JsMetavariable(_)
+        | AnyJsExpression::JsGlimmerTemplate(_)
         | AnyJsExpression::JsInstanceofExpression(_)
         | AnyJsExpression::JsObjectExpression(_)
         | AnyJsExpression::JsPostUpdateExpression(_)
diff --git a/crates/biome_js_analyze/src/lint/nursery/no_unused_expressions.rs b/crates/biome_js_analyze/src/lint/nursery/no_unused_expressions.rs
index 90d28f18a956..a09309aed478 100644
--- a/crates/biome_js_analyze/src/lint/nursery/no_unused_expressions.rs
+++ b/crates/biome_js_analyze/src/lint/nursery/no_unused_expressions.rs
@@ -259,6 +259,7 @@ fn is_disallowed(expr: &AnyJsExpression) -> SyntaxResult<bool> {
         | AnyJsExpression::JsComputedMemberExpression(_)
         | AnyJsExpression::JsConditionalExpression(_)
         | AnyJsExpression::JsFunctionExpression(_)
+        | AnyJsExpression::JsGlimmerTemplate(_)
         | AnyJsExpression::JsIdentifierExpression(_)
         | AnyJsExpression::JsImportMetaExpression(_)
         | AnyJsExpression::JsInExpression(_)
diff --git a/crates/biome_js_analyze/src/lint/style/use_naming_convention.rs b/crates/biome_js_analyze/src/lint/style/use_naming_convention.rs
index 27bf311096c4..b656ffc18066 100644
--- a/crates/biome_js_analyze/src/lint/style/use_naming_convention.rs
+++ b/crates/biome_js_analyze/src/lint/style/use_naming_convention.rs
@@ -1155,6 +1155,7 @@ fn selector_from_class_member(member: &AnyJsClassMember) -> Option<Selector> {
         | AnyJsClassMember::JsConstructorClassMember(_)
         | AnyJsClassMember::TsConstructorSignatureClassMember(_)
         | AnyJsClassMember::JsEmptyClassMember(_)
+        | AnyJsClassMember::JsGlimmerTemplate(_)
         | AnyJsClassMember::JsStaticInitializationBlockClassMember(_) => return None,
         AnyJsClassMember::TsIndexSignatureClassMember(member) => {
             (Kind::ClassProperty, (&member.modifiers()).into())
diff --git a/crates/biome_js_factory/src/generated/node_factory.rs b/crates/biome_js_factory/src/generated/node_factory.rs
index b510b6e9a91c..8acb9560381f 100644
--- a/crates/biome_js_factory/src/generated/node_factory.rs
+++ b/crates/biome_js_factory/src/generated/node_factory.rs
@@ -1895,6 +1895,12 @@ impl JsGetterObjectMemberBuilder {
         ))
     }
 }
+pub fn js_glimmer_template(template_token_token: SyntaxToken) -> JsGlimmerTemplate {
+    JsGlimmerTemplate::unwrap_cast(SyntaxNode::new_detached(
+        JsSyntaxKind::JS_GLIMMER_TEMPLATE,
+        [Some(SyntaxElement::Token(template_token_token))],
+    ))
+}
 pub fn js_identifier_assignment(name_token: SyntaxToken) -> JsIdentifierAssignment {
     JsIdentifierAssignment::unwrap_cast(SyntaxNode::new_detached(
         JsSyntaxKind::JS_IDENTIFIER_ASSIGNMENT,
diff --git a/crates/biome_js_factory/src/generated/syntax_factory.rs b/crates/biome_js_factory/src/generated/syntax_factory.rs
index 97832980c67f..4c4b7d2dcc50 100644
--- a/crates/biome_js_factory/src/generated/syntax_factory.rs
+++ b/crates/biome_js_factory/src/generated/syntax_factory.rs
@@ -2655,6 +2655,25 @@ impl SyntaxFactory for JsSyntaxFactory {
                 }
                 slots.into_node(JS_GETTER_OBJECT_MEMBER, children)
             }
+            JS_GLIMMER_TEMPLATE => {
+                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() == GLIMMER_TEMPLATE
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        JS_GLIMMER_TEMPLATE.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(JS_GLIMMER_TEMPLATE, children)
+            }
             JS_IDENTIFIER_ASSIGNMENT => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default();
diff --git a/crates/biome_js_formatter/src/generated.rs b/crates/biome_js_formatter/src/generated.rs
index f57505f1dfe0..eba9ccf34777 100644
--- a/crates/biome_js_formatter/src/generated.rs
+++ b/crates/biome_js_formatter/src/generated.rs
@@ -2263,6 +2263,73 @@ impl IntoFormat<JsFormatContext> for biome_js_syntax::JsGetterObjectMember {
         )
     }
 }
+impl FormatRule<biome_js_syntax::JsGlimmerTemplate>
+    for crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate
+{
+    type Context = JsFormatContext;
+    /// Formats a `JsGlimmerTemplate` node using this formatting rule.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// // Given a `template` of type `biome_js_syntax::JsGlimmerTemplate`
+    /// // and a mutable `formatter` of type `JsFormatter`:
+    /// // let result = crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate::default()
+    /// //     .fmt(&template, &mut formatter);
+    /// // assert!(result.is_ok());
+    /// ```
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_js_syntax::JsGlimmerTemplate,
+        f: &mut JsFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_js_syntax::JsGlimmerTemplate>::fmt(self, node, f)
+    }
+}
+impl AsFormat<JsFormatContext> for biome_js_syntax::JsGlimmerTemplate {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_js_syntax::JsGlimmerTemplate,
+        crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate,
+    >;
+    /// Format a borrowed `JsGlimmerTemplate` with the default Glimmer template formatter.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// // Given a `JsGlimmerTemplate` value `template`:
+    /// let formatted = template.format();
+    /// ```
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule::new(
+            self,
+            crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate::default(),
+        )
+    }
+}
+impl IntoFormat<JsFormatContext> for biome_js_syntax::JsGlimmerTemplate {
+    type Format = FormatOwnedWithRule<
+        biome_js_syntax::JsGlimmerTemplate,
+        crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate,
+    >;
+    /// Converts the Glimmer template node into an owned formatter that applies the Glimmer template formatting rule.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use biome_js_syntax::JsGlimmerTemplate;
+    ///
+    /// let node = JsGlimmerTemplate::default();
+    /// let owned_formatter = node.into_format();
+    /// ```
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule::new(
+            self,
+            crate::js::auxiliary::glimmer_template::FormatJsGlimmerTemplate::default(),
+        )
+    }
+}
 impl FormatRule<biome_js_syntax::JsIdentifierAssignment>
     for crate::js::assignments::identifier_assignment::FormatJsIdentifierAssignment
 {
diff --git a/crates/biome_js_formatter/src/js/any/class_member.rs b/crates/biome_js_formatter/src/js/any/class_member.rs
index e3ab803ed1fb..2439167b002c 100644
--- a/crates/biome_js_formatter/src/js/any/class_member.rs
+++ b/crates/biome_js_formatter/src/js/any/class_member.rs
@@ -12,6 +12,7 @@ impl FormatRule<AnyJsClassMember> for FormatAnyJsClassMember {
             AnyJsClassMember::JsConstructorClassMember(node) => node.format().fmt(f),
             AnyJsClassMember::JsEmptyClassMember(node) => node.format().fmt(f),
             AnyJsClassMember::JsGetterClassMember(node) => node.format().fmt(f),
+            AnyJsClassMember::JsGlimmerTemplate(node) => node.format().fmt(f),
             AnyJsClassMember::JsMetavariable(node) => node.format().fmt(f),
             AnyJsClassMember::JsMethodClassMember(node) => node.format().fmt(f),
             AnyJsClassMember::JsPropertyClassMember(node) => node.format().fmt(f),
diff --git a/crates/biome_js_formatter/src/js/any/expression.rs b/crates/biome_js_formatter/src/js/any/expression.rs
index c1eceec24086..bdf6cb56e707 100644
--- a/crates/biome_js_formatter/src/js/any/expression.rs
+++ b/crates/biome_js_formatter/src/js/any/expression.rs
@@ -20,6 +20,7 @@ impl FormatRule<AnyJsExpression> for FormatAnyJsExpression {
             AnyJsExpression::JsComputedMemberExpression(node) => node.format().fmt(f),
             AnyJsExpression::JsConditionalExpression(node) => node.format().fmt(f),
             AnyJsExpression::JsFunctionExpression(node) => node.format().fmt(f),
+            AnyJsExpression::JsGlimmerTemplate(node) => node.format().fmt(f),
             AnyJsExpression::JsIdentifierExpression(node) => node.format().fmt(f),
             AnyJsExpression::JsImportCallExpression(node) => node.format().fmt(f),
             AnyJsExpression::JsImportMetaExpression(node) => node.format().fmt(f),
diff --git a/crates/biome_js_formatter/src/js/any/statement.rs b/crates/biome_js_formatter/src/js/any/statement.rs
index 3f6387aa1abf..ff8a8f8c4dbc 100644
--- a/crates/biome_js_formatter/src/js/any/statement.rs
+++ b/crates/biome_js_formatter/src/js/any/statement.rs
@@ -21,6 +21,7 @@ impl FormatRule<AnyJsStatement> for FormatAnyJsStatement {
             AnyJsStatement::JsForOfStatement(node) => node.format().fmt(f),
             AnyJsStatement::JsForStatement(node) => node.format().fmt(f),
             AnyJsStatement::JsFunctionDeclaration(node) => node.format().fmt(f),
+            AnyJsStatement::JsGlimmerTemplate(node) => node.format().fmt(f),
             AnyJsStatement::JsIfStatement(node) => node.format().fmt(f),
             AnyJsStatement::JsLabeledStatement(node) => node.format().fmt(f),
             AnyJsStatement::JsMetavariable(node) => node.format().fmt(f),
diff --git a/crates/biome_js_formatter/src/js/auxiliary/glimmer_template.rs b/crates/biome_js_formatter/src/js/auxiliary/glimmer_template.rs
new file mode 100644
index 000000000000..3c501c56b1b6
--- /dev/null
+++ b/crates/biome_js_formatter/src/js/auxiliary/glimmer_template.rs
@@ -0,0 +1,19 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_js_syntax::{JsGlimmerTemplate, JsGlimmerTemplateFields};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatJsGlimmerTemplate;
+
+impl FormatNodeRule<JsGlimmerTemplate> for FormatJsGlimmerTemplate {
+    /// Formats a Glimmer template by writing its template token verbatim.
+    ///
+    /// This is a pass-through formatter that preserves the original template content.
+    fn fmt_fields(&self, node: &JsGlimmerTemplate, f: &mut JsFormatter) -> FormatResult<()> {
+        let JsGlimmerTemplateFields {
+            template_token_token,
+        } = node.as_fields();
+
+        write![f, [template_token_token.format()]]
+    }
+}
diff --git a/crates/biome_js_formatter/src/js/auxiliary/mod.rs b/crates/biome_js_formatter/src/js/auxiliary/mod.rs
index 9d978e673507..04b9b20799af 100644
--- a/crates/biome_js_formatter/src/js/auxiliary/mod.rs
+++ b/crates/biome_js_formatter/src/js/auxiliary/mod.rs
@@ -11,6 +11,7 @@ pub(crate) mod else_clause;
 pub(crate) mod expression_snipped;
 pub(crate) mod finally_clause;
 pub(crate) mod function_body;
+pub(crate) mod glimmer_template;
 pub(crate) mod initializer_clause;
 pub(crate) mod label;
 pub(crate) mod metavariable;
diff --git a/crates/biome_js_formatter/src/js/classes/property_class_member.rs b/crates/biome_js_formatter/src/js/classes/property_class_member.rs
index 4932bd9ee95d..b1eb93d4bc9a 100644
--- a/crates/biome_js_formatter/src/js/classes/property_class_member.rs
+++ b/crates/biome_js_formatter/src/js/classes/property_class_member.rs
@@ -134,6 +134,7 @@ fn needs_semicolon(property: &AnyJsPropertyClassMember) -> SyntaxResult<bool> {
         | AnyJsClassMember::TsGetterSignatureClassMember(_)
         | AnyJsClassMember::TsSetterSignatureClassMember(_)
         | AnyJsClassMember::JsSetterClassMember(_)
+        | AnyJsClassMember::JsGlimmerTemplate(_)
         | AnyJsClassMember::JsMetavariable(_) => false,
 
         // Computed members may be misinterpreted as array accessors/array types
@@ -170,6 +171,7 @@ fn has_modifiers(member: &AnyJsClassMember) -> bool {
             constructor.modifiers().is_empty()
         }
         AnyJsClassMember::JsEmptyClassMember(_) => true,
+        AnyJsClassMember::JsGlimmerTemplate(_) => true,
         AnyJsClassMember::JsGetterClassMember(getter) => getter.modifiers().is_empty(),
         AnyJsClassMember::JsMethodClassMember(method) => method.modifiers().is_empty(),
         AnyJsClassMember::JsPropertyClassMember(property) => property.modifiers().is_empty(),
diff --git a/crates/biome_js_formatter/src/utils/format_node_without_comments.rs b/crates/biome_js_formatter/src/utils/format_node_without_comments.rs
index adb96cb172b2..1dc0ad7a596c 100644
--- a/crates/biome_js_formatter/src/utils/format_node_without_comments.rs
+++ b/crates/biome_js_formatter/src/utils/format_node_without_comments.rs
@@ -93,6 +93,7 @@ impl FormatRule<AnyJsExpression> for FormatAnyJsExpressionWithoutComments {
             AnyJsExpression::JsFunctionExpression(node) => {
                 FormatJsFunctionExpression::default().fmt_node(node, f)
             }
+            AnyJsExpression::JsGlimmerTemplate(node) => node.format().fmt(f),
             AnyJsExpression::JsMetavariable(node) => FormatJsMetavariable.fmt_node(node, f),
             AnyJsExpression::JsIdentifierExpression(node) => {
                 FormatJsIdentifierExpression.fmt_node(node, f)
diff --git a/crates/biome_js_parser/src/lexer/mod.rs b/crates/biome_js_parser/src/lexer/mod.rs
index 40ea38cae8b0..1b243609c437 100644
--- a/crates/biome_js_parser/src/lexer/mod.rs
+++ b/crates/biome_js_parser/src/lexer/mod.rs
@@ -132,6 +132,9 @@ pub(crate) struct JsLexer<'src> {
     diagnostics: Vec<ParseDiagnostic>,
 
     options: JsParserOptions,
+
+    /// The file source type (for determining if we're in .gjs/.gts files)
+    source_type: JsFileSource,
 }
 
 impl<'src> Lexer<'src> for JsLexer<'src> {
@@ -311,6 +314,7 @@ impl<'src> JsLexer<'src> {
             position: 0,
             diagnostics: vec![],
             options: JsParserOptions::default(),
+            source_type: JsFileSource::default(),
         }
     }
 
@@ -318,6 +322,13 @@ impl<'src> JsLexer<'src> {
         Self { options, ..self }
     }
 
+    pub(crate) fn with_source_type(self, source_type: JsFileSource) -> Self {
+        Self {
+            source_type,
+            ..self
+        }
+    }
+
     fn re_lex_binary_operator(&mut self) -> JsSyntaxKind {
         if self.current_byte() == Some(b'>') {
             match self.next_byte() {
@@ -1727,6 +1738,93 @@ impl<'src> JsLexer<'src> {
         }
     }
 
+    /// Attempts to lex a Glimmer template block `<template>...</template>`.
+    /// Returns Some(GLIMMER_TEMPLATE) if a template was found, None otherwise.
+    ///
+    /// IMPORTANT: This function uses lookahead to check if we have a valid `<template>` tag.
+    /// The lexer position is ONLY advanced if we confirm it's a valid template. If we return `None`,
+    /// the position remains at the `<` character, allowing normal token lexing to continue.
+    fn try_lex_glimmer_template(&mut self) -> Option<JsSyntaxKind> {
+        // Save start position for error reporting (we're currently at '<')
+        let start = self.position;
+
+        // LOOKAHEAD PHASE: All checks below use non-advancing operations (peek_byte, byte_at, slicing)
+        // The lexer position is NOT advanced during these checks.
+
+        // Check if '<' is followed by 't' (first char of "template")
+        if self.peek_byte() != Some(b't') {
+            return None; // Not a template, position unchanged
+        }
+
+        // Check if we have enough bytes for "<template" (1 + 8 = 9 bytes)
+        let template_bytes = b"template";
+        let end_pos = self.position + 1 + template_bytes.len();
+        if end_pos > self.source.len() {
+            return None; // Not enough bytes, position unchanged
+        }
+
+        // Verify bytes spell "template" (checking self.position+1 through self.position+9)
+        if &self.source.as_bytes()[self.position + 1..end_pos] != template_bytes {
+            return None; // Doesn't match "template", position unchanged
+        }
+
+        // Verify that "template" is followed by '>' or whitespace (not part of an identifier)
+        // byte_at(9) checks self.position + 9, which is the byte immediately after "<template"
+        match self.byte_at(9) {
+            Some(b'>' | b' ' | b'\t' | b'\n' | b'\r') => {
+                // Valid template tag start
+            }
+            _ => return None, // Followed by identifier char (e.g., <templatex), position unchanged
+        }
+
+        // COMMIT PHASE: We've confirmed this is a valid `<template>` tag
+        // Now we advance the lexer position and consume the template
+
+        // Consume "<template" (9 bytes: 1 for '<' + 8 for 'template')
+        self.advance(9);
+
+        // Skip any attributes/whitespace until we find '>'
+        // Simplified loop: always advance, then check if we found '>'
+        while let Some(chr) = self.current_byte() {
+            self.next_byte(); // always consume the current byte
+            if chr == b'>' {
+                break; // Found '>', already consumed
+            }
+        }
+
+        // Save the position after the opening tag for error reporting
+        let opening_tag_end = self.position;
+
+        // Now search for "</template>"
+        let closing_tag = b"</template>";
+        let mut found_closing = false;
+
+        while self.position < self.source.len() {
+            if let Some(b'<') = self.current_byte() {
+                // Check if this is "</template>"
+                let end_pos = self.position + closing_tag.len();
+                if end_pos <= self.source.len()
+                    && &self.source.as_bytes()[self.position..end_pos] == closing_tag
+                {
+                    // Found closing tag, consume it
+                    self.advance(closing_tag.len());
+                    found_closing = true;
+                    break;
+                }
+            }
+            self.next_byte();
+        }
+
+        if !found_closing {
+            // Unclosed template - create diagnostic
+            let err = ParseDiagnostic::new("Unclosed `<template>` tag", start..opening_tag_end)
+                .with_hint("Add a closing `</template>` tag");
+            self.push_diagnostic(err);
+        }
+
+        Some(GLIMMER_TEMPLATE)
+    }
+
     #[inline]
     fn resolve_minus(&mut self) -> JsSyntaxKind {
         match self.next_byte() {
@@ -1744,6 +1842,13 @@ impl<'src> JsLexer<'src> {
 
     #[inline]
     fn resolve_less_than(&mut self) -> JsSyntaxKind {
+        // Check for Glimmer template in .gjs/.gts files
+        if self.source_type.as_embedding_kind().is_glimmer()
+            && let Some(template_kind) = self.try_lex_glimmer_template()
+        {
+            return template_kind;
+        }
+
         match self.next_byte() {
             Some(b'<') => {
                 if let Some(b'=') = self.next_byte() {
diff --git a/crates/biome_js_parser/src/options.rs b/crates/biome_js_parser/src/options.rs
index 47dcadeaf81a..083dcbcc5e67 100644
--- a/crates/biome_js_parser/src/options.rs
+++ b/crates/biome_js_parser/src/options.rs
@@ -1,3 +1,5 @@
+use biome_js_syntax::JsFileSource;
+
 /// Options to pass to the JavaScript parser
 #[derive(Debug, Clone, Copy, Default)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -46,3 +48,28 @@ impl JsParserOptions {
         self.parse_class_parameter_decorators
     }
 }
+
+impl From<&JsFileSource> for JsParserOptions {
+    /// Derive parser options from the file source type.
+    ///
+    /// This allows parser configuration to be automatically determined based on
+    /// file characteristics (language, variant, embedding kind, etc.) rather than
+    /// requiring explicit option passing.
+    ///
+    /// Currently returns default options for all file types, but provides a
+    /// centralized place to configure file-type-specific parsing behavior in the future.
+    /// For example, Glimmer template parsing (.gjs/.gts files) is handled at the
+    /// lexer level by checking the embedding kind.
+    fn from(_file_source: &JsFileSource) -> Self {
+        // File-type-specific options could be configured here based on:
+        // - _file_source.language() - JavaScript vs TypeScript
+        // - _file_source.variant() - Standard vs JSX
+        // - _file_source.module_kind() - Script vs Module
+        // - _file_source.as_embedding_kind() - Astro, Vue, Svelte, Glimmer, etc.
+        //
+        // For now, Glimmer-specific behavior (template lexing) is handled in the lexer
+        // by checking _file_source.as_embedding_kind().is_glimmer()
+
+        Self::default()
+    }
+}
diff --git a/crates/biome_js_parser/src/parse.rs b/crates/biome_js_parser/src/parse.rs
index d2c78d6e9f5f..9c1164dadd8d 100644
--- a/crates/biome_js_parser/src/parse.rs
+++ b/crates/biome_js_parser/src/parse.rs
@@ -45,7 +45,7 @@ impl<T> Parse<T> {
     /// The syntax node represented by this Parse result
     ///
     /// ```
-    /// use biome_js_parser::{JsParserOptions, parse_script};
+    /// use biome_js_parser::parse_script;
     /// use biome_js_syntax::{JsIfStatement, JsSyntaxKind};
     /// use biome_rowan::{AstNode, AstNodeList};
     ///
@@ -54,8 +54,7 @@ impl<T> Parse<T> {
     ///     if (a > 5) {
     ///         /* something */
     ///     }
-    /// ",
-    ///  JsParserOptions::default()
+    /// "
     /// );
     ///
     /// // The first stmt in the root syntax node (Script) is the if statement.
@@ -142,9 +141,8 @@ impl From<JsOffsetParse> for AnyParse {
 fn parse_common(
     text: &str,
     source_type: JsFileSource,
-    options: JsParserOptions,
 ) -> (Vec<Event<JsSyntaxKind>>, Vec<ParseDiagnostic>, Vec<Trivia>) {
-    let mut parser = JsParser::new(text, source_type, options);
+    let mut parser = JsParser::new(text, source_type);
     syntax::program::parse(&mut parser);
 
     let (events, trivia, errors) = parser.finish();
@@ -156,11 +154,11 @@ fn parse_common(
 /// Or turned into a typed [`JsScript`](JsScript) with [`tree`](Parse::tree).
 ///
 /// ```
-/// use biome_js_parser::{JsParserOptions, parse_script};
+/// use biome_js_parser::parse_script;
 /// use biome_js_syntax::{JsSyntaxToken, JsFileSource, JsSyntaxList, JsComputedMemberExpression};
 /// use biome_rowan::{AstNode, Direction};
 ///
-/// let parse = parse_script("foo.bar[2]", JsParserOptions::default());
+/// let parse = parse_script("foo.bar[2]");
 /// // Parse returns a JS Root which contains two lists, the directives and the statements, let's get the statements
 /// let stmt = parse.syntax().children().nth(1).unwrap();
 /// // The untyped syntax node of `foo.bar[2]`, the root node is `Script`.
@@ -183,11 +181,13 @@ fn parse_common(
 ///
 /// assert_eq!(&tokens, &vec!["foo", ".", "bar", "[", "2", "]"]);
 /// ```
-pub fn parse_script(text: &str, options: JsParserOptions) -> Parse<JsScript> {
+/// Parses the provided string as an ECMAScript script.
+///
+/// Parser options are automatically derived from the source type.
+pub fn parse_script(text: &str) -> Parse<JsScript> {
     parse(
         text,
         JsFileSource::js_module().with_module_kind(ModuleKind::Script),
-        options,
     )
     .cast::<JsScript>()
     .unwrap()
@@ -199,14 +199,14 @@ pub fn parse_script(text: &str, options: JsParserOptions) -> Parse<JsScript> {
 ///
 /// Check the diagnostics emitted by the code
 /// ```
-/// use biome_js_parser::{JsParserOptions, parse_module};
+/// use biome_js_parser::parse_module;
 /// let source = r#"
 /// import { someModule } from "./someModule.js";
 ///
 /// someModule();
 /// "#;
 ///
-/// let parse = parse_module(source, JsParserOptions::default());
+/// let parse = parse_module(source);
 ///
 /// // Retrieve the diagnostics emitted
 /// assert_eq!(parse.diagnostics().len(), 0);
@@ -214,7 +214,7 @@ pub fn parse_script(text: &str, options: JsParserOptions) -> Parse<JsScript> {
 ///
 /// Retrieve the emitted AST and check its kind:
 /// ```
-/// use biome_js_parser::{JsParserOptions, parse_module};
+/// use biome_js_parser::parse_module;
 /// use biome_js_syntax::JsSyntaxKind;
 /// use biome_rowan::AstNode;
 /// let source = r#"
@@ -222,15 +222,18 @@ pub fn parse_script(text: &str, options: JsParserOptions) -> Parse<JsScript> {
 ///
 /// someModule();
 /// "#;
-/// let parse = parse_module(source, JsParserOptions::default());
+/// let parse = parse_module(source);
 ///
 /// let tree = parse.tree();
 ///
 /// assert_eq!(tree.syntax().kind(), JsSyntaxKind::JS_MODULE);
 /// ```
 ///
-pub fn parse_module(text: &str, options: JsParserOptions) -> Parse<JsModule> {
-    parse(text, JsFileSource::js_module(), options)
+/// Parses the provided string as an ECMAScript module.
+///
+/// Parser options are automatically derived from the source type.
+pub fn parse_module(text: &str) -> Parse<JsModule> {
+    parse(text, JsFileSource::js_module())
         .cast::<JsModule>()
         .unwrap()
 }
@@ -240,27 +243,62 @@ pub fn parse_module(text: &str, options: JsParserOptions) -> Parse<JsModule> {
 /// ### Examples
 ///
 /// ```
-/// use biome_js_parser::{JsParserOptions, parse};
+/// use biome_js_parser::parse;
 /// use biome_js_syntax::{LanguageVariant, LanguageVersion, ModuleKind, JsFileSource};
 /// // parse source text as TypeScript
 /// let mut module = JsFileSource::ts();
-/// let mut parsed = parse("type F = {}", module, JsParserOptions::default());
+/// let mut parsed = parse("type F = {}", module);
 /// assert_eq!(parsed.diagnostics().len(), 0);
 /// // parse source text as JSX
 /// module = JsFileSource::jsx();
-/// parsed = parse("<Component></Component>", module, JsParserOptions::default());
+/// parsed = parse("<Component></Component>", module);
 /// assert_eq!(parsed.diagnostics().len(), 0);
 /// // parse source text with granular control
 /// module = JsFileSource::default()
 ///   .with_version(LanguageVersion::ESNext)
 ///   .with_module_kind(ModuleKind::Module)
 ///   .with_variant(LanguageVariant::Jsx);
-/// parsed = parse("foo[bar]", module, JsParserOptions::default());
+/// parsed = parse("foo[bar]", module);
 /// assert_eq!(parsed.diagnostics().len(), 0);
 /// ```
-pub fn parse(text: &str, source_type: JsFileSource, options: JsParserOptions) -> Parse<AnyJsRoot> {
+/// Parses the provided string as an ECMAScript program.
+///
+/// Parser options are automatically derived from the `source_type` based on
+/// file characteristics (language, variant, embedding kind, etc.).
+pub fn parse(text: &str, source_type: JsFileSource) -> Parse<AnyJsRoot> {
     let mut cache = NodeCache::default();
-    parse_js_with_cache(text, source_type, options, &mut cache)
+    parse_js_with_cache(text, source_type, &mut cache)
+}
+
+/// Parses with explicitly provided options (for testing).
+///
+/// This is primarily used by the test harness to apply custom parsing options
+/// from test configuration files. Regular code should use `parse` which derives
+/// options from the source type.
+pub fn parse_with_options(
+    text: &str,
+    source_type: JsFileSource,
+    options: JsParserOptions,
+) -> Parse<AnyJsRoot> {
+    let mut cache = NodeCache::default();
+    let (events, errors, tokens) = parse_common_with_options(text, source_type, options);
+    let mut tree_sink = JsLosslessTreeSink::with_cache(text, &tokens, &mut cache);
+    biome_parser::event::process(&mut tree_sink, events, errors);
+    let (green, parse_errors) = tree_sink.finish();
+    Parse::new(green, parse_errors)
+}
+
+fn parse_common_with_options(
+    text: &str,
+    source_type: JsFileSource,
+    options: JsParserOptions,
+) -> (Vec<Event<JsSyntaxKind>>, Vec<ParseDiagnostic>, Vec<Trivia>) {
+    let mut parser = parser::JsParser::with_options(text, source_type, options);
+    syntax::program::parse(&mut parser);
+
+    let (events, trivia, errors) = parser.finish();
+
+    (events, errors, trivia)
 }
 
 /// Parses the provided string as a EcmaScript program using the provided syntax features and node cache.
@@ -268,7 +306,7 @@ pub fn parse(text: &str, source_type: JsFileSource, options: JsParserOptions) ->
 /// ### Examples
 ///
 /// ```
-/// use biome_js_parser::{JsParserOptions, parse_js_with_cache};
+/// use biome_js_parser::parse_js_with_cache;
 /// use biome_js_syntax::JsFileSource;
 /// use biome_rowan::NodeCache;
 ///
@@ -276,20 +314,22 @@ pub fn parse(text: &str, source_type: JsFileSource, options: JsParserOptions) ->
 /// let mut cache = NodeCache::default();
 /// let mut source = "function f() { return 2 }";
 ///
-/// let parsed = parse_js_with_cache(source, source_type, JsParserOptions::default(), &mut cache);
+/// let parsed = parse_js_with_cache(source, source_type, &mut cache);
 /// assert_eq!(parsed.diagnostics().len(), 0);
 ///
 /// source = "function bar() { return 3 }";
-/// let parsed  = parse_js_with_cache(source, source_type, JsParserOptions::default(), &mut cache);
+/// let parsed  = parse_js_with_cache(source, source_type, &mut cache);
 /// assert_eq!(parsed.diagnostics().len(), 0);
 /// ```
+/// Parses the provided string using a node cache for improved performance.
+///
+/// Parser options are automatically derived from the `source_type`.
 pub fn parse_js_with_cache(
     text: &str,
     source_type: JsFileSource,
-    options: JsParserOptions,
     cache: &mut NodeCache,
 ) -> Parse<AnyJsRoot> {
-    let (events, errors, tokens) = parse_common(text, source_type, options);
+    let (events, errors, tokens) = parse_common(text, source_type);
     let mut tree_sink = JsLosslessTreeSink::with_cache(text, &tokens, cache);
     biome_parser::event::process(&mut tree_sink, events, errors);
     let (green, parse_errors) = tree_sink.finish();
@@ -400,7 +440,7 @@ pub fn parse_js_with_offset_and_cache(
     options: JsParserOptions,
     cache: &mut NodeCache,
 ) -> JsOffsetParse {
-    let (events, errors, tokens) = parse_common(text, source_type, options);
+    let (events, errors, tokens) = parse_common_with_options(text, source_type, options);
     let mut tree_sink =
         crate::JsOffsetLosslessTreeSink::with_cache(text, &tokens, cache, base_offset);
     biome_parser::event::process(&mut tree_sink, events, errors);
@@ -489,7 +529,6 @@ mod tests {
         let normal_parse = parse_js_with_cache(
             js_code,
             JsFileSource::js_module(),
-            JsParserOptions::default(),
             &mut biome_rowan::NodeCache::default(),
         );
 
diff --git a/crates/biome_js_parser/src/parser.rs b/crates/biome_js_parser/src/parser.rs
index 33a4df78c1e3..0e060088238a 100644
--- a/crates/biome_js_parser/src/parser.rs
+++ b/crates/biome_js_parser/src/parser.rs
@@ -40,8 +40,32 @@ pub struct JsParser<'source> {
 
 impl<'source> JsParser<'source> {
     /// Creates a new parser that parses the `source`.
-    pub fn new(source: &'source str, source_type: JsFileSource, options: JsParserOptions) -> Self {
-        let source = JsTokenSource::from_str(source, options);
+    ///
+    /// Parser options are automatically derived from the `source_type` based on
+    /// file characteristics (language, variant, embedding kind, etc.).
+    pub fn new(source: &'source str, source_type: JsFileSource) -> Self {
+        let options = JsParserOptions::from(&source_type);
+        let source = JsTokenSource::from_str(source, source_type);
+
+        JsParser {
+            state: JsParserState::new(&source_type),
+            source_type,
+            context: ParserContext::default(),
+            source,
+            options,
+        }
+    }
+
+    /// Creates a new parser with explicit options (for testing).
+    ///
+    /// This is primarily used by the test harness. Regular code should use `new`
+    /// which derives options from the source type.
+    pub(crate) fn with_options(
+        source: &'source str,
+        source_type: JsFileSource,
+        options: JsParserOptions,
+    ) -> Self {
+        let source = JsTokenSource::from_str(source, source_type);
 
         JsParser {
             state: JsParserState::new(&source_type),
@@ -226,7 +250,7 @@ mod tests {
         expected = "Marker must either be `completed` or `abandoned` to avoid that children are implicitly attached to a marker's parent."
     )]
     fn uncompleted_markers_panic() {
-        let mut parser = JsParser::new(
+        let mut parser = JsParser::with_options(
             "'use strict'",
             JsFileSource::default(),
             JsParserOptions::default(),
@@ -238,7 +262,7 @@ mod tests {
 
     #[test]
     fn completed_marker_doesnt_panic() {
-        let mut p = JsParser::new(
+        let mut p = JsParser::with_options(
             "'use strict'",
             JsFileSource::default(),
             JsParserOptions::default(),
@@ -251,7 +275,7 @@ mod tests {
 
     #[test]
     fn abandoned_marker_doesnt_panic() {
-        let mut p = JsParser::new(
+        let mut p = JsParser::with_options(
             "'use strict'",
             JsFileSource::default(),
             JsParserOptions::default(),
diff --git a/crates/biome_js_parser/src/syntax/class.rs b/crates/biome_js_parser/src/syntax/class.rs
index 2c337db6db53..5a6b5838938d 100644
--- a/crates/biome_js_parser/src/syntax/class.rs
+++ b/crates/biome_js_parser/src/syntax/class.rs
@@ -535,6 +535,12 @@ fn parse_class_member(p: &mut JsParser, inside_abstract_class: bool) -> ParsedSy
         return Present(member_marker.complete(p, JS_EMPTY_CLASS_MEMBER));
     }
 
+    // Glimmer templates in class bodies
+    if p.at(GLIMMER_TEMPLATE) {
+        p.bump(GLIMMER_TEMPLATE);
+        return Present(member_marker.complete(p, JS_GLIMMER_TEMPLATE));
+    }
+
     let mut modifiers = parse_class_member_modifiers(p, false);
 
     if is_at_static_initialization_block_class_member(p) {
diff --git a/crates/biome_js_parser/src/syntax/expr.rs b/crates/biome_js_parser/src/syntax/expr.rs
index 5b23ac83dc3c..dfdc98a783bd 100644
--- a/crates/biome_js_parser/src/syntax/expr.rs
+++ b/crates/biome_js_parser/src/syntax/expr.rs
@@ -1249,7 +1249,8 @@ pub(crate) fn is_nth_at_expression(p: &mut JsParser, n: usize) -> bool {
         | JS_NUMBER_LITERAL
         | JS_BIGINT_LITERAL
         | JS_STRING_LITERAL
-        | NULL_KW => true,
+        | NULL_KW
+        | GLIMMER_TEMPLATE => true,
         t => t.is_contextual_keyword() || t.is_future_reserved_keyword(),
     }
 }
@@ -1392,6 +1393,9 @@ fn parse_primary_expression(p: &mut JsParser, context: ExpressionContext) -> Par
         // let a = <number>b;
         T![<] if Jsx.is_supported(p) => return parse_jsx_tag_expression(p),
 
+        // Glimmer templates in .gjs/.gts files
+        GLIMMER_TEMPLATE => return parse_glimmer_template(p),
+
         // test_err js primary_expr_invalid_recovery
         // let a = \; foo();
         t if t.is_contextual_keyword() || t.is_future_reserved_keyword() => {
@@ -2168,3 +2172,14 @@ fn parse_import_call_expression(
     args.complete(p, JS_CALL_ARGUMENTS);
     marker.complete(p, JS_IMPORT_CALL_EXPRESSION)
 }
+
+/// Parses a Glimmer template block `<template>...</template>` in .gjs/.gts files
+pub(crate) fn parse_glimmer_template(p: &mut JsParser) -> ParsedSyntax {
+    if !p.at(GLIMMER_TEMPLATE) {
+        return Absent;
+    }
+
+    let m = p.start();
+    p.bump(GLIMMER_TEMPLATE);
+    Present(m.complete(p, JS_GLIMMER_TEMPLATE))
+}
diff --git a/crates/biome_js_parser/src/syntax/stmt.rs b/crates/biome_js_parser/src/syntax/stmt.rs
index a73bb0e31e08..c8abd0c22bbe 100644
--- a/crates/biome_js_parser/src/syntax/stmt.rs
+++ b/crates/biome_js_parser/src/syntax/stmt.rs
@@ -373,6 +373,12 @@ pub(crate) fn parse_statement(p: &mut JsParser, context: StatementContext) -> Pa
                 },
             )
         }
+        // Glimmer templates at top level in .gjs/.gts files
+        GLIMMER_TEMPLATE => {
+            let m = p.start();
+            p.bump(GLIMMER_TEMPLATE);
+            Present(m.complete(p, JS_GLIMMER_TEMPLATE))
+        }
         _ if is_at_expression(p) || is_at_metavariable(p) => parse_expression_statement(p),
         _ => Absent,
     }
diff --git a/crates/biome_js_parser/src/token_source.rs b/crates/biome_js_parser/src/token_source.rs
index f282a4f0eed7..e4037159e8d6 100644
--- a/crates/biome_js_parser/src/token_source.rs
+++ b/crates/biome_js_parser/src/token_source.rs
@@ -25,9 +25,21 @@ impl<'l> JsTokenSource<'l> {
         }
     }
 
-    /// Creates a new token source for the given string
-    pub fn from_str(source: &'l str, options: JsParserOptions) -> Self {
-        let lexer = JsLexer::from_str(source).with_options(options);
+    /// Creates a new token source for the given string.
+    ///
+    /// Parser options are automatically derived from the `source_type` using
+    /// `From<&JsFileSource> for JsParserOptions`, ensuring consistent configuration
+    /// based on file characteristics.
+    pub fn from_str(
+        source: &'l str,
+        source_type: biome_js_syntax::JsFileSource,
+    ) -> Self {
+        // Derive parser options from file source type
+        let options = JsParserOptions::from(&source_type);
+
+        let lexer = JsLexer::from_str(source)
+            .with_options(options)
+            .with_source_type(source_type);
         let buffered = BufferedLexer::new(lexer);
         let mut source = JsTokenSource::new(buffered);
 
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs
new file mode 100644
index 000000000000..11eb9e05c1fb
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs
@@ -0,0 +1,3 @@
+// Test bare < at EOF
+// Should handle EOF gracefully after less-than
+const x = <
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs.snap
new file mode 100644
index 000000000000..9ea45ccbe8ba
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_less_than.gjs.snap
@@ -0,0 +1,92 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test bare < at EOF
+// Should handle EOF gracefully after less-than
+const x = <
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..76 "const" [Comments("// Test bare < at EOF"), Newline("\n"), Comments("// Should handle EOF  ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@76..78 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@78..80 "=" [] [Whitespace(" ")],
+                            expression: JsBogusExpression {
+                                items: [
+                                    L_ANGLE@80..81 "<" [] [],
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@81..82 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..82
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..81
+    0: JS_VARIABLE_STATEMENT@0..81
+      0: JS_VARIABLE_DECLARATION@0..81
+        0: (empty)
+        1: CONST_KW@0..76 "const" [Comments("// Test bare < at EOF"), Newline("\n"), Comments("// Should handle EOF  ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@76..81
+          0: JS_VARIABLE_DECLARATOR@76..81
+            0: JS_IDENTIFIER_BINDING@76..78
+              0: IDENT@76..78 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@78..81
+              0: EQ@78..80 "=" [] [Whitespace(" ")]
+              1: JS_BOGUS_EXPRESSION@80..81
+                0: L_ANGLE@80..81 "<" [] []
+      1: (empty)
+  4: EOF@81..82 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_incomplete_less_than.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × type assertion are a TypeScript only feature. Convert your file to a TypeScript file or remove the syntax.
+  
+    1 │ // Test bare < at EOF
+    2 │ // Should handle EOF gracefully after less-than
+  > 3 │ const x = <
+      │           ^
+    4 │ 
+  
+  i TypeScript only syntax
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs
new file mode 100644
index 000000000000..f1f4078fed94
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs
@@ -0,0 +1,3 @@
+// Test incomplete "templat" at EOF
+// This tests lexer backtracking at EOF boundary
+const x = <templat
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs.snap
new file mode 100644
index 000000000000..af701d75bfa1
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_incomplete_templat.gjs.snap
@@ -0,0 +1,102 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test incomplete "templat" at EOF
+// This tests lexer backtracking at EOF boundary
+const x = <templat
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..91 "const" [Comments("// Test incomplete \"t ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@91..93 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@93..95 "=" [] [Whitespace(" ")],
+                            expression: JsBogusExpression {
+                                items: [
+                                    L_ANGLE@95..96 "<" [] [],
+                                    TsReferenceType {
+                                        name: JsReferenceIdentifier {
+                                            value_token: IDENT@96..103 "templat" [] [],
+                                        },
+                                        type_arguments: missing (optional),
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@103..104 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..104
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..103
+    0: JS_VARIABLE_STATEMENT@0..103
+      0: JS_VARIABLE_DECLARATION@0..103
+        0: (empty)
+        1: CONST_KW@0..91 "const" [Comments("// Test incomplete \"t ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@91..103
+          0: JS_VARIABLE_DECLARATOR@91..103
+            0: JS_IDENTIFIER_BINDING@91..93
+              0: IDENT@91..93 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@93..103
+              0: EQ@93..95 "=" [] [Whitespace(" ")]
+              1: JS_BOGUS_EXPRESSION@95..103
+                0: L_ANGLE@95..96 "<" [] []
+                1: TS_REFERENCE_TYPE@96..103
+                  0: JS_REFERENCE_IDENTIFIER@96..103
+                    0: IDENT@96..103 "templat" [] []
+                  1: (empty)
+      1: (empty)
+  4: EOF@103..104 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_incomplete_templat.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × type assertion are a TypeScript only feature. Convert your file to a TypeScript file or remove the syntax.
+  
+    1 │ // Test incomplete "templat" at EOF
+    2 │ // This tests lexer backtracking at EOF boundary
+  > 3 │ const x = <templat
+      │           ^^^^^^^^
+    4 │ 
+  
+  i TypeScript only syntax
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs
new file mode 100644
index 000000000000..aebaa21b1f3d
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs
@@ -0,0 +1,3 @@
+// Test that JSX (<div>) is forbidden in .gjs files
+// Only <template> tags are allowed, regular JSX is not
+const x = <div>content</div>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs.snap
new file mode 100644
index 000000000000..d11978e953c3
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_div.gjs.snap
@@ -0,0 +1,148 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test that JSX (<div>) is forbidden in .gjs files
+// Only <template> tags are allowed, regular JSX is not
+const x = <div>content</div>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..114 "const" [Comments("// Test that JSX (<di ..."), Newline("\n"), Comments("// Only <template> ta ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@114..116 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@116..118 "=" [] [Whitespace(" ")],
+                            expression: JsBinaryExpression {
+                                left: JsBogusExpression {
+                                    items: [
+                                        L_ANGLE@118..119 "<" [] [],
+                                        TsReferenceType {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@119..122 "div" [] [],
+                                            },
+                                            type_arguments: missing (optional),
+                                        },
+                                        R_ANGLE@122..123 ">" [] [],
+                                        JsIdentifierExpression {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@123..130 "content" [] [],
+                                            },
+                                        },
+                                    ],
+                                },
+                                operator_token: L_ANGLE@130..131 "<" [] [],
+                                right: JsRegexLiteralExpression {
+                                    value_token: JS_REGEX_LITERAL@131..137 "/div>;" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@137..138 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..138
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..137
+    0: JS_VARIABLE_STATEMENT@0..137
+      0: JS_VARIABLE_DECLARATION@0..137
+        0: (empty)
+        1: CONST_KW@0..114 "const" [Comments("// Test that JSX (<di ..."), Newline("\n"), Comments("// Only <template> ta ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@114..137
+          0: JS_VARIABLE_DECLARATOR@114..137
+            0: JS_IDENTIFIER_BINDING@114..116
+              0: IDENT@114..116 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@116..137
+              0: EQ@116..118 "=" [] [Whitespace(" ")]
+              1: JS_BINARY_EXPRESSION@118..137
+                0: JS_BOGUS_EXPRESSION@118..130
+                  0: L_ANGLE@118..119 "<" [] []
+                  1: TS_REFERENCE_TYPE@119..122
+                    0: JS_REFERENCE_IDENTIFIER@119..122
+                      0: IDENT@119..122 "div" [] []
+                    1: (empty)
+                  2: R_ANGLE@122..123 ">" [] []
+                  3: JS_IDENTIFIER_EXPRESSION@123..130
+                    0: JS_REFERENCE_IDENTIFIER@123..130
+                      0: IDENT@123..130 "content" [] []
+                1: L_ANGLE@130..131 "<" [] []
+                2: JS_REGEX_LITERAL_EXPRESSION@131..137
+                  0: JS_REGEX_LITERAL@131..137 "/div>;" [] []
+      1: (empty)
+  4: EOF@137..138 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_lookalike_div.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × type assertion are a TypeScript only feature. Convert your file to a TypeScript file or remove the syntax.
+  
+    1 │ // Test that JSX (<div>) is forbidden in .gjs files
+    2 │ // Only <template> tags are allowed, regular JSX is not
+  > 3 │ const x = <div>content</div>;
+      │           ^^^^^^^^^^^^
+    4 │ 
+  
+  i TypeScript only syntax
+  
+glimmer_lookalike_div.gjs:3:30 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × unterminated regex literal
+  
+    1 │ // Test that JSX (<div>) is forbidden in .gjs files
+    2 │ // Only <template> tags are allowed, regular JSX is not
+  > 3 │ const x = <div>content</div>;
+      │                              
+    4 │ 
+  
+  i ...but the line ends here
+  
+    1 │ // Test that JSX (<div>) is forbidden in .gjs files
+    2 │ // Only <template> tags are allowed, regular JSX is not
+  > 3 │ const x = <div>content</div>;
+      │                              
+    4 │ 
+  
+  i a regex literal starts there...
+  
+    1 │ // Test that JSX (<div>) is forbidden in .gjs files
+    2 │ // Only <template> tags are allowed, regular JSX is not
+  > 3 │ const x = <div>content</div>;
+      │                        ^
+    4 │ 
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs
new file mode 100644
index 000000000000..7eb0e179c507
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs
@@ -0,0 +1,3 @@
+// Test that <temp> (not "template") is properly rejected
+// This tests lexer backtracking - should restore position and report clear error
+const x = <temp>content</temp>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs.snap
new file mode 100644
index 000000000000..bcd1edbfd749
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_temp.gjs.snap
@@ -0,0 +1,148 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test that <temp> (not "template") is properly rejected
+// This tests lexer backtracking - should restore position and report clear error
+const x = <temp>content</temp>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..146 "const" [Comments("// Test that <temp> ( ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@146..148 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@148..150 "=" [] [Whitespace(" ")],
+                            expression: JsBinaryExpression {
+                                left: JsBogusExpression {
+                                    items: [
+                                        L_ANGLE@150..151 "<" [] [],
+                                        TsReferenceType {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@151..155 "temp" [] [],
+                                            },
+                                            type_arguments: missing (optional),
+                                        },
+                                        R_ANGLE@155..156 ">" [] [],
+                                        JsIdentifierExpression {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@156..163 "content" [] [],
+                                            },
+                                        },
+                                    ],
+                                },
+                                operator_token: L_ANGLE@163..164 "<" [] [],
+                                right: JsRegexLiteralExpression {
+                                    value_token: JS_REGEX_LITERAL@164..171 "/temp>;" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@171..172 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..172
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..171
+    0: JS_VARIABLE_STATEMENT@0..171
+      0: JS_VARIABLE_DECLARATION@0..171
+        0: (empty)
+        1: CONST_KW@0..146 "const" [Comments("// Test that <temp> ( ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@146..171
+          0: JS_VARIABLE_DECLARATOR@146..171
+            0: JS_IDENTIFIER_BINDING@146..148
+              0: IDENT@146..148 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@148..171
+              0: EQ@148..150 "=" [] [Whitespace(" ")]
+              1: JS_BINARY_EXPRESSION@150..171
+                0: JS_BOGUS_EXPRESSION@150..163
+                  0: L_ANGLE@150..151 "<" [] []
+                  1: TS_REFERENCE_TYPE@151..155
+                    0: JS_REFERENCE_IDENTIFIER@151..155
+                      0: IDENT@151..155 "temp" [] []
+                    1: (empty)
+                  2: R_ANGLE@155..156 ">" [] []
+                  3: JS_IDENTIFIER_EXPRESSION@156..163
+                    0: JS_REFERENCE_IDENTIFIER@156..163
+                      0: IDENT@156..163 "content" [] []
+                1: L_ANGLE@163..164 "<" [] []
+                2: JS_REGEX_LITERAL_EXPRESSION@164..171
+                  0: JS_REGEX_LITERAL@164..171 "/temp>;" [] []
+      1: (empty)
+  4: EOF@171..172 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_lookalike_temp.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × type assertion are a TypeScript only feature. Convert your file to a TypeScript file or remove the syntax.
+  
+    1 │ // Test that <temp> (not "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <temp>content</temp>;
+      │           ^^^^^^^^^^^^^
+    4 │ 
+  
+  i TypeScript only syntax
+  
+glimmer_lookalike_temp.gjs:3:32 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × unterminated regex literal
+  
+    1 │ // Test that <temp> (not "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <temp>content</temp>;
+      │                                
+    4 │ 
+  
+  i ...but the line ends here
+  
+    1 │ // Test that <temp> (not "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <temp>content</temp>;
+      │                                
+    4 │ 
+  
+  i a regex literal starts there...
+  
+    1 │ // Test that <temp> (not "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <temp>content</temp>;
+      │                         ^
+    4 │ 
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs
new file mode 100644
index 000000000000..69aaa005e612
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs
@@ -0,0 +1,3 @@
+// Test that <templatex> (identifier after "template") is properly rejected
+// This tests lexer backtracking - should restore position and report clear error
+const x = <templatex>content</templatex>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs.snap
new file mode 100644
index 000000000000..0869bebd5f07
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_lookalike_templatex.gjs.snap
@@ -0,0 +1,148 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test that <templatex> (identifier after "template") is properly rejected
+// This tests lexer backtracking - should restore position and report clear error
+const x = <templatex>content</templatex>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..164 "const" [Comments("// Test that <templat ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@164..166 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@166..168 "=" [] [Whitespace(" ")],
+                            expression: JsBinaryExpression {
+                                left: JsBogusExpression {
+                                    items: [
+                                        L_ANGLE@168..169 "<" [] [],
+                                        TsReferenceType {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@169..178 "templatex" [] [],
+                                            },
+                                            type_arguments: missing (optional),
+                                        },
+                                        R_ANGLE@178..179 ">" [] [],
+                                        JsIdentifierExpression {
+                                            name: JsReferenceIdentifier {
+                                                value_token: IDENT@179..186 "content" [] [],
+                                            },
+                                        },
+                                    ],
+                                },
+                                operator_token: L_ANGLE@186..187 "<" [] [],
+                                right: JsRegexLiteralExpression {
+                                    value_token: JS_REGEX_LITERAL@187..199 "/templatex>;" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@199..200 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..200
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..199
+    0: JS_VARIABLE_STATEMENT@0..199
+      0: JS_VARIABLE_DECLARATION@0..199
+        0: (empty)
+        1: CONST_KW@0..164 "const" [Comments("// Test that <templat ..."), Newline("\n"), Comments("// This tests lexer b ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@164..199
+          0: JS_VARIABLE_DECLARATOR@164..199
+            0: JS_IDENTIFIER_BINDING@164..166
+              0: IDENT@164..166 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@166..199
+              0: EQ@166..168 "=" [] [Whitespace(" ")]
+              1: JS_BINARY_EXPRESSION@168..199
+                0: JS_BOGUS_EXPRESSION@168..186
+                  0: L_ANGLE@168..169 "<" [] []
+                  1: TS_REFERENCE_TYPE@169..178
+                    0: JS_REFERENCE_IDENTIFIER@169..178
+                      0: IDENT@169..178 "templatex" [] []
+                    1: (empty)
+                  2: R_ANGLE@178..179 ">" [] []
+                  3: JS_IDENTIFIER_EXPRESSION@179..186
+                    0: JS_REFERENCE_IDENTIFIER@179..186
+                      0: IDENT@179..186 "content" [] []
+                1: L_ANGLE@186..187 "<" [] []
+                2: JS_REGEX_LITERAL_EXPRESSION@187..199
+                  0: JS_REGEX_LITERAL@187..199 "/templatex>;" [] []
+      1: (empty)
+  4: EOF@199..200 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_lookalike_templatex.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × type assertion are a TypeScript only feature. Convert your file to a TypeScript file or remove the syntax.
+  
+    1 │ // Test that <templatex> (identifier after "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <templatex>content</templatex>;
+      │           ^^^^^^^^^^^^^^^^^^
+    4 │ 
+  
+  i TypeScript only syntax
+  
+glimmer_lookalike_templatex.gjs:3:42 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × unterminated regex literal
+  
+    1 │ // Test that <templatex> (identifier after "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <templatex>content</templatex>;
+      │                                          
+    4 │ 
+  
+  i ...but the line ends here
+  
+    1 │ // Test that <templatex> (identifier after "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <templatex>content</templatex>;
+      │                                          
+    4 │ 
+  
+  i a regex literal starts there...
+  
+    1 │ // Test that <templatex> (identifier after "template") is properly rejected
+    2 │ // This tests lexer backtracking - should restore position and report clear error
+  > 3 │ const x = <templatex>content</templatex>;
+      │                              ^
+    4 │ 
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs
new file mode 100644
index 000000000000..d89b5009d793
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs
@@ -0,0 +1,3 @@
+// Test self-closing template tag
+// Glimmer templates must have explicit closing tags, not self-closing
+const x = <template />;
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs.snap
new file mode 100644
index 000000000000..249777f8800e
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_self_closing.gjs.snap
@@ -0,0 +1,90 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Test self-closing template tag
+// Glimmer templates must have explicit closing tags, not self-closing
+const x = <template />;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..111 "const" [Comments("// Test self-closing  ..."), Newline("\n"), Comments("// Glimmer templates  ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@111..113 "x" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@113..115 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@115..129 "<template />;\n" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@129..129 "" [] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..129
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..129
+    0: JS_VARIABLE_STATEMENT@0..129
+      0: JS_VARIABLE_DECLARATION@0..129
+        0: (empty)
+        1: CONST_KW@0..111 "const" [Comments("// Test self-closing  ..."), Newline("\n"), Comments("// Glimmer templates  ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@111..129
+          0: JS_VARIABLE_DECLARATOR@111..129
+            0: JS_IDENTIFIER_BINDING@111..113
+              0: IDENT@111..113 "x" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@113..129
+              0: EQ@113..115 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@115..129
+                0: GLIMMER_TEMPLATE@115..129 "<template />;\n" [] []
+      1: (empty)
+  4: EOF@129..129 "" [] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_template_self_closing.gjs:3:11 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Unclosed `<template>` tag
+  
+    1 │ // Test self-closing template tag
+    2 │ // Glimmer templates must have explicit closing tags, not self-closing
+  > 3 │ const x = <template />;
+      │           ^^^^^^^^^^^^
+    4 │ 
+  
+  i Add a closing `</template>` tag
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs
new file mode 100644
index 000000000000..65544c188a9e
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs
@@ -0,0 +1,3 @@
+// Unclosed template should produce error
+const Broken = <template>
+  <div>This template is never closed
diff --git a/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs.snap
new file mode 100644
index 000000000000..834ec60d7243
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/error/glimmer/glimmer_template_unclosed.gjs.snap
@@ -0,0 +1,90 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Unclosed template should produce error
+const Broken = <template>
+  <div>This template is never closed
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..48 "const" [Comments("// Unclosed template  ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@48..55 "Broken" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@55..57 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@57..105 "<template>\n  <div>This template is never closed\n" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: missing (optional),
+        },
+    ],
+    eof_token: EOF@105..105 "" [] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..105
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..105
+    0: JS_VARIABLE_STATEMENT@0..105
+      0: JS_VARIABLE_DECLARATION@0..105
+        0: (empty)
+        1: CONST_KW@0..48 "const" [Comments("// Unclosed template  ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@48..105
+          0: JS_VARIABLE_DECLARATOR@48..105
+            0: JS_IDENTIFIER_BINDING@48..55
+              0: IDENT@48..55 "Broken" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@55..105
+              0: EQ@55..57 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@57..105
+                0: GLIMMER_TEMPLATE@57..105 "<template>\n  <div>This template is never closed\n" [] []
+      1: (empty)
+  4: EOF@105..105 "" [] []
+
+```
+
+## Diagnostics
+
+```
+glimmer_template_unclosed.gjs:2:16 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Unclosed `<template>` tag
+  
+    1 │ // Unclosed template should produce error
+  > 2 │ const Broken = <template>
+      │                ^^^^^^^^^^
+    3 │   <div>This template is never closed
+    4 │ 
+  
+  i Add a closing `</template>` tag
+  
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs
new file mode 100644
index 000000000000..fc9ea877fd7d
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs
@@ -0,0 +1,17 @@
+// Template in class body
+class MyComponent {
+  <template>
+    Hello from class
+  </template>
+}
+
+// Another class with template
+class AnotherComponent {
+  constructor() {
+    this.value = 42;
+  }
+
+  <template>
+    Component template
+  </template>
+}
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs.snap
new file mode 100644
index 000000000000..bd393c1fb43d
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_class.gjs.snap
@@ -0,0 +1,177 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Template in class body
+class MyComponent {
+  <template>
+    Hello from class
+  </template>
+}
+
+// Another class with template
+class AnotherComponent {
+  constructor() {
+    this.value = 42;
+  }
+
+  <template>
+    Component template
+  </template>
+}
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsClassDeclaration {
+            decorators: JsDecoratorList [],
+            abstract_token: missing (optional),
+            class_token: CLASS_KW@0..32 "class" [Comments("// Template in class  ..."), Newline("\n")] [Whitespace(" ")],
+            id: JsIdentifierBinding {
+                name_token: IDENT@32..44 "MyComponent" [] [Whitespace(" ")],
+            },
+            type_parameters: missing (optional),
+            extends_clause: missing (optional),
+            implements_clause: missing (optional),
+            l_curly_token: L_CURLY@44..45 "{" [] [],
+            members: JsClassMemberList [
+                JsGlimmerTemplate {
+                    template_token_token: GLIMMER_TEMPLATE@45..93 "<template>\n    Hello from class\n  </template>" [Newline("\n"), Whitespace("  ")] [],
+                },
+            ],
+            r_curly_token: R_CURLY@93..95 "}" [Newline("\n")] [],
+        },
+        JsClassDeclaration {
+            decorators: JsDecoratorList [],
+            abstract_token: missing (optional),
+            class_token: CLASS_KW@95..134 "class" [Newline("\n"), Newline("\n"), Comments("// Another class with ..."), Newline("\n")] [Whitespace(" ")],
+            id: JsIdentifierBinding {
+                name_token: IDENT@134..151 "AnotherComponent" [] [Whitespace(" ")],
+            },
+            type_parameters: missing (optional),
+            extends_clause: missing (optional),
+            implements_clause: missing (optional),
+            l_curly_token: L_CURLY@151..152 "{" [] [],
+            members: JsClassMemberList [
+                JsConstructorClassMember {
+                    modifiers: JsConstructorModifierList [],
+                    name: JsLiteralMemberName {
+                        value: IDENT@152..166 "constructor" [Newline("\n"), Whitespace("  ")] [],
+                    },
+                    parameters: JsConstructorParameters {
+                        l_paren_token: L_PAREN@166..167 "(" [] [],
+                        parameters: JsConstructorParameterList [],
+                        r_paren_token: R_PAREN@167..169 ")" [] [Whitespace(" ")],
+                    },
+                    body: JsFunctionBody {
+                        l_curly_token: L_CURLY@169..170 "{" [] [],
+                        directives: JsDirectiveList [],
+                        statements: JsStatementList [
+                            JsExpressionStatement {
+                                expression: JsAssignmentExpression {
+                                    left: JsStaticMemberAssignment {
+                                        object: JsThisExpression {
+                                            this_token: THIS_KW@170..179 "this" [Newline("\n"), Whitespace("    ")] [],
+                                        },
+                                        dot_token: DOT@179..180 "." [] [],
+                                        member: JsName {
+                                            value_token: IDENT@180..186 "value" [] [Whitespace(" ")],
+                                        },
+                                    },
+                                    operator_token: EQ@186..188 "=" [] [Whitespace(" ")],
+                                    right: JsNumberLiteralExpression {
+                                        value_token: JS_NUMBER_LITERAL@188..190 "42" [] [],
+                                    },
+                                },
+                                semicolon_token: SEMICOLON@190..191 ";" [] [],
+                            },
+                        ],
+                        r_curly_token: R_CURLY@191..195 "}" [Newline("\n"), Whitespace("  ")] [],
+                    },
+                },
+                JsGlimmerTemplate {
+                    template_token_token: GLIMMER_TEMPLATE@195..246 "<template>\n    Component template\n  </template>" [Newline("\n"), Newline("\n"), Whitespace("  ")] [],
+                },
+            ],
+            r_curly_token: R_CURLY@246..248 "}" [Newline("\n")] [],
+        },
+    ],
+    eof_token: EOF@248..249 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..249
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..248
+    0: JS_CLASS_DECLARATION@0..95
+      0: JS_DECORATOR_LIST@0..0
+      1: (empty)
+      2: CLASS_KW@0..32 "class" [Comments("// Template in class  ..."), Newline("\n")] [Whitespace(" ")]
+      3: JS_IDENTIFIER_BINDING@32..44
+        0: IDENT@32..44 "MyComponent" [] [Whitespace(" ")]
+      4: (empty)
+      5: (empty)
+      6: (empty)
+      7: L_CURLY@44..45 "{" [] []
+      8: JS_CLASS_MEMBER_LIST@45..93
+        0: JS_GLIMMER_TEMPLATE@45..93
+          0: GLIMMER_TEMPLATE@45..93 "<template>\n    Hello from class\n  </template>" [Newline("\n"), Whitespace("  ")] []
+      9: R_CURLY@93..95 "}" [Newline("\n")] []
+    1: JS_CLASS_DECLARATION@95..248
+      0: JS_DECORATOR_LIST@95..95
+      1: (empty)
+      2: CLASS_KW@95..134 "class" [Newline("\n"), Newline("\n"), Comments("// Another class with ..."), Newline("\n")] [Whitespace(" ")]
+      3: JS_IDENTIFIER_BINDING@134..151
+        0: IDENT@134..151 "AnotherComponent" [] [Whitespace(" ")]
+      4: (empty)
+      5: (empty)
+      6: (empty)
+      7: L_CURLY@151..152 "{" [] []
+      8: JS_CLASS_MEMBER_LIST@152..246
+        0: JS_CONSTRUCTOR_CLASS_MEMBER@152..195
+          0: JS_CONSTRUCTOR_MODIFIER_LIST@152..152
+          1: JS_LITERAL_MEMBER_NAME@152..166
+            0: IDENT@152..166 "constructor" [Newline("\n"), Whitespace("  ")] []
+          2: JS_CONSTRUCTOR_PARAMETERS@166..169
+            0: L_PAREN@166..167 "(" [] []
+            1: JS_CONSTRUCTOR_PARAMETER_LIST@167..167
+            2: R_PAREN@167..169 ")" [] [Whitespace(" ")]
+          3: JS_FUNCTION_BODY@169..195
+            0: L_CURLY@169..170 "{" [] []
+            1: JS_DIRECTIVE_LIST@170..170
+            2: JS_STATEMENT_LIST@170..191
+              0: JS_EXPRESSION_STATEMENT@170..191
+                0: JS_ASSIGNMENT_EXPRESSION@170..190
+                  0: JS_STATIC_MEMBER_ASSIGNMENT@170..186
+                    0: JS_THIS_EXPRESSION@170..179
+                      0: THIS_KW@170..179 "this" [Newline("\n"), Whitespace("    ")] []
+                    1: DOT@179..180 "." [] []
+                    2: JS_NAME@180..186
+                      0: IDENT@180..186 "value" [] [Whitespace(" ")]
+                  1: EQ@186..188 "=" [] [Whitespace(" ")]
+                  2: JS_NUMBER_LITERAL_EXPRESSION@188..190
+                    0: JS_NUMBER_LITERAL@188..190 "42" [] []
+                1: SEMICOLON@190..191 ";" [] []
+            3: R_CURLY@191..195 "}" [Newline("\n"), Whitespace("  ")] []
+        1: JS_GLIMMER_TEMPLATE@195..246
+          0: GLIMMER_TEMPLATE@195..246 "<template>\n    Component template\n  </template>" [Newline("\n"), Newline("\n"), Whitespace("  ")] []
+      9: R_CURLY@246..248 "}" [Newline("\n")] []
+  4: EOF@248..249 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs
new file mode 100644
index 000000000000..822be46d1a14
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs
@@ -0,0 +1,4 @@
+// Single template in file (treated as default export)
+<template>
+  <div>This is the default template</div>
+</template>
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs.snap
new file mode 100644
index 000000000000..07593f30ab26
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_default_export.gjs.snap
@@ -0,0 +1,44 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Single template in file (treated as default export)
+<template>
+  <div>This is the default template</div>
+</template>
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsGlimmerTemplate {
+            template_token_token: GLIMMER_TEMPLATE@0..119 "<template>\n  <div>This is the default template</div>\n</template>" [Comments("// Single template in ..."), Newline("\n")] [],
+        },
+    ],
+    eof_token: EOF@119..120 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..120
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..119
+    0: JS_GLIMMER_TEMPLATE@0..119
+      0: GLIMMER_TEMPLATE@0..119 "<template>\n  <div>This is the default template</div>\n</template>" [Comments("// Single template in ..."), Newline("\n")] []
+  4: EOF@119..120 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs
new file mode 100644
index 000000000000..910681f0e221
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs
@@ -0,0 +1,5 @@
+// Template as expression
+const MyTemplate = <template>Hello World</template>;
+
+// Export template
+export const Exported = <template>Exported content</template>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs.snap
new file mode 100644
index 000000000000..3934d9649bd0
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_simple.gjs.snap
@@ -0,0 +1,117 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Template as expression
+const MyTemplate = <template>Hello World</template>;
+
+// Export template
+export const Exported = <template>Exported content</template>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..32 "const" [Comments("// Template as expres ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@32..43 "MyTemplate" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@43..45 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@45..77 "<template>Hello World</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@77..78 ";" [] [],
+        },
+        JsExport {
+            decorators: JsDecoratorList [],
+            export_token: EXPORT_KW@78..106 "export" [Newline("\n"), Newline("\n"), Comments("// Export template"), Newline("\n")] [Whitespace(" ")],
+            export_clause: JsVariableDeclarationClause {
+                declaration: JsVariableDeclaration {
+                    await_token: missing (optional),
+                    kind: CONST_KW@106..112 "const" [] [Whitespace(" ")],
+                    declarators: JsVariableDeclaratorList [
+                        JsVariableDeclarator {
+                            id: JsIdentifierBinding {
+                                name_token: IDENT@112..121 "Exported" [] [Whitespace(" ")],
+                            },
+                            variable_annotation: missing (optional),
+                            initializer: JsInitializerClause {
+                                eq_token: EQ@121..123 "=" [] [Whitespace(" ")],
+                                expression: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@123..160 "<template>Exported content</template>" [] [],
+                                },
+                            },
+                        },
+                    ],
+                },
+                semicolon_token: SEMICOLON@160..161 ";" [] [],
+            },
+        },
+    ],
+    eof_token: EOF@161..162 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..162
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..161
+    0: JS_VARIABLE_STATEMENT@0..78
+      0: JS_VARIABLE_DECLARATION@0..77
+        0: (empty)
+        1: CONST_KW@0..32 "const" [Comments("// Template as expres ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@32..77
+          0: JS_VARIABLE_DECLARATOR@32..77
+            0: JS_IDENTIFIER_BINDING@32..43
+              0: IDENT@32..43 "MyTemplate" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@43..77
+              0: EQ@43..45 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@45..77
+                0: GLIMMER_TEMPLATE@45..77 "<template>Hello World</template>" [] []
+      1: SEMICOLON@77..78 ";" [] []
+    1: JS_EXPORT@78..161
+      0: JS_DECORATOR_LIST@78..78
+      1: EXPORT_KW@78..106 "export" [Newline("\n"), Newline("\n"), Comments("// Export template"), Newline("\n")] [Whitespace(" ")]
+      2: JS_VARIABLE_DECLARATION_CLAUSE@106..161
+        0: JS_VARIABLE_DECLARATION@106..160
+          0: (empty)
+          1: CONST_KW@106..112 "const" [] [Whitespace(" ")]
+          2: JS_VARIABLE_DECLARATOR_LIST@112..160
+            0: JS_VARIABLE_DECLARATOR@112..160
+              0: JS_IDENTIFIER_BINDING@112..121
+                0: IDENT@112..121 "Exported" [] [Whitespace(" ")]
+              1: (empty)
+              2: JS_INITIALIZER_CLAUSE@121..160
+                0: EQ@121..123 "=" [] [Whitespace(" ")]
+                1: JS_GLIMMER_TEMPLATE@123..160
+                  0: GLIMMER_TEMPLATE@123..160 "<template>Exported content</template>" [] []
+        1: SEMICOLON@160..161 ";" [] []
+  4: EOF@161..162 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts
new file mode 100644
index 000000000000..1fb3ff6450ce
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts
@@ -0,0 +1,13 @@
+// Template in TypeScript file
+const MyTemplate: TemplateFactory = <template>
+  <div>Hello TypeScript</div>
+</template>;
+
+// Class with template in TypeScript
+class TypedComponent {
+  private value: number = 42;
+
+  <template>
+    <span>{{this.value}}</span>
+  </template>
+}
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts.snap
new file mode 100644
index 000000000000..b7072eed70d1
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_typescript.gts.snap
@@ -0,0 +1,166 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```ts
+// Template in TypeScript file
+const MyTemplate: TemplateFactory = <template>
+  <div>Hello TypeScript</div>
+</template>;
+
+// Class with template in TypeScript
+class TypedComponent {
+  private value: number = 42;
+
+  <template>
+    <span>{{this.value}}</span>
+  </template>
+}
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..37 "const" [Comments("// Template in TypeSc ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@37..47 "MyTemplate" [] [],
+                        },
+                        variable_annotation: TsTypeAnnotation {
+                            colon_token: COLON@47..49 ":" [] [Whitespace(" ")],
+                            ty: TsReferenceType {
+                                name: JsReferenceIdentifier {
+                                    value_token: IDENT@49..65 "TemplateFactory" [] [Whitespace(" ")],
+                                },
+                                type_arguments: missing (optional),
+                            },
+                        },
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@65..67 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@67..119 "<template>\n  <div>Hello TypeScript</div>\n</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@119..120 ";" [] [],
+        },
+        JsClassDeclaration {
+            decorators: JsDecoratorList [],
+            abstract_token: missing (optional),
+            class_token: CLASS_KW@120..165 "class" [Newline("\n"), Newline("\n"), Comments("// Class with templat ..."), Newline("\n")] [Whitespace(" ")],
+            id: JsIdentifierBinding {
+                name_token: IDENT@165..180 "TypedComponent" [] [Whitespace(" ")],
+            },
+            type_parameters: missing (optional),
+            extends_clause: missing (optional),
+            implements_clause: missing (optional),
+            l_curly_token: L_CURLY@180..181 "{" [] [],
+            members: JsClassMemberList [
+                JsPropertyClassMember {
+                    modifiers: JsPropertyModifierList [
+                        TsAccessibilityModifier {
+                            modifier_token: PRIVATE_KW@181..192 "private" [Newline("\n"), Whitespace("  ")] [Whitespace(" ")],
+                        },
+                    ],
+                    name: JsLiteralMemberName {
+                        value: IDENT@192..197 "value" [] [],
+                    },
+                    property_annotation: TsTypeAnnotation {
+                        colon_token: COLON@197..199 ":" [] [Whitespace(" ")],
+                        ty: TsNumberType {
+                            number_token: NUMBER_KW@199..206 "number" [] [Whitespace(" ")],
+                        },
+                    },
+                    value: JsInitializerClause {
+                        eq_token: EQ@206..208 "=" [] [Whitespace(" ")],
+                        expression: JsNumberLiteralExpression {
+                            value_token: JS_NUMBER_LITERAL@208..210 "42" [] [],
+                        },
+                    },
+                    semicolon_token: SEMICOLON@210..211 ";" [] [],
+                },
+                JsGlimmerTemplate {
+                    template_token_token: GLIMMER_TEMPLATE@211..271 "<template>\n    <span>{{this.value}}</span>\n  </template>" [Newline("\n"), Newline("\n"), Whitespace("  ")] [],
+                },
+            ],
+            r_curly_token: R_CURLY@271..273 "}" [Newline("\n")] [],
+        },
+    ],
+    eof_token: EOF@273..274 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..274
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..273
+    0: JS_VARIABLE_STATEMENT@0..120
+      0: JS_VARIABLE_DECLARATION@0..119
+        0: (empty)
+        1: CONST_KW@0..37 "const" [Comments("// Template in TypeSc ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@37..119
+          0: JS_VARIABLE_DECLARATOR@37..119
+            0: JS_IDENTIFIER_BINDING@37..47
+              0: IDENT@37..47 "MyTemplate" [] []
+            1: TS_TYPE_ANNOTATION@47..65
+              0: COLON@47..49 ":" [] [Whitespace(" ")]
+              1: TS_REFERENCE_TYPE@49..65
+                0: JS_REFERENCE_IDENTIFIER@49..65
+                  0: IDENT@49..65 "TemplateFactory" [] [Whitespace(" ")]
+                1: (empty)
+            2: JS_INITIALIZER_CLAUSE@65..119
+              0: EQ@65..67 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@67..119
+                0: GLIMMER_TEMPLATE@67..119 "<template>\n  <div>Hello TypeScript</div>\n</template>" [] []
+      1: SEMICOLON@119..120 ";" [] []
+    1: JS_CLASS_DECLARATION@120..273
+      0: JS_DECORATOR_LIST@120..120
+      1: (empty)
+      2: CLASS_KW@120..165 "class" [Newline("\n"), Newline("\n"), Comments("// Class with templat ..."), Newline("\n")] [Whitespace(" ")]
+      3: JS_IDENTIFIER_BINDING@165..180
+        0: IDENT@165..180 "TypedComponent" [] [Whitespace(" ")]
+      4: (empty)
+      5: (empty)
+      6: (empty)
+      7: L_CURLY@180..181 "{" [] []
+      8: JS_CLASS_MEMBER_LIST@181..271
+        0: JS_PROPERTY_CLASS_MEMBER@181..211
+          0: JS_PROPERTY_MODIFIER_LIST@181..192
+            0: TS_ACCESSIBILITY_MODIFIER@181..192
+              0: PRIVATE_KW@181..192 "private" [Newline("\n"), Whitespace("  ")] [Whitespace(" ")]
+          1: JS_LITERAL_MEMBER_NAME@192..197
+            0: IDENT@192..197 "value" [] []
+          2: TS_TYPE_ANNOTATION@197..206
+            0: COLON@197..199 ":" [] [Whitespace(" ")]
+            1: TS_NUMBER_TYPE@199..206
+              0: NUMBER_KW@199..206 "number" [] [Whitespace(" ")]
+          3: JS_INITIALIZER_CLAUSE@206..210
+            0: EQ@206..208 "=" [] [Whitespace(" ")]
+            1: JS_NUMBER_LITERAL_EXPRESSION@208..210
+              0: JS_NUMBER_LITERAL@208..210 "42" [] []
+          4: SEMICOLON@210..211 ";" [] []
+        1: JS_GLIMMER_TEMPLATE@211..271
+          0: GLIMMER_TEMPLATE@211..271 "<template>\n    <span>{{this.value}}</span>\n  </template>" [Newline("\n"), Newline("\n"), Whitespace("  ")] []
+      9: R_CURLY@271..273 "}" [Newline("\n")] []
+  4: EOF@273..274 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs
new file mode 100644
index 000000000000..0b777a6202a8
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs
@@ -0,0 +1,13 @@
+// Template with whitespace after 'template' keyword
+// This tests the edge case where there's whitespace before the '>'
+const WithSpace = <template >Hello World</template>;
+
+// Template with tab
+const WithTab = <template	>Hello Tab</template>;
+
+// Template with newline
+const WithNewline = <template
+>Hello Newline</template>;
+
+// Multiple spaces
+const MultipleSpaces = <template    >Hello Spaces</template>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs.snap
new file mode 100644
index 000000000000..8f998f5bf604
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_whitespace.gjs.snap
@@ -0,0 +1,188 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Template with whitespace after 'template' keyword
+// This tests the edge case where there's whitespace before the '>'
+const WithSpace = <template >Hello World</template>;
+
+// Template with tab
+const WithTab = <template	>Hello Tab</template>;
+
+// Template with newline
+const WithNewline = <template
+>Hello Newline</template>;
+
+// Multiple spaces
+const MultipleSpaces = <template    >Hello Spaces</template>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..127 "const" [Comments("// Template with whit ..."), Newline("\n"), Comments("// This tests the edg ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@127..137 "WithSpace" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@137..139 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@139..172 "<template >Hello World</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@172..173 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@173..202 "const" [Newline("\n"), Newline("\n"), Comments("// Template with tab"), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@202..210 "WithTab" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@210..212 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@212..243 "<template\t>Hello Tab</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@243..244 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@244..277 "const" [Newline("\n"), Newline("\n"), Comments("// Template with newline"), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@277..289 "WithNewline" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@289..291 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@291..326 "<template\n>Hello Newline</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@326..327 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@327..354 "const" [Newline("\n"), Newline("\n"), Comments("// Multiple spaces"), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@354..369 "MultipleSpaces" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@369..371 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@371..408 "<template    >Hello Spaces</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@408..409 ";" [] [],
+        },
+    ],
+    eof_token: EOF@409..410 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..410
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..409
+    0: JS_VARIABLE_STATEMENT@0..173
+      0: JS_VARIABLE_DECLARATION@0..172
+        0: (empty)
+        1: CONST_KW@0..127 "const" [Comments("// Template with whit ..."), Newline("\n"), Comments("// This tests the edg ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@127..172
+          0: JS_VARIABLE_DECLARATOR@127..172
+            0: JS_IDENTIFIER_BINDING@127..137
+              0: IDENT@127..137 "WithSpace" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@137..172
+              0: EQ@137..139 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@139..172
+                0: GLIMMER_TEMPLATE@139..172 "<template >Hello World</template>" [] []
+      1: SEMICOLON@172..173 ";" [] []
+    1: JS_VARIABLE_STATEMENT@173..244
+      0: JS_VARIABLE_DECLARATION@173..243
+        0: (empty)
+        1: CONST_KW@173..202 "const" [Newline("\n"), Newline("\n"), Comments("// Template with tab"), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@202..243
+          0: JS_VARIABLE_DECLARATOR@202..243
+            0: JS_IDENTIFIER_BINDING@202..210
+              0: IDENT@202..210 "WithTab" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@210..243
+              0: EQ@210..212 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@212..243
+                0: GLIMMER_TEMPLATE@212..243 "<template\t>Hello Tab</template>" [] []
+      1: SEMICOLON@243..244 ";" [] []
+    2: JS_VARIABLE_STATEMENT@244..327
+      0: JS_VARIABLE_DECLARATION@244..326
+        0: (empty)
+        1: CONST_KW@244..277 "const" [Newline("\n"), Newline("\n"), Comments("// Template with newline"), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@277..326
+          0: JS_VARIABLE_DECLARATOR@277..326
+            0: JS_IDENTIFIER_BINDING@277..289
+              0: IDENT@277..289 "WithNewline" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@289..326
+              0: EQ@289..291 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@291..326
+                0: GLIMMER_TEMPLATE@291..326 "<template\n>Hello Newline</template>" [] []
+      1: SEMICOLON@326..327 ";" [] []
+    3: JS_VARIABLE_STATEMENT@327..409
+      0: JS_VARIABLE_DECLARATION@327..408
+        0: (empty)
+        1: CONST_KW@327..354 "const" [Newline("\n"), Newline("\n"), Comments("// Multiple spaces"), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@354..408
+          0: JS_VARIABLE_DECLARATOR@354..408
+            0: JS_IDENTIFIER_BINDING@354..369
+              0: IDENT@354..369 "MultipleSpaces" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@369..408
+              0: EQ@369..371 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@371..408
+                0: GLIMMER_TEMPLATE@371..408 "<template    >Hello Spaces</template>" [] []
+      1: SEMICOLON@408..409 ";" [] []
+  4: EOF@409..410 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs
new file mode 100644
index 000000000000..89b226171c32
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs
@@ -0,0 +1,10 @@
+// Template with various content
+const MyTemplate = <template>
+  <div>
+    <h1>Hello {{name}}</h1>
+    <p>{{@description}}</p>
+    {{#each items as |item|}}
+      <li>{{item}}</li>
+    {{/each}}
+  </div>
+</template>;
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs.snap
new file mode 100644
index 000000000000..f1ae29288252
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_with_content.gjs.snap
@@ -0,0 +1,80 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Template with various content
+const MyTemplate = <template>
+  <div>
+    <h1>Hello {{name}}</h1>
+    <p>{{@description}}</p>
+    {{#each items as |item|}}
+      <li>{{item}}</li>
+    {{/each}}
+  </div>
+</template>;
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@0..39 "const" [Comments("// Template with vari ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@39..50 "MyTemplate" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@50..52 "=" [] [Whitespace(" ")],
+                            expression: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@52..215 "<template>\n  <div>\n    <h1>Hello {{name}}</h1>\n    <p>{{@description}}</p>\n    {{#each items as |item|}}\n      <li>{{item}}</li>\n    {{/each}}\n  </div>\n</template>" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@215..216 ";" [] [],
+        },
+    ],
+    eof_token: EOF@216..217 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..217
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..216
+    0: JS_VARIABLE_STATEMENT@0..216
+      0: JS_VARIABLE_DECLARATION@0..215
+        0: (empty)
+        1: CONST_KW@0..39 "const" [Comments("// Template with vari ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@39..215
+          0: JS_VARIABLE_DECLARATOR@39..215
+            0: JS_IDENTIFIER_BINDING@39..50
+              0: IDENT@39..50 "MyTemplate" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@50..215
+              0: EQ@50..52 "=" [] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@52..215
+                0: GLIMMER_TEMPLATE@52..215 "<template>\n  <div>\n    <h1>Hello {{name}}</h1>\n    <p>{{@description}}</p>\n    {{#each items as |item|}}\n      <li>{{item}}</li>\n    {{/each}}\n  </div>\n</template>" [] []
+      1: SEMICOLON@215..216 ";" [] []
+  4: EOF@216..217 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs
new file mode 100644
index 000000000000..b9c6e855420d
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs
@@ -0,0 +1,21 @@
+// Template with yield expression
+function* generator() {
+    yield <template>Yielded template</template>;
+}
+
+// Template with await expression
+async function asyncFn() {
+    await <template>Awaited template</template>;
+}
+
+// Template after typeof
+const TypeOf = typeof <template>Type test</template>;
+
+// Template in conditional
+const conditional = true ? <template>True</template> : <template>False</template>;
+
+// Template with void
+const voidResult = void <template>Void template</template>;
+
+// Template with delete (unusual but valid expression)
+const obj = { prop: <template>Prop</template> };
diff --git a/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs.snap b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs.snap
new file mode 100644
index 000000000000..e977014f3ec9
--- /dev/null
+++ b/crates/biome_js_parser/tests/js_test_suite/ok/glimmer/glimmer_template_yield_await.gjs.snap
@@ -0,0 +1,356 @@
+---
+source: crates/biome_js_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```js
+// Template with yield expression
+function* generator() {
+    yield <template>Yielded template</template>;
+}
+
+// Template with await expression
+async function asyncFn() {
+    await <template>Awaited template</template>;
+}
+
+// Template after typeof
+const TypeOf = typeof <template>Type test</template>;
+
+// Template in conditional
+const conditional = true ? <template>True</template> : <template>False</template>;
+
+// Template with void
+const voidResult = void <template>Void template</template>;
+
+// Template with delete (unusual but valid expression)
+const obj = { prop: <template>Prop</template> };
+
+```
+
+
+## AST
+
+```
+JsModule {
+    bom_token: missing (optional),
+    interpreter_token: missing (optional),
+    directives: JsDirectiveList [],
+    items: JsModuleItemList [
+        JsFunctionDeclaration {
+            async_token: missing (optional),
+            function_token: FUNCTION_KW@0..42 "function" [Comments("// Template with yiel ..."), Newline("\n")] [],
+            star_token: STAR@42..44 "*" [] [Whitespace(" ")],
+            id: JsIdentifierBinding {
+                name_token: IDENT@44..53 "generator" [] [],
+            },
+            type_parameters: missing (optional),
+            parameters: JsParameters {
+                l_paren_token: L_PAREN@53..54 "(" [] [],
+                items: JsParameterList [],
+                r_paren_token: R_PAREN@54..56 ")" [] [Whitespace(" ")],
+            },
+            return_type_annotation: missing (optional),
+            body: JsFunctionBody {
+                l_curly_token: L_CURLY@56..57 "{" [] [],
+                directives: JsDirectiveList [],
+                statements: JsStatementList [
+                    JsExpressionStatement {
+                        expression: JsYieldExpression {
+                            yield_token: YIELD_KW@57..68 "yield" [Newline("\n"), Whitespace("    ")] [Whitespace(" ")],
+                            argument: JsYieldArgument {
+                                star_token: missing (optional),
+                                expression: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@68..105 "<template>Yielded template</template>" [] [],
+                                },
+                            },
+                        },
+                        semicolon_token: SEMICOLON@105..106 ";" [] [],
+                    },
+                ],
+                r_curly_token: R_CURLY@106..108 "}" [Newline("\n")] [],
+            },
+        },
+        JsFunctionDeclaration {
+            async_token: ASYNC_KW@108..150 "async" [Newline("\n"), Newline("\n"), Comments("// Template with awai ..."), Newline("\n")] [Whitespace(" ")],
+            function_token: FUNCTION_KW@150..159 "function" [] [Whitespace(" ")],
+            star_token: missing (optional),
+            id: JsIdentifierBinding {
+                name_token: IDENT@159..166 "asyncFn" [] [],
+            },
+            type_parameters: missing (optional),
+            parameters: JsParameters {
+                l_paren_token: L_PAREN@166..167 "(" [] [],
+                items: JsParameterList [],
+                r_paren_token: R_PAREN@167..169 ")" [] [Whitespace(" ")],
+            },
+            return_type_annotation: missing (optional),
+            body: JsFunctionBody {
+                l_curly_token: L_CURLY@169..170 "{" [] [],
+                directives: JsDirectiveList [],
+                statements: JsStatementList [
+                    JsExpressionStatement {
+                        expression: JsAwaitExpression {
+                            await_token: AWAIT_KW@170..181 "await" [Newline("\n"), Whitespace("    ")] [Whitespace(" ")],
+                            argument: JsGlimmerTemplate {
+                                template_token_token: GLIMMER_TEMPLATE@181..218 "<template>Awaited template</template>" [] [],
+                            },
+                        },
+                        semicolon_token: SEMICOLON@218..219 ";" [] [],
+                    },
+                ],
+                r_curly_token: R_CURLY@219..221 "}" [Newline("\n")] [],
+            },
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@221..254 "const" [Newline("\n"), Newline("\n"), Comments("// Template after typeof"), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@254..261 "TypeOf" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@261..263 "=" [] [Whitespace(" ")],
+                            expression: JsUnaryExpression {
+                                operator_token: TYPEOF_KW@263..270 "typeof" [] [Whitespace(" ")],
+                                argument: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@270..300 "<template>Type test</template>" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@300..301 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@301..336 "const" [Newline("\n"), Newline("\n"), Comments("// Template in condit ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@336..348 "conditional" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@348..350 "=" [] [Whitespace(" ")],
+                            expression: JsConditionalExpression {
+                                test: JsBooleanLiteralExpression {
+                                    value_token: TRUE_KW@350..355 "true" [] [Whitespace(" ")],
+                                },
+                                question_mark_token: QUESTION@355..357 "?" [] [Whitespace(" ")],
+                                consequent: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@357..383 "<template>True</template>" [] [Whitespace(" ")],
+                                },
+                                colon_token: COLON@383..385 ":" [] [Whitespace(" ")],
+                                alternate: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@385..411 "<template>False</template>" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@411..412 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@412..442 "const" [Newline("\n"), Newline("\n"), Comments("// Template with void"), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@442..453 "voidResult" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@453..455 "=" [] [Whitespace(" ")],
+                            expression: JsUnaryExpression {
+                                operator_token: VOID_KW@455..460 "void" [] [Whitespace(" ")],
+                                argument: JsGlimmerTemplate {
+                                    template_token_token: GLIMMER_TEMPLATE@460..494 "<template>Void template</template>" [] [],
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@494..495 ";" [] [],
+        },
+        JsVariableStatement {
+            declaration: JsVariableDeclaration {
+                await_token: missing (optional),
+                kind: CONST_KW@495..558 "const" [Newline("\n"), Newline("\n"), Comments("// Template with dele ..."), Newline("\n")] [Whitespace(" ")],
+                declarators: JsVariableDeclaratorList [
+                    JsVariableDeclarator {
+                        id: JsIdentifierBinding {
+                            name_token: IDENT@558..562 "obj" [] [Whitespace(" ")],
+                        },
+                        variable_annotation: missing (optional),
+                        initializer: JsInitializerClause {
+                            eq_token: EQ@562..564 "=" [] [Whitespace(" ")],
+                            expression: JsObjectExpression {
+                                l_curly_token: L_CURLY@564..566 "{" [] [Whitespace(" ")],
+                                members: JsObjectMemberList [
+                                    JsPropertyObjectMember {
+                                        name: JsLiteralMemberName {
+                                            value: IDENT@566..570 "prop" [] [],
+                                        },
+                                        colon_token: COLON@570..572 ":" [] [Whitespace(" ")],
+                                        value: JsGlimmerTemplate {
+                                            template_token_token: GLIMMER_TEMPLATE@572..598 "<template>Prop</template>" [] [Whitespace(" ")],
+                                        },
+                                    },
+                                ],
+                                r_curly_token: R_CURLY@598..599 "}" [] [],
+                            },
+                        },
+                    },
+                ],
+            },
+            semicolon_token: SEMICOLON@599..600 ";" [] [],
+        },
+    ],
+    eof_token: EOF@600..601 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: JS_MODULE@0..601
+  0: (empty)
+  1: (empty)
+  2: JS_DIRECTIVE_LIST@0..0
+  3: JS_MODULE_ITEM_LIST@0..600
+    0: JS_FUNCTION_DECLARATION@0..108
+      0: (empty)
+      1: FUNCTION_KW@0..42 "function" [Comments("// Template with yiel ..."), Newline("\n")] []
+      2: STAR@42..44 "*" [] [Whitespace(" ")]
+      3: JS_IDENTIFIER_BINDING@44..53
+        0: IDENT@44..53 "generator" [] []
+      4: (empty)
+      5: JS_PARAMETERS@53..56
+        0: L_PAREN@53..54 "(" [] []
+        1: JS_PARAMETER_LIST@54..54
+        2: R_PAREN@54..56 ")" [] [Whitespace(" ")]
+      6: (empty)
+      7: JS_FUNCTION_BODY@56..108
+        0: L_CURLY@56..57 "{" [] []
+        1: JS_DIRECTIVE_LIST@57..57
+        2: JS_STATEMENT_LIST@57..106
+          0: JS_EXPRESSION_STATEMENT@57..106
+            0: JS_YIELD_EXPRESSION@57..105
+              0: YIELD_KW@57..68 "yield" [Newline("\n"), Whitespace("    ")] [Whitespace(" ")]
+              1: JS_YIELD_ARGUMENT@68..105
+                0: (empty)
+                1: JS_GLIMMER_TEMPLATE@68..105
+                  0: GLIMMER_TEMPLATE@68..105 "<template>Yielded template</template>" [] []
+            1: SEMICOLON@105..106 ";" [] []
+        3: R_CURLY@106..108 "}" [Newline("\n")] []
+    1: JS_FUNCTION_DECLARATION@108..221
+      0: ASYNC_KW@108..150 "async" [Newline("\n"), Newline("\n"), Comments("// Template with awai ..."), Newline("\n")] [Whitespace(" ")]
+      1: FUNCTION_KW@150..159 "function" [] [Whitespace(" ")]
+      2: (empty)
+      3: JS_IDENTIFIER_BINDING@159..166
+        0: IDENT@159..166 "asyncFn" [] []
+      4: (empty)
+      5: JS_PARAMETERS@166..169
+        0: L_PAREN@166..167 "(" [] []
+        1: JS_PARAMETER_LIST@167..167
+        2: R_PAREN@167..169 ")" [] [Whitespace(" ")]
+      6: (empty)
+      7: JS_FUNCTION_BODY@169..221
+        0: L_CURLY@169..170 "{" [] []
+        1: JS_DIRECTIVE_LIST@170..170
+        2: JS_STATEMENT_LIST@170..219
+          0: JS_EXPRESSION_STATEMENT@170..219
+            0: JS_AWAIT_EXPRESSION@170..218
+              0: AWAIT_KW@170..181 "await" [Newline("\n"), Whitespace("    ")] [Whitespace(" ")]
+              1: JS_GLIMMER_TEMPLATE@181..218
+                0: GLIMMER_TEMPLATE@181..218 "<template>Awaited template</template>" [] []
+            1: SEMICOLON@218..219 ";" [] []
+        3: R_CURLY@219..221 "}" [Newline("\n")] []
+    2: JS_VARIABLE_STATEMENT@221..301
+      0: JS_VARIABLE_DECLARATION@221..300
+        0: (empty)
+        1: CONST_KW@221..254 "const" [Newline("\n"), Newline("\n"), Comments("// Template after typeof"), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@254..300
+          0: JS_VARIABLE_DECLARATOR@254..300
+            0: JS_IDENTIFIER_BINDING@254..261
+              0: IDENT@254..261 "TypeOf" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@261..300
+              0: EQ@261..263 "=" [] [Whitespace(" ")]
+              1: JS_UNARY_EXPRESSION@263..300
+                0: TYPEOF_KW@263..270 "typeof" [] [Whitespace(" ")]
+                1: JS_GLIMMER_TEMPLATE@270..300
+                  0: GLIMMER_TEMPLATE@270..300 "<template>Type test</template>" [] []
+      1: SEMICOLON@300..301 ";" [] []
+    3: JS_VARIABLE_STATEMENT@301..412
+      0: JS_VARIABLE_DECLARATION@301..411
+        0: (empty)
+        1: CONST_KW@301..336 "const" [Newline("\n"), Newline("\n"), Comments("// Template in condit ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@336..411
+          0: JS_VARIABLE_DECLARATOR@336..411
+            0: JS_IDENTIFIER_BINDING@336..348
+              0: IDENT@336..348 "conditional" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@348..411
+              0: EQ@348..350 "=" [] [Whitespace(" ")]
+              1: JS_CONDITIONAL_EXPRESSION@350..411
+                0: JS_BOOLEAN_LITERAL_EXPRESSION@350..355
+                  0: TRUE_KW@350..355 "true" [] [Whitespace(" ")]
+                1: QUESTION@355..357 "?" [] [Whitespace(" ")]
+                2: JS_GLIMMER_TEMPLATE@357..383
+                  0: GLIMMER_TEMPLATE@357..383 "<template>True</template>" [] [Whitespace(" ")]
+                3: COLON@383..385 ":" [] [Whitespace(" ")]
+                4: JS_GLIMMER_TEMPLATE@385..411
+                  0: GLIMMER_TEMPLATE@385..411 "<template>False</template>" [] []
+      1: SEMICOLON@411..412 ";" [] []
+    4: JS_VARIABLE_STATEMENT@412..495
+      0: JS_VARIABLE_DECLARATION@412..494
+        0: (empty)
+        1: CONST_KW@412..442 "const" [Newline("\n"), Newline("\n"), Comments("// Template with void"), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@442..494
+          0: JS_VARIABLE_DECLARATOR@442..494
+            0: JS_IDENTIFIER_BINDING@442..453
+              0: IDENT@442..453 "voidResult" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@453..494
+              0: EQ@453..455 "=" [] [Whitespace(" ")]
+              1: JS_UNARY_EXPRESSION@455..494
+                0: VOID_KW@455..460 "void" [] [Whitespace(" ")]
+                1: JS_GLIMMER_TEMPLATE@460..494
+                  0: GLIMMER_TEMPLATE@460..494 "<template>Void template</template>" [] []
+      1: SEMICOLON@494..495 ";" [] []
+    5: JS_VARIABLE_STATEMENT@495..600
+      0: JS_VARIABLE_DECLARATION@495..599
+        0: (empty)
+        1: CONST_KW@495..558 "const" [Newline("\n"), Newline("\n"), Comments("// Template with dele ..."), Newline("\n")] [Whitespace(" ")]
+        2: JS_VARIABLE_DECLARATOR_LIST@558..599
+          0: JS_VARIABLE_DECLARATOR@558..599
+            0: JS_IDENTIFIER_BINDING@558..562
+              0: IDENT@558..562 "obj" [] [Whitespace(" ")]
+            1: (empty)
+            2: JS_INITIALIZER_CLAUSE@562..599
+              0: EQ@562..564 "=" [] [Whitespace(" ")]
+              1: JS_OBJECT_EXPRESSION@564..599
+                0: L_CURLY@564..566 "{" [] [Whitespace(" ")]
+                1: JS_OBJECT_MEMBER_LIST@566..598
+                  0: JS_PROPERTY_OBJECT_MEMBER@566..598
+                    0: JS_LITERAL_MEMBER_NAME@566..570
+                      0: IDENT@566..570 "prop" [] []
+                    1: COLON@570..572 ":" [] [Whitespace(" ")]
+                    2: JS_GLIMMER_TEMPLATE@572..598
+                      0: GLIMMER_TEMPLATE@572..598 "<template>Prop</template>" [] [Whitespace(" ")]
+                2: R_CURLY@598..599 "}" [] []
+      1: SEMICOLON@599..600 ";" [] []
+  4: EOF@600..601 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_js_parser/tests/spec_test.rs b/crates/biome_js_parser/tests/spec_test.rs
index 72fb9c064e8a..fc8b5fb1008a 100644
--- a/crates/biome_js_parser/tests/spec_test.rs
+++ b/crates/biome_js_parser/tests/spec_test.rs
@@ -6,7 +6,7 @@ use biome_diagnostics::DiagnosticExt;
 use biome_diagnostics::display::PrintDiagnostic;
 use biome_diagnostics::{print_diagnostic_to_string, termcolor};
 use biome_fs::BiomePath;
-use biome_js_parser::{JsParserOptions, parse};
+use biome_js_parser::{JsParserOptions, parse, parse_with_options};
 use biome_js_syntax::JsFileSource;
 use biome_rowan::SyntaxKind;
 use biome_service::settings::Settings;
@@ -82,7 +82,13 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
     let file_source = JsFileSource::try_from(test_case_path).unwrap_or_default();
 
     let extension = file_source.file_extension();
-    let parsed = parse(&content, file_source, options);
+
+    // Use parse_with_options if test-specific options were configured, otherwise use parse
+    let parsed = if options_path.exists() {
+        parse_with_options(&content, file_source, options)
+    } else {
+        parse(&content, file_source)
+    };
     validate_eof_token(parsed.syntax());
 
     let formatted_ast = format!("{:#?}", parsed.tree());
@@ -185,7 +191,7 @@ pub fn quick_test() {
 import.defer("foo", { with: { type: 'json' } })
     "#;
 
-    let root = parse(code, JsFileSource::ts(), JsParserOptions::default());
+    let root = parse_with_options(code, JsFileSource::ts(), JsParserOptions::default());
     let syntax = root.syntax();
     dbg!(&syntax, root.diagnostics(), root.has_errors());
     if has_bogus_nodes_or_empty_slots(&syntax) {
diff --git a/crates/biome_js_parser/tests/spec_tests.rs b/crates/biome_js_parser/tests/spec_tests.rs
index 449d2dc06c32..df42491a9de3 100644
--- a/crates/biome_js_parser/tests/spec_tests.rs
+++ b/crates/biome_js_parser/tests/spec_tests.rs
@@ -1,8 +1,8 @@
 mod spec_test;
 
 mod ok {
-    tests_macros::gen_tests! {"tests/js_test_suite/ok/**/*.{js,cjs,mjs,jsx,ts,tsx,d.ts}", crate::spec_test::run, "ok"}
+    tests_macros::gen_tests! {"tests/js_test_suite/ok/**/*.{js,cjs,mjs,jsx,ts,tsx,d.ts,gjs,gts}", crate::spec_test::run, "ok"}
 }
 mod err {
-    tests_macros::gen_tests! {"tests/js_test_suite/error/**/*.{js,cjs,mjs,jsx,ts,tsx,d.ts}", crate::spec_test::run, "error"}
+    tests_macros::gen_tests! {"tests/js_test_suite/error/**/*.{js,cjs,mjs,jsx,ts,tsx,d.ts,gjs,gts}", crate::spec_test::run, "error"}
 }
diff --git a/crates/biome_js_syntax/src/expr_ext.rs b/crates/biome_js_syntax/src/expr_ext.rs
index 61aa24ff32e1..60fefd944039 100644
--- a/crates/biome_js_syntax/src/expr_ext.rs
+++ b/crates/biome_js_syntax/src/expr_ext.rs
@@ -913,7 +913,8 @@ impl AnyJsExpression {
             | Self::JsFunctionExpression(_)
             | Self::JsIdentifierExpression(_)
             | Self::JsObjectExpression(_)
-            | Self::JsxTagExpression(_) => OperatorPrecedence::Primary,
+            | Self::JsxTagExpression(_)
+            | Self::JsGlimmerTemplate(_) => OperatorPrecedence::Primary,
 
             Self::JsTemplateExpression(template) => {
                 if template.tag().is_some() {
diff --git a/crates/biome_js_syntax/src/file_source.rs b/crates/biome_js_syntax/src/file_source.rs
index 7bb3ca96d5ae..b3d249d1617a 100644
--- a/crates/biome_js_syntax/src/file_source.rs
+++ b/crates/biome_js_syntax/src/file_source.rs
@@ -123,6 +123,8 @@ pub enum EmbeddingKind {
     Astro,
     Vue,
     Svelte,
+    /// Glimmer template files (.gjs/.gts) with embedded `<template>` blocks
+    Glimmer,
     #[default]
     None,
 }
@@ -137,6 +139,9 @@ impl EmbeddingKind {
     pub const fn is_svelte(&self) -> bool {
         matches!(self, Self::Svelte)
     }
+    pub const fn is_glimmer(&self) -> bool {
+        matches!(self, Self::Glimmer)
+    }
 }
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -214,6 +219,18 @@ impl JsFileSource {
         Self::js_module().with_embedding_kind(EmbeddingKind::Svelte)
     }
 
+    /// Glimmer JavaScript file (.gjs)
+    /// language: JS, variant: Standard, module_kind: Module, embedding: Glimmer
+    pub fn gjs() -> Self {
+        Self::js_module().with_embedding_kind(EmbeddingKind::Glimmer)
+    }
+
+    /// Glimmer TypeScript file (.gts)
+    /// language: TS, variant: Standard, module_kind: Module, embedding: Glimmer
+    pub fn gts() -> Self {
+        Self::ts().with_embedding_kind(EmbeddingKind::Glimmer)
+    }
+
     pub const fn with_module_kind(mut self, kind: ModuleKind) -> Self {
         self.module_kind = kind;
         self
@@ -343,6 +360,9 @@ impl JsFileSource {
             "vue" => Ok(Self::vue()),
             // TODO: Remove once we have full support of svelte files
             "svelte" => Ok(Self::svelte()),
+            // Glimmer template files
+            "gjs" => Ok(Self::gjs()),
+            "gts" => Ok(Self::gts()),
 
             _ => Err(FileSourceError::UnknownExtension),
         }
@@ -376,6 +396,8 @@ impl JsFileSource {
             "vue" | "vuejs" => Ok(Self::vue()),
             // TODO: Remove once we have full support of svelte files
             "svelte" => Ok(Self::svelte()),
+            "gjs" => Ok(Self::gjs()),
+            "gts" => Ok(Self::gts()),
             _ => Err(FileSourceError::UnknownLanguageId),
         }
     }
@@ -430,3 +452,26 @@ impl From<Language> for JsFileSource {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_gjs_language_id() {
+        let result = JsFileSource::try_from_language_id("gjs");
+        assert!(result.is_ok(), "gjs language ID should be recognized");
+        let file_source = result.unwrap();
+        // gjs() returns Self::js_module().with_embedding_kind(EmbeddingKind::Glimmer)
+        assert_eq!(file_source, JsFileSource::gjs());
+    }
+
+    #[test]
+    fn test_gts_language_id() {
+        let result = JsFileSource::try_from_language_id("gts");
+        assert!(result.is_ok(), "gts language ID should be recognized");
+        let file_source = result.unwrap();
+        // gts() returns Self::ts().with_embedding_kind(EmbeddingKind::Glimmer)
+        assert_eq!(file_source, JsFileSource::gts());
+    }
+}
diff --git a/crates/biome_js_syntax/src/generated/kind.rs b/crates/biome_js_syntax/src/generated/kind.rs
index 38bb538103d1..9305cc85b5a3 100644
--- a/crates/biome_js_syntax/src/generated/kind.rs
+++ b/crates/biome_js_syntax/src/generated/kind.rs
@@ -170,6 +170,7 @@ pub enum JsSyntaxKind {
     ERROR_TOKEN,
     IDENT,
     JSX_IDENT,
+    GLIMMER_TEMPLATE,
     NEWLINE,
     WHITESPACE,
     COMMENT,
@@ -323,6 +324,7 @@ pub enum JsSyntaxKind {
     JS_GETTER_CLASS_MEMBER,
     JS_SETTER_CLASS_MEMBER,
     JS_EMPTY_CLASS_MEMBER,
+    JS_GLIMMER_TEMPLATE,
     JS_PARENTHESIZED_ASSIGNMENT,
     JS_IDENTIFIER_ASSIGNMENT,
     JS_STATIC_MEMBER_ASSIGNMENT,
diff --git a/crates/biome_js_syntax/src/generated/macros.rs b/crates/biome_js_syntax/src/generated/macros.rs
index aa3bd8838ce1..9b35a4181973 100644
--- a/crates/biome_js_syntax/src/generated/macros.rs
+++ b/crates/biome_js_syntax/src/generated/macros.rs
@@ -295,6 +295,10 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::JsGetterObjectMember::new_unchecked(node) };
                     $body
                 }
+                $crate::JsSyntaxKind::JS_GLIMMER_TEMPLATE => {
+                    let $pattern = unsafe { $crate::JsGlimmerTemplate::new_unchecked(node) };
+                    $body
+                }
                 $crate::JsSyntaxKind::JS_IDENTIFIER_ASSIGNMENT => {
                     let $pattern = unsafe { $crate::JsIdentifierAssignment::new_unchecked(node) };
                     $body
diff --git a/crates/biome_js_syntax/src/generated/nodes.rs b/crates/biome_js_syntax/src/generated/nodes.rs
index d1e9ee72bec5..1e0746768da6 100644
--- a/crates/biome_js_syntax/src/generated/nodes.rs
+++ b/crates/biome_js_syntax/src/generated/nodes.rs
@@ -3283,6 +3283,41 @@ pub struct JsGetterObjectMemberFields {
     pub body: SyntaxResult<JsFunctionBody>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
+pub struct JsGlimmerTemplate {
+    pub(crate) syntax: SyntaxNode,
+}
+impl JsGlimmerTemplate {
+    #[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) -> JsGlimmerTemplateFields {
+        JsGlimmerTemplateFields {
+            template_token_token: self.template_token_token(),
+        }
+    }
+    pub fn template_token_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+}
+impl Serialize for JsGlimmerTemplate {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct JsGlimmerTemplateFields {
+    pub template_token_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct JsIdentifierAssignment {
     pub(crate) syntax: SyntaxNode,
 }
@@ -13723,6 +13758,7 @@ pub enum AnyJsClassMember {
     JsConstructorClassMember(JsConstructorClassMember),
     JsEmptyClassMember(JsEmptyClassMember),
     JsGetterClassMember(JsGetterClassMember),
+    JsGlimmerTemplate(JsGlimmerTemplate),
     JsMetavariable(JsMetavariable),
     JsMethodClassMember(JsMethodClassMember),
     JsPropertyClassMember(JsPropertyClassMember),
@@ -13761,6 +13797,12 @@ impl AnyJsClassMember {
             _ => None,
         }
     }
+    pub fn as_js_glimmer_template(&self) -> Option<&JsGlimmerTemplate> {
+        match &self {
+            Self::JsGlimmerTemplate(item) => Some(item),
+            _ => None,
+        }
+    }
     pub fn as_js_metavariable(&self) -> Option<&JsMetavariable> {
         match &self {
             Self::JsMetavariable(item) => Some(item),
@@ -14268,6 +14310,7 @@ pub enum AnyJsExpression {
     JsComputedMemberExpression(JsComputedMemberExpression),
     JsConditionalExpression(JsConditionalExpression),
     JsFunctionExpression(JsFunctionExpression),
+    JsGlimmerTemplate(JsGlimmerTemplate),
     JsIdentifierExpression(JsIdentifierExpression),
     JsImportCallExpression(JsImportCallExpression),
     JsImportMetaExpression(JsImportMetaExpression),
@@ -14368,6 +14411,12 @@ impl AnyJsExpression {
             _ => None,
         }
     }
+    pub fn as_js_glimmer_template(&self) -> Option<&JsGlimmerTemplate> {
+        match &self {
+            Self::JsGlimmerTemplate(item) => Some(item),
+            _ => None,
+        }
+    }
     pub fn as_js_identifier_expression(&self) -> Option<&JsIdentifierExpression> {
         match &self {
             Self::JsIdentifierExpression(item) => Some(item),
@@ -15189,6 +15238,7 @@ pub enum AnyJsStatement {
     JsForOfStatement(JsForOfStatement),
     JsForStatement(JsForStatement),
     JsFunctionDeclaration(JsFunctionDeclaration),
+    JsGlimmerTemplate(JsGlimmerTemplate),
     JsIfStatement(JsIfStatement),
     JsLabeledStatement(JsLabeledStatement),
     JsMetavariable(JsMetavariable),
@@ -15289,6 +15339,12 @@ impl AnyJsStatement {
             _ => None,
         }
     }
+    pub fn as_js_glimmer_template(&self) -> Option<&JsGlimmerTemplate> {
+        match &self {
+            Self::JsGlimmerTemplate(item) => Some(item),
+            _ => None,
+        }
+    }
     pub fn as_js_if_statement(&self) -> Option<&JsIfStatement> {
         match &self {
             Self::JsIfStatement(item) => Some(item),
@@ -20181,6 +20237,56 @@ impl From<JsGetterObjectMember> for SyntaxElement {
         n.syntax.into()
     }
 }
+impl AstNode for JsGlimmerTemplate {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(JS_GLIMMER_TEMPLATE as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == JS_GLIMMER_TEMPLATE
+    }
+    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 JsGlimmerTemplate {
+    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("JsGlimmerTemplate")
+                .field(
+                    "template_token_token",
+                    &support::DebugSyntaxResult(self.template_token_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("JsGlimmerTemplate").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<JsGlimmerTemplate> for SyntaxNode {
+    fn from(n: JsGlimmerTemplate) -> Self {
+        n.syntax
+    }
+}
+impl From<JsGlimmerTemplate> for SyntaxElement {
+    fn from(n: JsGlimmerTemplate) -> Self {
+        n.syntax.into()
+    }
+}
 impl AstNode for JsIdentifierAssignment {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
@@ -33222,6 +33328,11 @@ impl From<JsGetterClassMember> for AnyJsClassMember {
         Self::JsGetterClassMember(node)
     }
 }
+impl From<JsGlimmerTemplate> for AnyJsClassMember {
+    fn from(node: JsGlimmerTemplate) -> Self {
+        Self::JsGlimmerTemplate(node)
+    }
+}
 impl From<JsMetavariable> for AnyJsClassMember {
     fn from(node: JsMetavariable) -> Self {
         Self::JsMetavariable(node)
@@ -33288,6 +33399,7 @@ impl AstNode for AnyJsClassMember {
         .union(JsConstructorClassMember::KIND_SET)
         .union(JsEmptyClassMember::KIND_SET)
         .union(JsGetterClassMember::KIND_SET)
+        .union(JsGlimmerTemplate::KIND_SET)
         .union(JsMetavariable::KIND_SET)
         .union(JsMethodClassMember::KIND_SET)
         .union(JsPropertyClassMember::KIND_SET)
@@ -33307,6 +33419,7 @@ impl AstNode for AnyJsClassMember {
                 | JS_CONSTRUCTOR_CLASS_MEMBER
                 | JS_EMPTY_CLASS_MEMBER
                 | JS_GETTER_CLASS_MEMBER
+                | JS_GLIMMER_TEMPLATE
                 | JS_METAVARIABLE
                 | JS_METHOD_CLASS_MEMBER
                 | JS_PROPERTY_CLASS_MEMBER
@@ -33329,6 +33442,7 @@ impl AstNode for AnyJsClassMember {
             }
             JS_EMPTY_CLASS_MEMBER => Self::JsEmptyClassMember(JsEmptyClassMember { syntax }),
             JS_GETTER_CLASS_MEMBER => Self::JsGetterClassMember(JsGetterClassMember { syntax }),
+            JS_GLIMMER_TEMPLATE => Self::JsGlimmerTemplate(JsGlimmerTemplate { syntax }),
             JS_METAVARIABLE => Self::JsMetavariable(JsMetavariable { syntax }),
             JS_METHOD_CLASS_MEMBER => Self::JsMethodClassMember(JsMethodClassMember { syntax }),
             JS_PROPERTY_CLASS_MEMBER => {
@@ -33375,6 +33489,7 @@ impl AstNode for AnyJsClassMember {
             Self::JsConstructorClassMember(it) => &it.syntax,
             Self::JsEmptyClassMember(it) => &it.syntax,
             Self::JsGetterClassMember(it) => &it.syntax,
+            Self::JsGlimmerTemplate(it) => &it.syntax,
             Self::JsMetavariable(it) => &it.syntax,
             Self::JsMethodClassMember(it) => &it.syntax,
             Self::JsPropertyClassMember(it) => &it.syntax,
@@ -33395,6 +33510,7 @@ impl AstNode for AnyJsClassMember {
             Self::JsConstructorClassMember(it) => it.syntax,
             Self::JsEmptyClassMember(it) => it.syntax,
             Self::JsGetterClassMember(it) => it.syntax,
+            Self::JsGlimmerTemplate(it) => it.syntax,
             Self::JsMetavariable(it) => it.syntax,
             Self::JsMethodClassMember(it) => it.syntax,
             Self::JsPropertyClassMember(it) => it.syntax,
@@ -33417,6 +33533,7 @@ impl std::fmt::Debug for AnyJsClassMember {
             Self::JsConstructorClassMember(it) => std::fmt::Debug::fmt(it, f),
             Self::JsEmptyClassMember(it) => std::fmt::Debug::fmt(it, f),
             Self::JsGetterClassMember(it) => std::fmt::Debug::fmt(it, f),
+            Self::JsGlimmerTemplate(it) => std::fmt::Debug::fmt(it, f),
             Self::JsMetavariable(it) => std::fmt::Debug::fmt(it, f),
             Self::JsMethodClassMember(it) => std::fmt::Debug::fmt(it, f),
             Self::JsPropertyClassMember(it) => std::fmt::Debug::fmt(it, f),
@@ -33439,6 +33556,7 @@ impl From<AnyJsClassMember> for SyntaxNode {
             AnyJsClassMember::JsConstructorClassMember(it) => it.into(),
             AnyJsClassMember::JsEmptyClassMember(it) => it.into(),
             AnyJsClassMember::JsGetterClassMember(it) => it.into(),
+            AnyJsClassMember::JsGlimmerTemplate(it) => it.into(),
             AnyJsClassMember::JsMetavariable(it) => it.into(),
             AnyJsClassMember::JsMethodClassMember(it) => it.into(),
             AnyJsClassMember::JsPropertyClassMember(it) => it.into(),
@@ -34552,6 +34670,11 @@ impl From<JsFunctionExpression> for AnyJsExpression {
         Self::JsFunctionExpression(node)
     }
 }
+impl From<JsGlimmerTemplate> for AnyJsExpression {
+    fn from(node: JsGlimmerTemplate) -> Self {
+        Self::JsGlimmerTemplate(node)
+    }
+}
 impl From<JsIdentifierExpression> for AnyJsExpression {
     fn from(node: JsIdentifierExpression) -> Self {
         Self::JsIdentifierExpression(node)
@@ -34696,6 +34819,7 @@ impl AstNode for AnyJsExpression {
         .union(JsComputedMemberExpression::KIND_SET)
         .union(JsConditionalExpression::KIND_SET)
         .union(JsFunctionExpression::KIND_SET)
+        .union(JsGlimmerTemplate::KIND_SET)
         .union(JsIdentifierExpression::KIND_SET)
         .union(JsImportCallExpression::KIND_SET)
         .union(JsImportMetaExpression::KIND_SET)
@@ -34735,6 +34859,7 @@ impl AstNode for AnyJsExpression {
             | JS_COMPUTED_MEMBER_EXPRESSION
             | JS_CONDITIONAL_EXPRESSION
             | JS_FUNCTION_EXPRESSION
+            | JS_GLIMMER_TEMPLATE
             | JS_IDENTIFIER_EXPRESSION
             | JS_IMPORT_CALL_EXPRESSION
             | JS_IMPORT_META_EXPRESSION
@@ -34786,6 +34911,7 @@ impl AstNode for AnyJsExpression {
                 Self::JsConditionalExpression(JsConditionalExpression { syntax })
             }
             JS_FUNCTION_EXPRESSION => Self::JsFunctionExpression(JsFunctionExpression { syntax }),
+            JS_GLIMMER_TEMPLATE => Self::JsGlimmerTemplate(JsGlimmerTemplate { syntax }),
             JS_IDENTIFIER_EXPRESSION => {
                 Self::JsIdentifierExpression(JsIdentifierExpression { syntax })
             }
@@ -34860,6 +34986,7 @@ impl AstNode for AnyJsExpression {
             Self::JsComputedMemberExpression(it) => &it.syntax,
             Self::JsConditionalExpression(it) => &it.syntax,
             Self::JsFunctionExpression(it) => &it.syntax,
+            Self::JsGlimmerTemplate(it) => &it.syntax,
             Self::JsIdentifierExpression(it) => &it.syntax,
             Self::JsImportCallExpression(it) => &it.syntax,
             Self::JsImportMetaExpression(it) => &it.syntax,
@@ -34902,6 +35029,7 @@ impl AstNode for AnyJsExpression {
             Self::JsComputedMemberExpression(it) => it.syntax,
             Self::JsConditionalExpression(it) => it.syntax,
             Self::JsFunctionExpression(it) => it.syntax,
+            Self::JsGlimmerTemplate(it) => it.syntax,
             Self::JsIdentifierExpression(it) => it.syntax,
             Self::JsImportCallExpression(it) => it.syntax,
             Self::JsImportMetaExpression(it) => it.syntax,
@@ -34947,6 +35075,7 @@ impl std::fmt::Debug for AnyJsExpression {
             Self::JsComputedMemberExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::JsConditionalExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::JsFunctionExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::JsGlimmerTemplate(it) => std::fmt::Debug::fmt(it, f),
             Self::JsIdentifierExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::JsImportCallExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::JsImportMetaExpression(it) => std::fmt::Debug::fmt(it, f),
@@ -34991,6 +35120,7 @@ impl From<AnyJsExpression> for SyntaxNode {
             AnyJsExpression::JsComputedMemberExpression(it) => it.into(),
             AnyJsExpression::JsConditionalExpression(it) => it.into(),
             AnyJsExpression::JsFunctionExpression(it) => it.into(),
+            AnyJsExpression::JsGlimmerTemplate(it) => it.into(),
             AnyJsExpression::JsIdentifierExpression(it) => it.into(),
             AnyJsExpression::JsImportCallExpression(it) => it.into(),
             AnyJsExpression::JsImportMetaExpression(it) => it.into(),
@@ -36885,6 +37015,11 @@ impl From<JsFunctionDeclaration> for AnyJsStatement {
         Self::JsFunctionDeclaration(node)
     }
 }
+impl From<JsGlimmerTemplate> for AnyJsStatement {
+    fn from(node: JsGlimmerTemplate) -> Self {
+        Self::JsGlimmerTemplate(node)
+    }
+}
 impl From<JsIfStatement> for AnyJsStatement {
     fn from(node: JsIfStatement) -> Self {
         Self::JsIfStatement(node)
@@ -37000,6 +37135,7 @@ impl AstNode for AnyJsStatement {
         .union(JsForOfStatement::KIND_SET)
         .union(JsForStatement::KIND_SET)
         .union(JsFunctionDeclaration::KIND_SET)
+        .union(JsGlimmerTemplate::KIND_SET)
         .union(JsIfStatement::KIND_SET)
         .union(JsLabeledStatement::KIND_SET)
         .union(JsMetavariable::KIND_SET)
@@ -37036,6 +37172,7 @@ impl AstNode for AnyJsStatement {
                 | JS_FOR_OF_STATEMENT
                 | JS_FOR_STATEMENT
                 | JS_FUNCTION_DECLARATION
+                | JS_GLIMMER_TEMPLATE
                 | JS_IF_STATEMENT
                 | JS_LABELED_STATEMENT
                 | JS_METAVARIABLE
@@ -37077,6 +37214,7 @@ impl AstNode for AnyJsStatement {
             JS_FUNCTION_DECLARATION => {
                 Self::JsFunctionDeclaration(JsFunctionDeclaration { syntax })
             }
+            JS_GLIMMER_TEMPLATE => Self::JsGlimmerTemplate(JsGlimmerTemplate { syntax }),
             JS_IF_STATEMENT => Self::JsIfStatement(JsIfStatement { syntax }),
             JS_LABELED_STATEMENT => Self::JsLabeledStatement(JsLabeledStatement { syntax }),
             JS_METAVARIABLE => Self::JsMetavariable(JsMetavariable { syntax }),
@@ -37128,6 +37266,7 @@ impl AstNode for AnyJsStatement {
             Self::JsForOfStatement(it) => &it.syntax,
             Self::JsForStatement(it) => &it.syntax,
             Self::JsFunctionDeclaration(it) => &it.syntax,
+            Self::JsGlimmerTemplate(it) => &it.syntax,
             Self::JsIfStatement(it) => &it.syntax,
             Self::JsLabeledStatement(it) => &it.syntax,
             Self::JsMetavariable(it) => &it.syntax,
@@ -37165,6 +37304,7 @@ impl AstNode for AnyJsStatement {
             Self::JsForOfStatement(it) => it.syntax,
             Self::JsForStatement(it) => it.syntax,
             Self::JsFunctionDeclaration(it) => it.syntax,
+            Self::JsGlimmerTemplate(it) => it.syntax,
             Self::JsIfStatement(it) => it.syntax,
             Self::JsLabeledStatement(it) => it.syntax,
             Self::JsMetavariable(it) => it.syntax,
@@ -37204,6 +37344,7 @@ impl std::fmt::Debug for AnyJsStatement {
             Self::JsForOfStatement(it) => std::fmt::Debug::fmt(it, f),
             Self::JsForStatement(it) => std::fmt::Debug::fmt(it, f),
             Self::JsFunctionDeclaration(it) => std::fmt::Debug::fmt(it, f),
+            Self::JsGlimmerTemplate(it) => std::fmt::Debug::fmt(it, f),
             Self::JsIfStatement(it) => std::fmt::Debug::fmt(it, f),
             Self::JsLabeledStatement(it) => std::fmt::Debug::fmt(it, f),
             Self::JsMetavariable(it) => std::fmt::Debug::fmt(it, f),
@@ -37243,6 +37384,7 @@ impl From<AnyJsStatement> for SyntaxNode {
             AnyJsStatement::JsForOfStatement(it) => it.into(),
             AnyJsStatement::JsForStatement(it) => it.into(),
             AnyJsStatement::JsFunctionDeclaration(it) => it.into(),
+            AnyJsStatement::JsGlimmerTemplate(it) => it.into(),
             AnyJsStatement::JsIfStatement(it) => it.into(),
             AnyJsStatement::JsLabeledStatement(it) => it.into(),
             AnyJsStatement::JsMetavariable(it) => it.into(),
@@ -40680,6 +40822,11 @@ impl std::fmt::Display for JsGetterObjectMember {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for JsGlimmerTemplate {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for JsIdentifierAssignment {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/biome_js_syntax/src/generated/nodes_mut.rs b/crates/biome_js_syntax/src/generated/nodes_mut.rs
index 6ed1caac3877..d4ed63aacd3e 100644
--- a/crates/biome_js_syntax/src/generated/nodes_mut.rs
+++ b/crates/biome_js_syntax/src/generated/nodes_mut.rs
@@ -1676,6 +1676,14 @@ impl JsGetterObjectMember {
         )
     }
 }
+impl JsGlimmerTemplate {
+    pub fn with_template_token_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+}
 impl JsIdentifierAssignment {
     pub fn with_name_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
diff --git a/crates/biome_js_syntax/src/parentheses/expression.rs b/crates/biome_js_syntax/src/parentheses/expression.rs
index b4cb748d9011..f9177640b81a 100644
--- a/crates/biome_js_syntax/src/parentheses/expression.rs
+++ b/crates/biome_js_syntax/src/parentheses/expression.rs
@@ -63,6 +63,7 @@ impl NeedsParentheses for AnyJsExpression {
             Self::JsBogusExpression(_) => false,
             Self::JsYieldExpression(expr) => expr.needs_parentheses(),
             Self::JsxTagExpression(expr) => expr.needs_parentheses(),
+            Self::JsGlimmerTemplate(_) => false,
             Self::JsNewTargetExpression(expr) => expr.needs_parentheses(),
             Self::TsAsExpression(expr) => expr.needs_parentheses(),
             Self::TsSatisfiesExpression(expr) => expr.needs_parentheses(),
diff --git a/crates/biome_js_syntax/src/union_ext.rs b/crates/biome_js_syntax/src/union_ext.rs
index 5cf1c747ffbd..41eccc526637 100644
--- a/crates/biome_js_syntax/src/union_ext.rs
+++ b/crates/biome_js_syntax/src/union_ext.rs
@@ -97,6 +97,7 @@ impl AnyJsClassMember {
                 .name()
                 .map(|name| Some(AnyJsClassMemberName::from(name))),
             Self::JsEmptyClassMember(_) => Ok(None),
+            Self::JsGlimmerTemplate(_) => Ok(None),
             Self::JsGetterClassMember(getter) => getter.name().map(Some),
             Self::JsMethodClassMember(method) => method.name().map(Some),
             Self::JsPropertyClassMember(property) => property.name().map(Some),
diff --git a/crates/biome_service/src/file_handlers/astro.rs b/crates/biome_service/src/file_handlers/astro.rs
index 7e9e9b6d6e83..60856c86fa76 100644
--- a/crates/biome_service/src/file_handlers/astro.rs
+++ b/crates/biome_service/src/file_handlers/astro.rs
@@ -8,7 +8,7 @@ use crate::settings::Settings;
 use crate::workspace::{DocumentFileSource, FixFileResult, PullActionsResult};
 use biome_formatter::Printed;
 use biome_fs::BiomePath;
-use biome_js_parser::{JsParserOptions, parse_js_with_cache};
+use biome_js_parser::parse_js_with_cache;
 use biome_js_syntax::{JsFileSource, TextRange, TextSize};
 use biome_parser::AnyParse;
 use biome_rowan::NodeCache;
@@ -119,7 +119,6 @@ fn parse(
         file_source
             .to_js_file_source()
             .unwrap_or(JsFileSource::ts()),
-        JsParserOptions::default(),
         cache,
     );
 
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 577cf8e03442..5335657099a0 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -537,16 +537,14 @@ pub fn search_enabled(_path: &Utf8Path, _settings: &Settings) -> bool {
 }
 
 fn parse(
-    biome_path: &BiomePath,
+    _biome_path: &BiomePath,
     file_source: DocumentFileSource,
     text: &str,
-    settings: &Settings,
+    _settings: &Settings,
     cache: &mut NodeCache,
 ) -> ParseResult {
-    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);
+    let parse = biome_js_parser::parse_js_with_cache(text, file_source, cache);
     ParseResult {
         any_parse: parse.into(),
         language: None,
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index 686dc4143891..1d429ef3dd40 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -34,7 +34,7 @@ use biome_grit_patterns::{GritQuery, GritQueryEffect, GritTargetFile};
 use biome_grit_syntax::file_source::GritFileSource;
 use biome_html_syntax::{HtmlFileSource, HtmlLanguage};
 use biome_js_analyze::METADATA as js_metadata;
-use biome_js_parser::{JsParserOptions, parse};
+use biome_js_parser::parse;
 use biome_js_syntax::{
     EmbeddingKind, JsFileSource, JsLanguage, Language, LanguageVariant, TextRange, TextSize,
 };
@@ -817,7 +817,7 @@ impl Features {
                 EmbeddingKind::Astro => self.astro.capabilities(),
                 EmbeddingKind::Vue => self.vue.capabilities(),
                 EmbeddingKind::Svelte => self.svelte.capabilities(),
-                EmbeddingKind::None => self.js.capabilities(),
+                EmbeddingKind::Glimmer | EmbeddingKind::None => self.js.capabilities(),
             },
             DocumentFileSource::Json(_) => self.json.capabilities(),
             DocumentFileSource::Css(_) => self.css.capabilities(),
@@ -867,7 +867,6 @@ pub(crate) fn parse_lang_from_script_opening_tag(
     parse(
         script_opening_tag,
         JsFileSource::jsx(),
-        JsParserOptions::default(),
     )
     .try_tree()
     .and_then(|tree| {
diff --git a/crates/biome_service/src/file_handlers/svelte.rs b/crates/biome_service/src/file_handlers/svelte.rs
index fbe3ead301b2..b6e2007a10f7 100644
--- a/crates/biome_service/src/file_handlers/svelte.rs
+++ b/crates/biome_service/src/file_handlers/svelte.rs
@@ -11,7 +11,7 @@ use biome_formatter::Printed;
 use biome_fs::BiomePath;
 use biome_html_syntax::HtmlLanguage;
 use biome_js_formatter::format_node;
-use biome_js_parser::{JsParserOptions, parse_js_with_cache};
+use biome_js_parser::parse_js_with_cache;
 use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, TextRange, TextSize};
 use biome_parser::AnyParse;
 use biome_rowan::NodeCache;
@@ -132,7 +132,7 @@ fn parse(
 
     debug!("Parsing file with language {:?}", file_source);
 
-    let parse = parse_js_with_cache(script, file_source, JsParserOptions::default(), cache);
+    let parse = parse_js_with_cache(script, file_source, cache);
 
     ParseResult {
         any_parse: parse.into(),
diff --git a/crates/biome_service/src/file_handlers/vue.rs b/crates/biome_service/src/file_handlers/vue.rs
index aa0ff53a5eb6..b2856c8695b5 100644
--- a/crates/biome_service/src/file_handlers/vue.rs
+++ b/crates/biome_service/src/file_handlers/vue.rs
@@ -11,7 +11,7 @@ use biome_formatter::Printed;
 use biome_fs::BiomePath;
 use biome_html_syntax::HtmlLanguage;
 use biome_js_formatter::format_node;
-use biome_js_parser::{JsParserOptions, parse_js_with_cache};
+use biome_js_parser::parse_js_with_cache;
 use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, TextRange, TextSize};
 use biome_parser::AnyParse;
 use biome_rowan::NodeCache;
@@ -132,7 +132,7 @@ fn parse(
 
     debug!("Parsing file with language {:?}", file_source);
 
-    let parse = parse_js_with_cache(script, file_source, JsParserOptions::default(), cache);
+    let parse = parse_js_with_cache(script, file_source, cache);
 
     ParseResult {
         any_parse: parse.into(),
diff --git a/crates/biome_test_utils/src/lib.rs b/crates/biome_test_utils/src/lib.rs
index bfcd0294f03a..fb0cc2a08326 100644
--- a/crates/biome_test_utils/src/lib.rs
+++ b/crates/biome_test_utils/src/lib.rs
@@ -12,7 +12,7 @@ use biome_console::markup;
 use biome_diagnostics::termcolor::Buffer;
 use biome_diagnostics::{DiagnosticExt, Error, PrintDiagnostic};
 use biome_fs::{BiomePath, FileSystem, OsFileSystem};
-use biome_js_parser::{AnyJsRoot, JsFileSource, JsParserOptions};
+use biome_js_parser::{AnyJsRoot, JsFileSource};
 use biome_js_type_info::{TypeData, TypeResolver};
 use biome_json_parser::{JsonParserOptions, ParseDiagnostic};
 use biome_module_graph::ModuleGraph;
@@ -176,7 +176,7 @@ pub fn get_added_paths<'a>(
             let root = fs.read_file_from_path(path).ok().and_then(|content| {
                 let file_source = JsFileSource::try_from(path.as_path()).unwrap_or_default();
                 let parsed =
-                    biome_js_parser::parse(&content, file_source, JsParserOptions::default());
+                    biome_js_parser::parse(&content, file_source);
                 let diagnostics = parsed.diagnostics();
                 assert!(
                     diagnostics.is_empty(),
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index 53b84cbd3bdd..7f1eff14527b 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -9598,7 +9598,7 @@ export interface HtmlFileSource {
 export interface GritFileSource {
 	variant: GritVariant;
 }
-export type EmbeddingKind = "Astro" | "Vue" | "Svelte" | "None";
+export type EmbeddingKind = "Astro" | "Vue" | "Svelte" | "None" | "Glimmer";
 export type Language =
 	| "javaScript"
 	| { typeScript: { definition_file: boolean } };
diff --git a/xtask/codegen/html.ungram b/xtask/codegen/html.ungram
index 594025cb8d6c..e65bd5200a6e 100644
--- a/xtask/codegen/html.ungram
+++ b/xtask/codegen/html.ungram
@@ -73,12 +73,15 @@ AnyHtmlElement =
 	| HtmlElement
 	| AnyHtmlContent
 	| HtmlCdataSection
+	| GlimmerMustacheComment
+	| GlimmerTripleStashExpression
 	| HtmlBogusElement
 
 AnyHtmlContent =
 	HtmlContent
 	| HtmlEmbeddedContent
 	| AnyHtmlTextExpression
+	| AnyGlimmerExpression
 
 AnyHtmlTextExpression =
 	HtmlDoubleTextExpression
@@ -162,6 +165,8 @@ AnyHtmlAttribute =
 	HtmlAttribute
 	| HtmlDoubleTextExpression
 	| HtmlSingleTextExpression
+	| GlimmerSplattribute
+	| GlimmerElementModifier
 	| HtmlBogusAttribute
 
 // <a href="">
@@ -208,3 +213,147 @@ HtmlTagName = value: 'html_literal'
 HtmlAttributeName = value: 'html_literal'
 HtmlContent = value: 'html_literal'
 HtmlEmbeddedContent = value: 'html_literal'
+
+// ==================================
+// Glimmer
+// ==================================
+
+// Union of all Glimmer expressions
+AnyGlimmerExpression =
+	GlimmerMustacheExpression
+	| GlimmerMustacheComment
+	| GlimmerTripleStashExpression
+	| GlimmerBlockHelper
+	| GlimmerNamedBlock
+	| GlimmerBogusExpression
+
+// Bogus node for error recovery
+GlimmerBogusExpression = SyntaxElement*
+
+// Basic mustache: {{path args}}
+GlimmerMustacheExpression =
+	l_curly2_token: '{{'
+	path: GlimmerPath
+	arguments: GlimmerArgumentList
+	r_curly2_token: '}}'
+
+// Mustache comment: {{! comment }} or {{!-- comment --}}
+// Note: MUSTACHE_COMMENT is consumed entirely by the lexer
+GlimmerMustacheComment =
+	comment_token: 'mustache_comment'
+
+// Triple-stash (unescaped): {{{path args}}}
+// Like mustache expressions but outputs unescaped HTML
+GlimmerTripleStashExpression =
+	l_curly3_token: 'l_triple_curly'
+	path: GlimmerPath
+	arguments: GlimmerArgumentList
+	r_curly3_token: 'r_triple_curly'
+
+// Block helper: {{#if}}...{{/if}}
+GlimmerBlockHelper =
+	opening: GlimmerBlockHelperOpening
+	children: HtmlElementList
+	closing: GlimmerBlockHelperClosing
+
+GlimmerBlockHelperOpening =
+	l_curly2_token: '{{'
+	hash_token: '#'
+	helper: GlimmerPath
+	arguments: GlimmerArgumentList
+	block_params: GlimmerBlockParams?
+	r_curly2_token: '}}'
+
+GlimmerBlockHelperClosing =
+	l_curly2_token: '{{'
+	slash_token: '/'
+	helper: GlimmerPath
+	r_curly2_token: '}}'
+
+// Block params: as |item index|
+GlimmerBlockParams =
+	as_token: 'ident'
+	l_pipe_token: '|'
+	params: GlimmerBlockParamList
+	r_pipe_token: '|'
+
+GlimmerBlockParamList = GlimmerBlockParam*
+
+GlimmerBlockParam =
+	name_token: 'ident'
+
+// Path: this.foo, @arg, helper
+GlimmerPath =
+	at_token: '@'?
+	segments: GlimmerPathSegmentList
+
+GlimmerPathSegmentList = (GlimmerPathSegment ('.' GlimmerPathSegment)*)
+
+GlimmerPathSegment =
+	value_token: 'ident'
+
+// Arguments
+GlimmerArgumentList = AnyGlimmerArgument*
+
+AnyGlimmerArgument =
+	GlimmerPositionalArgument
+	| GlimmerNamedArgument
+
+GlimmerPositionalArgument =
+	value: AnyGlimmerArgumentValue
+
+GlimmerNamedArgument =
+	name_token: 'ident'
+	eq_token: '='
+	value: AnyGlimmerArgumentValue
+
+AnyGlimmerArgumentValue =
+	GlimmerPath
+	| GlimmerStringLiteral
+	| GlimmerLiteral
+	| GlimmerSubexpression
+
+// Subexpression: (helper arg1 arg2)
+GlimmerSubexpression =
+	l_paren_token: '('
+	path: GlimmerPath
+	arguments: GlimmerArgumentList
+	r_paren_token: ')'
+
+GlimmerStringLiteral =
+	value_token: 'html_string_literal'
+
+GlimmerLiteral =
+	value_token: 'html_literal'
+
+// Splattribute: ...attributes
+GlimmerSplattribute =
+	dotdotdot_token: '...'
+	attributes_token: 'ident'
+
+// Element modifier: {{modifier args}} in attribute position
+GlimmerElementModifier =
+	l_curly2_token: '{{'
+	path: GlimmerPath
+	arguments: GlimmerArgumentList
+	r_curly2_token: '}}'
+
+// Named block: <:blockName>content</:blockName>
+GlimmerNamedBlock =
+	opening: GlimmerNamedBlockOpening
+	children: HtmlElementList
+	closing: GlimmerNamedBlockClosing
+
+GlimmerNamedBlockOpening =
+	l_angle_token: '<'
+	colon_token: ':'
+	name_token: 'ident'
+	attributes: HtmlAttributeList
+	r_angle_token: '>'
+
+GlimmerNamedBlockClosing =
+	l_angle_token: '<'
+	slash_token: '/'
+	colon_token: ':'
+	name_token: 'ident'
+	r_angle_token: '>'
diff --git a/xtask/codegen/js.ungram b/xtask/codegen/js.ungram
index 1640c81def0c..2818a7876f8a 100644
--- a/xtask/codegen/js.ungram
+++ b/xtask/codegen/js.ungram
@@ -120,6 +120,7 @@ AnyJsStatement =
 	| TsExternalModuleDeclaration
 	| TsGlobalDeclaration
 	| TsImportEqualsDeclaration
+	| JsGlimmerTemplate
 	| JsMetavariable
 
 JsBlockStatement =
@@ -332,6 +333,8 @@ AnyJsExpression =
 	| TsInstantiationExpression
 	// JSX
 	| JsxTagExpression
+	// Glimmer
+	| JsGlimmerTemplate
 	// Grit
 	| JsMetavariable
 
@@ -660,6 +663,7 @@ AnyJsClassMember =
 	| TsSetterSignatureClassMember
 	| TsIndexSignatureClassMember
 	| JsEmptyClassMember
+	| JsGlimmerTemplate
 	| JsBogusMember
 	| JsMetavariable
 
@@ -883,6 +887,15 @@ TsIndexSignatureModifierList = AnyTsIndexSignatureModifier*
 
 JsEmptyClassMember = ';'
 
+///////////////
+// GLIMMER TEMPLATES
+///////////////
+
+// <template>...</template>
+// Represents a Glimmer template block in .gjs/.gts files
+JsGlimmerTemplate =
+	template_token: 'GLIMMER_TEMPLATE'
+
 ///////////////
 // ASSIGNMENT TARGETS
 ///////////////
diff --git a/xtask/codegen/src/html_kinds_src.rs b/xtask/codegen/src/html_kinds_src.rs
index db99472b5359..81d90d4f06ae 100644
--- a/xtask/codegen/src/html_kinds_src.rs
+++ b/xtask/codegen/src/html_kinds_src.rs
@@ -20,6 +20,15 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         ("{/", "SV_CURLY_SLASH"),
         ("{:", "SV_CURLY_COLON"),
         (",", "COMMA"),
+        // Glimmer tokens
+        ("#", "HASH"),
+        (".", "DOT"),
+        ("|", "PIPE"),
+        ("@", "AT"),
+        ("...", "DOTDOTDOT"),
+        ("(", "L_PAREN"),
+        (")", "R_PAREN"),
+        (":", "COLON"),
     ],
     keywords: &["null", "true", "false", "doctype", "html", "debug"],
     literals: &["HTML_STRING_LITERAL", "HTML_LITERAL"],
@@ -30,6 +39,9 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "IDENT",
         "HTML_IDENT",
         "SVELTE_IDENT",
+        "MUSTACHE_COMMENT",
+        "L_TRIPLE_CURLY",
+        "R_TRIPLE_CURLY",
     ],
     nodes: &[
         "HTML_ROOT",
@@ -60,6 +72,30 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "SVELTE_DEBUG_BLOCK",
         "SVELTE_BINDING_LIST",
         "SVELTE_NAME",
+        // Glimmer nodes
+        "GLIMMER_MUSTACHE_EXPRESSION",
+        "GLIMMER_MUSTACHE_COMMENT",
+        "GLIMMER_TRIPLE_STASH_EXPRESSION",
+        "GLIMMER_BLOCK_HELPER",
+        "GLIMMER_BLOCK_HELPER_OPENING",
+        "GLIMMER_BLOCK_HELPER_CLOSING",
+        "GLIMMER_BLOCK_PARAMS",
+        "GLIMMER_BLOCK_PARAM_LIST",
+        "GLIMMER_BLOCK_PARAM",
+        "GLIMMER_PATH",
+        "GLIMMER_PATH_SEGMENT_LIST",
+        "GLIMMER_PATH_SEGMENT",
+        "GLIMMER_ARGUMENT_LIST",
+        "GLIMMER_POSITIONAL_ARGUMENT",
+        "GLIMMER_NAMED_ARGUMENT",
+        "GLIMMER_SUBEXPRESSION",
+        "GLIMMER_STRING_LITERAL",
+        "GLIMMER_LITERAL",
+        "GLIMMER_SPLATTRIBUTE",
+        "GLIMMER_ELEMENT_MODIFIER",
+        "GLIMMER_NAMED_BLOCK",
+        "GLIMMER_NAMED_BLOCK_OPENING",
+        "GLIMMER_NAMED_BLOCK_CLOSING",
         // Bogus nodes
         "HTML_BOGUS",
         "HTML_BOGUS_ELEMENT",
@@ -67,5 +103,6 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "HTML_BOGUS_TEXT_EXPRESSION",
         "ASTRO_BOGUS_FRONTMATTER",
         "SVELTE_BOGUS_BLOCK",
+        "GLIMMER_BOGUS_EXPRESSION",
     ],
 };
diff --git a/xtask/codegen/src/js_kinds_src.rs b/xtask/codegen/src/js_kinds_src.rs
index 38edff725ab0..d81f0f1eca68 100644
--- a/xtask/codegen/src/js_kinds_src.rs
+++ b/xtask/codegen/src/js_kinds_src.rs
@@ -176,6 +176,7 @@ pub const JS_KINDS_SRC: KindsSrc = KindsSrc {
         "ERROR_TOKEN",
         "IDENT",
         "JSX_IDENT",
+        "GLIMMER_TEMPLATE", // <template>...</template>
         "NEWLINE",
         "WHITESPACE",
         "COMMENT",
@@ -331,6 +332,7 @@ pub const JS_KINDS_SRC: KindsSrc = KindsSrc {
         "JS_GETTER_CLASS_MEMBER",
         "JS_SETTER_CLASS_MEMBER",
         "JS_EMPTY_CLASS_MEMBER",
+        "JS_GLIMMER_TEMPLATE",
         "JS_PARENTHESIZED_ASSIGNMENT",
         "JS_IDENTIFIER_ASSIGNMENT",
         "JS_STATIC_MEMBER_ASSIGNMENT",
diff --git a/xtask/coverage/src/js/test262.rs b/xtask/coverage/src/js/test262.rs
index ed98a32472cb..76f9fb24da8b 100644
--- a/xtask/coverage/src/js/test262.rs
+++ b/xtask/coverage/src/js/test262.rs
@@ -1,7 +1,7 @@
 use crate::runner::{
     TestCase, TestCaseFiles, TestRunOutcome, TestSuite, create_bogus_node_in_tree_diagnostic,
 };
-use biome_js_parser::{JsParserOptions, parse};
+use biome_js_parser::{JsParserOptions, parse_with_options};
 use biome_js_syntax::JsFileSource;
 use biome_rowan::AstNode;
 use biome_rowan::syntax::SyntaxKind;
@@ -103,8 +103,11 @@ impl Test262TestCase {
         let files =
             TestCaseFiles::single(self.name.clone(), self.code.clone(), source_type, options);
 
-        match parse(&code, source_type, options).ok() {
-            Ok(root) if !should_fail => {
+        let parsed = parse_with_options(&code, source_type, options);
+        let has_errors = parsed.has_errors();
+
+        match (parsed.try_tree(), has_errors, should_fail) {
+            (Some(root), false, false) => {
                 if let Some(bogus) = root
                     .syntax()
                     .descendants()
@@ -118,9 +121,12 @@ impl Test262TestCase {
                     TestRunOutcome::Passed(files)
                 }
             }
-            Err(_) if should_fail => TestRunOutcome::Passed(files),
-            Ok(_) if should_fail => TestRunOutcome::IncorrectlyPassed(files),
-            Err(errors) if !should_fail => TestRunOutcome::IncorrectlyErrored { errors, files },
+            (_, true, true) => TestRunOutcome::Passed(files),
+            (_, false, true) => TestRunOutcome::IncorrectlyPassed(files),
+            (_, true, false) => TestRunOutcome::IncorrectlyErrored {
+                errors: parsed.diagnostics().to_vec(),
+                files,
+            },
             _ => unreachable!(),
         }
     }
diff --git a/xtask/coverage/src/jsx/jsx_babel.rs b/xtask/coverage/src/jsx/jsx_babel.rs
index b9f80a9195ef..7a9b1d885031 100644
--- a/xtask/coverage/src/jsx/jsx_babel.rs
+++ b/xtask/coverage/src/jsx/jsx_babel.rs
@@ -3,7 +3,7 @@ use crate::{
     check_file_encoding,
     runner::{TestCase, TestCaseFiles, TestRunOutcome, TestSuite},
 };
-use biome_js_parser::{JsParserOptions, parse};
+use biome_js_parser::{JsParserOptions, parse_with_options};
 use biome_js_syntax::{JsFileSource, ModuleKind};
 use biome_rowan::SyntaxKind;
 use std::io;
@@ -47,7 +47,7 @@ impl TestCase for BabelJsxTestCase {
             source_type,
             options,
         );
-        let result = parse(&self.code, source_type, options);
+        let result = parse_with_options(&self.code, source_type, options);
 
         if result.diagnostics().is_empty() {
             if let Some(bogus) = result
diff --git a/xtask/coverage/src/runner.rs b/xtask/coverage/src/runner.rs
index 32db86fbe1d3..73a9e9603d0f 100644
--- a/xtask/coverage/src/runner.rs
+++ b/xtask/coverage/src/runner.rs
@@ -5,7 +5,7 @@ use biome_diagnostics::PrintDiagnostic;
 use biome_diagnostics::console::fmt::{Formatter, Termcolor};
 use biome_diagnostics::console::markup;
 use biome_diagnostics::termcolor::Buffer;
-use biome_js_parser::{JsParserOptions, Parse, parse};
+use biome_js_parser::{JsParserOptions, Parse, parse_with_options};
 use biome_js_syntax::{AnyJsRoot, JsFileSource, JsSyntaxNode};
 use biome_rowan::SyntaxKind;
 use std::fmt::Debug;
@@ -85,7 +85,7 @@ pub(crate) struct TestCaseFile {
 
 impl TestCaseFile {
     pub(crate) fn parse(&self) -> Parse<AnyJsRoot> {
-        parse(&self.code, self.source_type, self.options)
+        parse_with_options(&self.code, self.source_type, self.options)
     }
 
     pub(crate) fn name(&self) -> &str {
diff --git a/xtask/coverage/src/symbols/msts.rs b/xtask/coverage/src/symbols/msts.rs
index 5487a671122a..b1ef6cbc40c3 100644
--- a/xtask/coverage/src/symbols/msts.rs
+++ b/xtask/coverage/src/symbols/msts.rs
@@ -85,7 +85,7 @@ impl TestCase for SymbolsMicrosoftTestCase {
         );
 
         let mut prev_starts: HashSet<TextSize> = HashSet::default();
-        let r = biome_js_parser::parse(&code, JsFileSource::tsx(), options);
+        let r = biome_js_parser::parse_with_options(&code, JsFileSource::tsx(), options);
         let mut actual: Vec<_> = biome_js_semantic::semantic_events(r.syntax())
             .into_iter()
             .filter(|x| {
diff --git a/xtask/coverage/src/ts/ts_babel.rs b/xtask/coverage/src/ts/ts_babel.rs
index 9c8497b40b1c..2d4c8e8a23e7 100644
--- a/xtask/coverage/src/ts/ts_babel.rs
+++ b/xtask/coverage/src/ts/ts_babel.rs
@@ -54,7 +54,7 @@ impl TestCase for BabelTypescriptTestCase {
             options,
         );
 
-        let result = biome_js_parser::parse(&self.code, source_type, options);
+        let result = biome_js_parser::parse_with_options(&self.code, source_type, options);
 
         if self.expected_to_fail && result.diagnostics().is_empty() {
             TestRunOutcome::IncorrectlyPassed(files)
diff --git a/xtask/rules_check/src/lib.rs b/xtask/rules_check/src/lib.rs
index e702739fcce6..a0c6a018a1c0 100644
--- a/xtask/rules_check/src/lib.rs
+++ b/xtask/rules_check/src/lib.rs
@@ -20,7 +20,6 @@ use biome_diagnostics::{DiagnosticExt, PrintDiagnostic, Severity};
 use biome_graphql_syntax::GraphqlLanguage;
 use biome_html_parser::HtmlParseOptions;
 use biome_html_syntax::HtmlLanguage;
-use biome_js_parser::JsParserOptions;
 use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, TextSize};
 use biome_json_factory::make;
 use biome_json_parser::JsonParserOptions;
@@ -300,7 +299,7 @@ fn assert_lint(
                 _ => (code, file_source),
             };
 
-            let parse = biome_js_parser::parse(code, file_source, JsParserOptions::default());
+            let parse = biome_js_parser::parse(code, file_source);
 
             if parse.has_errors() {
                 for diag in parse.into_diagnostics() {