diff --git a/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlElementFactory.cs b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlElementFactory.cs
new file mode 100644
index 0000000..b0b162f
--- /dev/null
+++ b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlElementFactory.cs
@@ -0,0 +1,150 @@
+using WebExpress.WebCore.WebHtml;
+using WebExpress.WebCore.WebHtml.Parser;
+
+namespace WebExpress.WebCore.Test.Html.Parser
+{
+    /// <summary>
+    /// Unit tests for the <see cref="HtmlElementFactory"/> class.
+    /// </summary>
+    [Collection("NonParallelTests")]
+    public class UnitTestHtmlElementFactory
+    {
+        /// <summary>
+        /// Known tags are resolved to their specific subclass.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Div_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("div");
+
+            Assert.IsType<HtmlElementTextContentDiv>(element);
+        }
+
+        /// <summary>
+        /// Known tags are resolved to their specific subclass.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Span_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("span");
+
+            Assert.IsType<HtmlElementTextSemanticsSpan>(element);
+        }
+
+        /// <summary>
+        /// Known tags are resolved to their specific subclass.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Img_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("img");
+
+            Assert.IsType<HtmlElementMultimediaImg>(element);
+        }
+
+        /// <summary>
+        /// Known tags are resolved to their specific subclass.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Input_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("input");
+
+            Assert.IsType<HtmlElementFieldInput>(element);
+        }
+
+        /// <summary>
+        /// Known tags are resolved to their specific subclass.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Table_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("table");
+
+            Assert.IsType<HtmlElementTableTable>(element);
+        }
+
+        /// <summary>
+        /// Factory is case-insensitive – upper-case tag names resolve correctly.
+        /// </summary>
+        [Fact]
+        public void CaseInsensitive_UpperCase_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("DIV");
+
+            Assert.IsType<HtmlElementTextContentDiv>(element);
+        }
+
+        /// <summary>
+        /// An unknown tag name returns a generic <see cref="HtmlElement"/>.
+        /// </summary>
+        [Fact]
+        public void UnknownTag_ReturnsGenericElement()
+        {
+            var element = HtmlElementFactory.Create("x-custom-widget");
+
+            Assert.IsType<HtmlElement>(element);
+        }
+
+        /// <summary>
+        /// <see cref="HtmlElementFactory.IsKnown"/> returns <c>true</c> for known tags.
+        /// </summary>
+        [Fact]
+        public void IsKnown_KnownTag_ReturnsTrue()
+        {
+            Assert.True(HtmlElementFactory.IsKnown("div"));
+        }
+
+        /// <summary>
+        /// <see cref="HtmlElementFactory.IsKnown"/> returns <c>false</c> for unknown tags.
+        /// </summary>
+        [Fact]
+        public void IsKnown_UnknownTag_ReturnsFalse()
+        {
+            Assert.False(HtmlElementFactory.IsKnown("x-unknown"));
+        }
+
+        /// <summary>
+        /// Passing <c>null</c> to <see cref="HtmlElementFactory.Create"/> throws an
+        /// <see cref="System.ArgumentNullException"/>.
+        /// </summary>
+        [Fact]
+        public void NullTagName_Throws()
+        {
+            Assert.Throws<System.ArgumentNullException>(() => HtmlElementFactory.Create(null));
+        }
+
+        /// <summary>
+        /// Both 'kbd' and 'kdb' map to the existing <see cref="HtmlElementTextSemanticsKdb"/>.
+        /// </summary>
+        [Fact]
+        public void KbdTag_MapsToKdbElement()
+        {
+            var element = HtmlElementFactory.Create("kbd");
+
+            Assert.IsType<HtmlElementTextSemanticsKdb>(element);
+        }
+
+        /// <summary>
+        /// The 'keygen' tag is resolved to <see cref="HtmlElementFormKeygen"/>.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Keygen_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("keygen");
+
+            Assert.IsType<HtmlElementFormKeygen>(element);
+        }
+
+        /// <summary>
+        /// The 'command' tag is resolved to <see cref="HtmlElementInteractiveCommand"/>.
+        /// </summary>
+        [Fact]
+        public void KnownTag_Command_ReturnsCorrectType()
+        {
+            var element = HtmlElementFactory.Create("command");
+
+            Assert.IsType<HtmlElementInteractiveCommand>(element);
+        }
+    }
+}
diff --git a/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlParser.cs b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlParser.cs
new file mode 100644
index 0000000..5738752
--- /dev/null
+++ b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlParser.cs
@@ -0,0 +1,500 @@
+using System.Linq;
+using WebExpress.WebCore.WebHtml;
+using WebExpress.WebCore.WebHtml.Parser;
+
+namespace WebExpress.WebCore.Test.Html.Parser
+{
+    /// <summary>
+    /// Unit tests for the <see cref="HtmlParser"/> class.
+    /// </summary>
+    [Collection("NonParallelTests")]
+    public class UnitTestHtmlParser
+    {
+        private static readonly HtmlParser Parser = new();
+
+        // ------------------------------------------------------------------
+        // Simple elements
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A simple element is correctly reconstructed.
+        /// </summary>
+        [Fact]
+        public void SimpleElement_Div_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<div></div>");
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+
+            Assert.NotNull(div);
+        }
+
+        /// <summary>
+        /// An element with a class attribute retains its attribute.
+        /// </summary>
+        [Fact]
+        public void ElementWithClass_RetainsAttribute()
+        {
+            var nodes = Parser.Parse("<div class=\"container\"></div>");
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+
+            Assert.Equal("container", div.Class);
+        }
+
+        /// <summary>
+        /// An element with an id attribute retains its attribute.
+        /// </summary>
+        [Fact]
+        public void ElementWithId_RetainsAttribute()
+        {
+            var nodes = Parser.Parse("<p id=\"intro\">text</p>");
+            var p = nodes.OfType<HtmlElementTextContentP>().Single();
+
+            Assert.Equal("intro", p.Id);
+        }
+
+        // ------------------------------------------------------------------
+        // Nested structures
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A nested element hierarchy is correctly reconstructed.
+        /// </summary>
+        [Fact]
+        public void NestedElements_AreReconstructed()
+        {
+            var nodes = Parser.Parse("<div><span>text</span></div>");
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+            var span = div.Elements.OfType<HtmlElementTextSemanticsSpan>().Single();
+
+            Assert.NotNull(span);
+        }
+
+        /// <summary>
+        /// A deeply nested structure is correctly reconstructed.
+        /// </summary>
+        [Fact]
+        public void DeepNesting_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<ul><li><span>item</span></li></ul>");
+            var ul = nodes.OfType<HtmlElementTextContentUl>().Single();
+            var li = ul.Elements.OfType<HtmlElementTextContentLi>().Single();
+            var span = li.Elements.OfType<HtmlElementTextSemanticsSpan>().Single();
+
+            Assert.NotNull(span);
+        }
+
+        // ------------------------------------------------------------------
+        // Text nodes
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A text node inside an element is preserved.
+        /// </summary>
+        [Fact]
+        public void TextNode_IsPreserved()
+        {
+            var nodes = Parser.Parse("<p>Hello World</p>");
+            var p = nodes.OfType<HtmlElementTextContentP>().Single();
+            var text = p.Elements.OfType<HtmlText>().Single();
+
+            Assert.Equal("Hello World", text.Value);
+        }
+
+        /// <summary>
+        /// A bare text node at the top level is returned as a text node.
+        /// </summary>
+        [Fact]
+        public void BareText_ReturnsTextNode()
+        {
+            var nodes = Parser.Parse("Hello");
+            var text = nodes.OfType<HtmlText>().Single();
+
+            Assert.Equal("Hello", text.Value);
+        }
+
+        // ------------------------------------------------------------------
+        // Self-closing tags
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A self-closing &lt;br/&gt; tag produces a <see cref="HtmlElementTextSemanticsBr"/>.
+        /// </summary>
+        [Fact]
+        public void SelfClosingBr_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<br/>");
+            var br = nodes.OfType<HtmlElementTextSemanticsBr>().Single();
+
+            Assert.NotNull(br);
+        }
+
+        /// <summary>
+        /// A void &lt;img&gt; tag (no trailing slash) produces a <see cref="HtmlElementMultimediaImg"/>.
+        /// </summary>
+        [Fact]
+        public void VoidImg_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<img src=\"photo.png\" alt=\"photo\">");
+            var img = nodes.OfType<HtmlElementMultimediaImg>().Single();
+
+            Assert.Equal("photo.png", img.Src);
+            Assert.Equal("photo", img.Alt);
+        }
+
+        // ------------------------------------------------------------------
+        // Attributes
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// Boolean attributes are applied to the element.
+        /// </summary>
+        [Fact]
+        public void BooleanAttribute_IsApplied()
+        {
+            var nodes = Parser.Parse("<input disabled>");
+            var input = nodes.OfType<HtmlElementFieldInput>().Single();
+
+            Assert.True(input.HasUserAttribute("disabled"));
+        }
+
+        /// <summary>
+        /// data-* attributes are preserved on the element.
+        /// </summary>
+        [Fact]
+        public void DataAttribute_IsPreserved()
+        {
+            var nodes = Parser.Parse("<div data-toggle=\"modal\"></div>");
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+
+            Assert.Equal("modal", div.GetUserAttribute("data-toggle"));
+        }
+
+        /// <summary>
+        /// ARIA attributes are preserved on the element.
+        /// </summary>
+        [Fact]
+        public void AriaAttribute_IsPreserved()
+        {
+            var nodes = Parser.Parse("<button aria-label=\"Close\"></button>");
+            var btn = nodes.OfType<HtmlElementFieldButton>().Single();
+
+            Assert.Equal("Close", btn.GetUserAttribute("aria-label"));
+        }
+
+        // ------------------------------------------------------------------
+        // Comments
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// An HTML comment is reconstructed as a <see cref="HtmlComment"/> node.
+        /// </summary>
+        [Fact]
+        public void Comment_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<!-- remark -->");
+            var comment = nodes.OfType<HtmlComment>().Single();
+
+            Assert.Equal("remark", comment.Text);
+        }
+
+        // ------------------------------------------------------------------
+        // DOCTYPE
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A DOCTYPE declaration does not produce a node in the tree (it is
+        /// informational only).
+        /// </summary>
+        [Fact]
+        public void Doctype_ProducesNoNode()
+        {
+            var nodes = Parser.Parse("<!DOCTYPE html><html></html>");
+
+            Assert.DoesNotContain(nodes, n => n is HtmlText t && t.Value.Contains("DOCTYPE"));
+        }
+
+        // ------------------------------------------------------------------
+        // Unknown tags
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// An unknown tag is mapped to a generic <see cref="HtmlElement"/>.
+        /// </summary>
+        [Fact]
+        public void UnknownTag_MapsToGenericElement()
+        {
+            var nodes = Parser.Parse("<x-widget foo=\"bar\"></x-widget>");
+            var element = nodes.OfType<HtmlElement>().Single();
+
+            Assert.Equal("bar", element.GetUserAttribute("foo"));
+        }
+
+        // ------------------------------------------------------------------
+        // Malformed HTML
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// An unclosed tag is handled gracefully and the element is still returned.
+        /// </summary>
+        [Fact]
+        public void UnclosedTag_IsHandledGracefully()
+        {
+            var nodes = Parser.Parse("<div><p>text");
+
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+            Assert.NotNull(div);
+        }
+
+        /// <summary>
+        /// Parsing an empty string does not throw.
+        /// </summary>
+        [Fact]
+        public void EmptyInput_ReturnsEmptyList()
+        {
+            var nodes = Parser.Parse("");
+
+            Assert.Empty(nodes);
+        }
+
+        /// <summary>
+        /// Passing <c>null</c> to <see cref="HtmlParser.Parse"/> throws
+        /// <see cref="System.ArgumentNullException"/>.
+        /// </summary>
+        [Fact]
+        public void NullInput_Throws()
+        {
+            Assert.Throws<System.ArgumentNullException>(() => Parser.Parse(null));
+        }
+
+        // ------------------------------------------------------------------
+        // Round-trip tests
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// Parsing the HTML produced by the renderer reconstructs the same
+        /// element type.
+        /// </summary>
+        [Fact]
+        public void RoundTrip_SimpleDiv_PreservesType()
+        {
+            // arrange
+            var original = new HtmlElementTextContentDiv();
+            original.Id = "main";
+            original.AddClass("container");
+
+            // act
+            var html = original.ToString().Trim();
+            var parsed = Parser.Parse(html);
+
+            var restored = parsed.OfType<HtmlElementTextContentDiv>().Single();
+
+            // validation
+            Assert.Equal(original.Id, restored.Id);
+            Assert.Equal(original.Class, restored.Class);
+        }
+
+        /// <summary>
+        /// Parsing the HTML produced by the renderer for a nested structure
+        /// reconstructs the hierarchy.
+        /// </summary>
+        [Fact]
+        public void RoundTrip_NestedStructure_PreservesHierarchy()
+        {
+            // arrange
+            var original = new HtmlElementTextContentDiv(
+                new HtmlElementTextSemanticsSpan(new HtmlText("hello"))
+            );
+
+            // act
+            var html = original.ToString().Trim();
+            var parsed = Parser.Parse(html);
+
+            var div = parsed.OfType<HtmlElementTextContentDiv>().Single();
+            var span = div.Elements.OfType<HtmlElementTextSemanticsSpan>().Single();
+            var text = span.Elements.OfType<HtmlText>().Single();
+
+            // validation
+            Assert.Equal("hello", text.Value);
+        }
+
+        /// <summary>
+        /// Rendering the parsed HTML of an &lt;img&gt; element produces equivalent HTML.
+        /// </summary>
+        [Fact]
+        public void RoundTrip_Img_ProducesEquivalentHtml()
+        {
+            // arrange
+            var original = new HtmlElementMultimediaImg
+            {
+                Src = "logo.png",
+                Alt = "Logo"
+            };
+
+            // act
+            var html = original.ToString().Trim();
+            var parsed = Parser.Parse(html);
+
+            var img = parsed.OfType<HtmlElementMultimediaImg>().Single();
+            var restoredHtml = img.ToString().Trim();
+
+            // validation
+            Assert.Equal(html, restoredHtml);
+        }
+
+        // ------------------------------------------------------------------
+        // Additional tests
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// ParseSingle returns the first node.
+        /// </summary>
+        [Fact]
+        public void ParseSingle_ReturnsFirstNode()
+        {
+            var node = Parser.ParseSingle("<div></div>");
+
+            Assert.IsType<HtmlElementTextContentDiv>(node);
+        }
+
+        /// <summary>
+        /// ParseSingle returns null for an empty input.
+        /// </summary>
+        [Fact]
+        public void ParseSingle_EmptyInput_ReturnsNull()
+        {
+            var node = Parser.ParseSingle("");
+
+            Assert.Null(node);
+        }
+
+        /// <summary>
+        /// An element with an inline style attribute retains its value.
+        /// </summary>
+        [Fact]
+        public void InlineStyleAttribute_IsPreserved()
+        {
+            var nodes = Parser.Parse("<div style=\"color: red;\"></div>");
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+
+            Assert.Equal("color: red;", div.Style);
+        }
+
+        /// <summary>
+        /// A table structure with thead, tbody, and rows is correctly reconstructed.
+        /// </summary>
+        [Fact]
+        public void TableStructure_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<table><thead><tr><th>Header</th></tr></thead><tbody><tr><td>Cell</td></tr></tbody></table>");
+            var table = nodes.OfType<HtmlElementTableTable>().Single();
+            var thead = table.Elements.OfType<HtmlElementTableThead>().Single();
+            var tbody = table.Elements.OfType<HtmlElementTableTbody>().Single();
+
+            Assert.NotNull(thead);
+            Assert.NotNull(tbody);
+        }
+
+        /// <summary>
+        /// Multiple top-level elements are all returned.
+        /// </summary>
+        [Fact]
+        public void MultipleRoots_AreAllReturned()
+        {
+            var nodes = Parser.Parse("<p>one</p><p>two</p>");
+
+            Assert.Equal(2, nodes.Count);
+            Assert.All(nodes, n => Assert.IsType<HtmlElementTextContentP>(n));
+        }
+
+        /// <summary>
+        /// A mismatched end tag is handled gracefully without throwing.
+        /// </summary>
+        [Fact]
+        public void MismatchedEndTag_IsHandledGracefully()
+        {
+            var nodes = Parser.Parse("<div><span>text</div>");
+
+            var div = nodes.OfType<HtmlElementTextContentDiv>().Single();
+            Assert.NotNull(div);
+        }
+
+        /// <summary>
+        /// Mixed text and element children are preserved in order.
+        /// </summary>
+        [Fact]
+        public void MixedContent_TextAndElements_ArePreserved()
+        {
+            var nodes = Parser.Parse("<p>Hello <strong>World</strong>!</p>");
+            var p = nodes.OfType<HtmlElementTextContentP>().Single();
+
+            Assert.Equal(3, p.Elements.Count());
+        }
+
+        /// <summary>
+        /// Roundtrip of a styled element preserves the style attribute.
+        /// </summary>
+        [Fact]
+        public void RoundTrip_StyleAttribute_IsPreserved()
+        {
+            // arrange
+            var original = new HtmlElementTextContentDiv();
+            original.Style = "color: red;";
+
+            // act
+            var html = original.ToString().Trim();
+            var parsed = Parser.Parse(html);
+
+            var restored = parsed.OfType<HtmlElementTextContentDiv>().Single();
+
+            // validation
+            Assert.Equal("color: red;", restored.Style);
+        }
+
+        /// <summary>
+        /// Roundtrip of an anchor element preserves href and text content.
+        /// </summary>
+        [Fact]
+        public void RoundTrip_Anchor_PreservesHrefAndText()
+        {
+            // arrange
+            var original = new HtmlElementTextSemanticsA(new HtmlText("click me"));
+            original.Href = "https://example.com";
+
+            // act
+            var html = original.ToString().Trim();
+            var parsed = Parser.Parse(html);
+
+            var a = parsed.OfType<HtmlElementTextSemanticsA>().Single();
+            var text = a.Elements.OfType<HtmlText>().Single();
+
+            // validation
+            Assert.Equal("https://example.com", a.Href);
+            Assert.Equal("click me", text.Value);
+        }
+
+        /// <summary>
+        /// A form with input fields is correctly reconstructed.
+        /// </summary>
+        [Fact]
+        public void FormWithInputs_IsReconstructed()
+        {
+            var nodes = Parser.Parse("<form action=\"/submit\"><input type=\"text\" name=\"q\"></form>");
+            var form = nodes.OfType<HtmlElementFormForm>().Single();
+            var input = form.Elements.OfType<HtmlElementFieldInput>().Single();
+
+            Assert.NotNull(input);
+        }
+
+        /// <summary>
+        /// The kbd tag (standard HTML) maps to HtmlElementTextSemanticsKdb.
+        /// </summary>
+        [Fact]
+        public void KbdTag_MapsToKdbElement()
+        {
+            var nodes = Parser.Parse("<kbd>Ctrl+C</kbd>");
+            var kbd = nodes.OfType<HtmlElementTextSemanticsKdb>().Single();
+
+            Assert.NotNull(kbd);
+        }
+    }
+}
diff --git a/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlTokenizer.cs b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlTokenizer.cs
new file mode 100644
index 0000000..3dda876
--- /dev/null
+++ b/src/WebExpress.WebCore.Test/Html/Parser/UnitTestHtmlTokenizer.cs
@@ -0,0 +1,321 @@
+using System.Linq;
+using WebExpress.WebCore.WebHtml.Parser;
+
+namespace WebExpress.WebCore.Test.Html.Parser
+{
+    /// <summary>
+    /// Unit tests for the <see cref="HtmlTokenizer"/> class.
+    /// </summary>
+    [Collection("NonParallelTests")]
+    public class UnitTestHtmlTokenizer
+    {
+        // ------------------------------------------------------------------
+        // Helper
+        // ------------------------------------------------------------------
+
+        private static HtmlToken[] Tokenize(string html)
+        {
+            var tokenizer = new HtmlTokenizer(html);
+            return [.. tokenizer.Tokenize()];
+        }
+
+        // ------------------------------------------------------------------
+        // Basic tokens
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// An empty input produces only an EOF token.
+        /// </summary>
+        [Fact]
+        public void EmptyInput_ReturnsEof()
+        {
+            var tokens = Tokenize("");
+
+            Assert.Single(tokens);
+            Assert.Equal(HtmlTokenType.EndOfFile, tokens[0].Type);
+        }
+
+        /// <summary>
+        /// A plain text input produces a text token.
+        /// </summary>
+        [Fact]
+        public void PlainText_ReturnsTextToken()
+        {
+            var tokens = Tokenize("Hello World");
+
+            Assert.Equal(HtmlTokenType.Text, tokens[0].Type);
+            Assert.Equal("Hello World", tokens[0].Value);
+        }
+
+        /// <summary>
+        /// A simple start tag produces a start-tag token.
+        /// </summary>
+        [Fact]
+        public void SimpleStartTag_ReturnsStartTag()
+        {
+            var tokens = Tokenize("<div>");
+
+            Assert.Equal(HtmlTokenType.StartTag, tokens[0].Type);
+            Assert.Equal("div", tokens[0].TagName);
+        }
+
+        /// <summary>
+        /// A simple end tag produces an end-tag token.
+        /// </summary>
+        [Fact]
+        public void SimpleEndTag_ReturnsEndTag()
+        {
+            var tokens = Tokenize("</div>");
+
+            Assert.Equal(HtmlTokenType.EndTag, tokens[0].Type);
+            Assert.Equal("div", tokens[0].TagName);
+        }
+
+        /// <summary>
+        /// An explicit self-closing tag produces a self-closing token.
+        /// </summary>
+        [Fact]
+        public void ExplicitSelfClosingTag_ReturnsSelfClosing()
+        {
+            var tokens = Tokenize("<br/>");
+
+            Assert.Equal(HtmlTokenType.SelfClosingTag, tokens[0].Type);
+            Assert.Equal("br", tokens[0].TagName);
+        }
+
+        /// <summary>
+        /// A void element without a trailing slash is still emitted as self-closing.
+        /// </summary>
+        [Fact]
+        public void VoidElement_ReturnsSelfClosing()
+        {
+            var tokens = Tokenize("<img>");
+
+            Assert.Equal(HtmlTokenType.SelfClosingTag, tokens[0].Type);
+            Assert.Equal("img", tokens[0].TagName);
+        }
+
+        // ------------------------------------------------------------------
+        // Attributes
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// Quoted attribute values are correctly extracted.
+        /// </summary>
+        [Fact]
+        public void TagWithQuotedAttribute_ExtractsAttribute()
+        {
+            var tokens = Tokenize("<div class=\"foo\">");
+
+            Assert.Equal(HtmlTokenType.StartTag, tokens[0].Type);
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("class", attr.Name);
+            Assert.Equal("foo", attr.Value);
+        }
+
+        /// <summary>
+        /// Single-quoted attribute values are correctly extracted.
+        /// </summary>
+        [Fact]
+        public void TagWithSingleQuotedAttribute_ExtractsAttribute()
+        {
+            var tokens = Tokenize("<div class='bar'>");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("class", attr.Name);
+            Assert.Equal("bar", attr.Value);
+        }
+
+        /// <summary>
+        /// Multiple attributes on a single tag are all extracted.
+        /// </summary>
+        [Fact]
+        public void TagWithMultipleAttributes_ExtractsAll()
+        {
+            var tokens = Tokenize("<input id=\"x\" type=\"text\" disabled>");
+
+            var attrs = tokens[0].Attributes;
+            Assert.Equal(3, attrs.Count);
+            Assert.Equal("id", attrs[0].Name);
+            Assert.Equal("x", attrs[0].Value);
+            Assert.Equal("type", attrs[1].Name);
+            Assert.Equal("text", attrs[1].Value);
+            Assert.Equal("disabled", attrs[2].Name);
+            Assert.True(attrs[2].IsBoolean);
+        }
+
+        /// <summary>
+        /// Boolean (valueless) attributes are represented without a value.
+        /// </summary>
+        [Fact]
+        public void BooleanAttribute_IsBoolean()
+        {
+            var tokens = Tokenize("<input required>");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.True(attr.IsBoolean);
+            Assert.Null(attr.Value);
+        }
+
+        /// <summary>
+        /// Data attributes are preserved as-is.
+        /// </summary>
+        [Fact]
+        public void DataAttribute_IsPreserved()
+        {
+            var tokens = Tokenize("<div data-toggle=\"modal\">");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("data-toggle", attr.Name);
+            Assert.Equal("modal", attr.Value);
+        }
+
+        /// <summary>
+        /// ARIA attributes are preserved as-is.
+        /// </summary>
+        [Fact]
+        public void AriaAttribute_IsPreserved()
+        {
+            var tokens = Tokenize("<button aria-label=\"Close\"></button>");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("aria-label", attr.Name);
+            Assert.Equal("Close", attr.Value);
+        }
+
+        // ------------------------------------------------------------------
+        // Comments and DOCTYPE
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// An HTML comment produces a comment token whose value does not include the delimiters.
+        /// </summary>
+        [Fact]
+        public void Comment_ReturnsCommentToken()
+        {
+            var tokens = Tokenize("<!-- remark -->");
+
+            Assert.Equal(HtmlTokenType.Comment, tokens[0].Type);
+            Assert.Equal("remark", tokens[0].Value);
+        }
+
+        /// <summary>
+        /// A DOCTYPE declaration produces a doctype token.
+        /// </summary>
+        [Fact]
+        public void Doctype_ReturnsDoctypeToken()
+        {
+            var tokens = Tokenize("<!DOCTYPE html>");
+
+            Assert.Equal(HtmlTokenType.Doctype, tokens[0].Type);
+            Assert.Equal("html", tokens[0].TagName);
+        }
+
+        // ------------------------------------------------------------------
+        // Compound input
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// A typical HTML snippet produces the expected sequence of tokens.
+        /// </summary>
+        [Fact]
+        public void CompoundInput_ProducesExpectedSequence()
+        {
+            var tokens = Tokenize("<p>Hello</p>");
+
+            Assert.Equal(HtmlTokenType.StartTag, tokens[0].Type);
+            Assert.Equal("p", tokens[0].TagName);
+
+            Assert.Equal(HtmlTokenType.Text, tokens[1].Type);
+            Assert.Equal("Hello", tokens[1].Value);
+
+            Assert.Equal(HtmlTokenType.EndTag, tokens[2].Type);
+            Assert.Equal("p", tokens[2].TagName);
+
+            Assert.Equal(HtmlTokenType.EndOfFile, tokens[3].Type);
+        }
+
+        /// <summary>
+        /// Tags names are normalised to lower case.
+        /// </summary>
+        [Fact]
+        public void TagNameNormalisation_IsLowerCase()
+        {
+            var tokens = Tokenize("<DIV class=\"FOO\">");
+
+            Assert.Equal("div", tokens[0].TagName);
+            Assert.Equal("class", tokens[0].Attributes[0].Name);
+        }
+
+        // ------------------------------------------------------------------
+        // Whitespace and edge cases
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// Whitespace-only text between tags is preserved as a text token.
+        /// </summary>
+        [Fact]
+        public void WhitespaceText_IsPreservedAsTextToken()
+        {
+            var tokens = Tokenize("<div> </div>");
+
+            Assert.Equal(HtmlTokenType.StartTag, tokens[0].Type);
+            Assert.Equal(HtmlTokenType.Text, tokens[1].Type);
+            Assert.Equal(" ", tokens[1].Value);
+            Assert.Equal(HtmlTokenType.EndTag, tokens[2].Type);
+        }
+
+        /// <summary>
+        /// An unquoted attribute value is read until whitespace or closing bracket.
+        /// </summary>
+        [Fact]
+        public void UnquotedAttributeValue_IsExtracted()
+        {
+            var tokens = Tokenize("<div class=foo>");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("class", attr.Name);
+            Assert.Equal("foo", attr.Value);
+        }
+
+        /// <summary>
+        /// An inline style attribute is preserved in its entirety.
+        /// </summary>
+        [Fact]
+        public void InlineStyleAttribute_IsPreserved()
+        {
+            var tokens = Tokenize("<div style=\"color: red; font-size: 14px;\">");
+
+            var attr = tokens[0].Attributes.Single();
+            Assert.Equal("style", attr.Name);
+            Assert.Equal("color: red; font-size: 14px;", attr.Value);
+        }
+
+        /// <summary>
+        /// A stray less-than character is emitted as text.
+        /// </summary>
+        [Fact]
+        public void StrayLessThan_IsEmittedAsText()
+        {
+            var tokens = Tokenize("a < b");
+
+            Assert.Equal(HtmlTokenType.Text, tokens[0].Type);
+            Assert.Equal("a ", tokens[0].Value);
+            Assert.Equal(HtmlTokenType.Text, tokens[1].Type);
+            Assert.Equal("<", tokens[1].Value);
+            Assert.Equal(HtmlTokenType.Text, tokens[2].Type);
+        }
+
+        /// <summary>
+        /// A keygen void element without slash is emitted as self-closing.
+        /// </summary>
+        [Fact]
+        public void KeygenVoidElement_ReturnsSelfClosing()
+        {
+            var tokens = Tokenize("<keygen>");
+
+            Assert.Equal(HtmlTokenType.SelfClosingTag, tokens[0].Type);
+            Assert.Equal("keygen", tokens[0].TagName);
+        }
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlElementFactory.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlElementFactory.cs
new file mode 100644
index 0000000..b44c04b
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlElementFactory.cs
@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Maps HTML tag names to their corresponding <see cref="HtmlElement"/> subclass instances.
+    /// </summary>
+    /// <remarks>
+    /// When a tag name is not recognised, the factory returns a generic
+    /// <see cref="HtmlElement"/> instance whose <c>ElementName</c> is preserved so
+    /// that the tag name survives a round-trip through the renderer.
+    /// </remarks>
+    public class HtmlElementFactory
+    {
+        private static readonly Dictionary<string, Func<HtmlElement>> _registry =
+            new(StringComparer.OrdinalIgnoreCase)
+            {
+                // Root
+                ["html"] = () => new HtmlElementRootHtml(),
+
+                // Metadata
+                ["head"] = () => new HtmlElementMetadataHead(),
+                ["base"] = () => new HtmlElementMetadataBase(),
+                ["link"] = () => new HtmlElementMetadataLink(),
+                ["meta"] = () => new HtmlElementMetadataMeta(),
+                ["style"] = () => new HtmlElementMetadataStyle(),
+                ["title"] = () => new HtmlElementMetadataTitle(),
+
+                // Scripting
+                ["script"] = () => new HtmlElementScriptingScript(),
+                ["noscript"] = () => new HtmlElementScriptingNoscript(),
+                ["canvas"] = () => new HtmlElementScriptingCanvas(),
+
+                // Sections
+                ["body"] = () => new HtmlElementSectionBody(),
+                ["address"] = () => new HtmlElementSectionAddress(),
+                ["article"] = () => new HtmlElementSectionArticle(),
+                ["aside"] = () => new HtmlElementSectionAside(),
+                ["footer"] = () => new HtmlElementSectionFooter(),
+                ["h1"] = () => new HtmlElementSectionH1(),
+                ["h2"] = () => new HtmlElementSectionH2(),
+                ["h3"] = () => new HtmlElementSectionH3(),
+                ["h4"] = () => new HtmlElementSectionH4(),
+                ["h5"] = () => new HtmlElementSectionH5(),
+                ["h6"] = () => new HtmlElementSectionH6(),
+                ["header"] = () => new HtmlElementSectionHeader(),
+                ["main"] = () => new HtmlElementSectionMain(),
+                ["nav"] = () => new HtmlElementSectionNav(),
+                ["section"] = () => new HtmlElementSectionSection(),
+
+                // Text content
+                ["blockquote"] = () => new HtmlElementTextContentBlockquote(),
+                ["dd"] = () => new HtmlElementTextContentDd(),
+                ["div"] = () => new HtmlElementTextContentDiv(),
+                ["dl"] = () => new HtmlElementTextContentDl(),
+                ["dt"] = () => new HtmlElementTextContentDt(),
+                ["figcaption"] = () => new HtmlElementTextContentFigcaption(),
+                ["figure"] = () => new HtmlElementTextContentFigure(),
+                ["hr"] = () => new HtmlElementTextContentHr(),
+                ["li"] = () => new HtmlElementTextContentLi(),
+                ["ol"] = () => new HtmlElementTextContentOl(),
+                ["p"] = () => new HtmlElementTextContentP(),
+                ["pre"] = () => new HtmlElementTextContentPre(),
+                ["ul"] = () => new HtmlElementTextContentUl(),
+
+                // Inline text semantics
+                ["a"] = () => new HtmlElementTextSemanticsA(),
+                ["abbr"] = () => new HtmlElementTextSemanticsAbbr(),
+                ["b"] = () => new HtmlElementTextSemanticsB(),
+                ["bdi"] = () => new HtmlElementTextSemanticsBdi(),
+                ["bdo"] = () => new HtmlElementTextSemanticsBdo(),
+                ["br"] = () => new HtmlElementTextSemanticsBr(),
+                ["cite"] = () => new HtmlElementTextSemanticsCite(),
+                ["code"] = () => new HtmlElementTextSemanticsCode(),
+                ["data"] = () => new HtmlElementTextSemanticsData(),
+                ["dfn"] = () => new HtmlElementTextSemanticsDfn(),
+                ["em"] = () => new HtmlElementTextSemanticsEm(),
+                ["i"] = () => new HtmlElementTextSemanticsI(),
+                // The standard HTML element is <kbd>, but the existing class uses "kdb" as
+                // its element name.  Both spellings are mapped so that the parser handles
+                // real-world HTML (<kbd>) as well as the project's own renderer output (<kdb>).
+                ["kbd"] = () => new HtmlElementTextSemanticsKdb(),
+                ["kdb"] = () => new HtmlElementTextSemanticsKdb(),
+                // 'kbd' is the correct HTML tag name; 'kdb' mirrors the existing class typo.
+                ["kbd"] = () => new HtmlElementTextSemanticsKdb(),
+                ["mark"] = () => new HtmlElementTextSemanticsMark(),
+                ["q"] = () => new HtmlElementTextSemanticsQ(),
+                ["rp"] = () => new HtmlElementTextSemanticsRp(),
+                ["rt"] = () => new HtmlElementTextSemanticsRt(),
+                ["ruby"] = () => new HtmlElementTextSemanticsRuby(),
+                ["s"] = () => new HtmlElementTextSemanticsS(),
+                ["samp"] = () => new HtmlElementTextSemanticsSamp(),
+                ["small"] = () => new HtmlElementTextSemanticsSmall(),
+                ["span"] = () => new HtmlElementTextSemanticsSpan(),
+                ["strong"] = () => new HtmlElementTextSemanticsStrong(),
+                ["sub"] = () => new HtmlElementTextSemanticsSub(),
+                ["sup"] = () => new HtmlElementTextSemanticsSup(),
+                ["time"] = () => new HtmlElementTextSemanticsTime(),
+                ["u"] = () => new HtmlElementTextSemanticsU(),
+                ["var"] = () => new HtmlElementTextSemanticsVar(),
+                ["wbr"] = () => new HtmlElementTextSemanticsWbr(),
+
+                // Edits
+                ["del"] = () => new HtmlElementEditDel(),
+                ["ins"] = () => new HtmlElementEditIns(),
+
+                // Embedded content
+                ["embed"] = () => new HtmlElementEmbeddedEmbed(),
+                ["iframe"] = () => new HtmlElementEmbeddedIframe(),
+                ["object"] = () => new HtmlElementEmbeddedObject(),
+                ["param"] = () => new HtmlElementEmbeddedParam(),
+                ["picture"] = () => new HtmlElementEmbeddedPicture(),
+                ["source"] = () => new HtmlElementEmbeddedSource(),
+
+                // Multimedia
+                ["area"] = () => new HtmlElementMultimediaArea(),
+                ["audio"] = () => new HtmlElementMultimediaAudio(),
+                ["img"] = () => new HtmlElementMultimediaImg(),
+                ["map"] = () => new HtmlElementMultimediaMap(),
+                ["math"] = () => new HtmlElementMultimediaMath(),
+                ["svg"] = () => new HtmlElementMultimediaSvg(),
+                ["track"] = () => new HtmlElementMultimediaTrack(),
+                ["video"] = () => new HtmlElementMultimediaVideo(),
+
+                // Table
+                ["caption"] = () => new HtmlElementTableCaption(),
+                ["col"] = () => new HtmlElementTableCol(),
+                ["colgroup"] = () => new HtmlElementTableColgroup(),
+                ["table"] = () => new HtmlElementTableTable(),
+                ["tbody"] = () => new HtmlElementTableTbody(),
+                ["td"] = () => new HtmlElementTableTd(),
+                ["tfoot"] = () => new HtmlElementTableTfoot(),
+                ["th"] = () => new HtmlElementTableTh(),
+                ["thead"] = () => new HtmlElementTableThead(),
+                ["tr"] = () => new HtmlElementTableTr(),
+
+                // Forms
+                ["button"] = () => new HtmlElementFieldButton(),
+                ["input"] = () => new HtmlElementFieldInput(),
+                ["label"] = () => new HtmlElementFieldLabel(),
+                ["legend"] = () => new HtmlElementFieldLegend(),
+                ["select"] = () => new HtmlElementFieldSelect(),
+                ["datalist"] = () => new HtmlElementFormDatalist(),
+                ["fieldset"] = () => new HtmlElementFormFieldset(),
+                ["form"] = () => new HtmlElementFormForm(),
+                ["keygen"] = () => new HtmlElementFormKeygen(),
+                ["meter"] = () => new HtmlElementFormMeter(),
+                ["optgroup"] = () => new HtmlElementFormOptgroup(),
+                ["option"] = () => new HtmlElementFormOption(),
+                ["output"] = () => new HtmlElementFormOutput(),
+                ["progress"] = () => new HtmlElementFormProgress(),
+                ["textarea"] = () => new HtmlElementFormTextarea(),
+
+                // Interactive
+                ["command"] = () => new HtmlElementInteractiveCommand(),
+                ["details"] = () => new HtmlElementInteractiveDetails(),
+                ["menu"] = () => new HtmlElementInteractiveMenu(),
+                ["summary"] = () => new HtmlElementInteractiveSummary(),
+
+                // Web fragments
+                ["slot"] = () => new HtmlElementWebFragmentsSlot(),
+                ["template"] = () => new HtmlElementWebFragmentsTemplate(),
+            };
+
+        /// <summary>
+        /// Creates an <see cref="HtmlElement"/> instance for the specified HTML tag name.
+        /// </summary>
+        /// <param name="tagName">The lower-case HTML tag name (e.g. <c>"div"</c>).</param>
+        /// <returns>
+        /// An instance of the most specific <see cref="HtmlElement"/> subclass that
+        /// corresponds to <paramref name="tagName"/>. If the tag name is unknown, a generic
+        /// <see cref="HtmlElement"/> is returned so that the parser remains robust.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown when <paramref name="tagName"/> is <c>null</c>.
+        /// </exception>
+        public static HtmlElement Create(string tagName)
+        {
+            if (tagName is null)
+            {
+                throw new ArgumentNullException(nameof(tagName));
+            }
+
+            if (_registry.TryGetValue(tagName, out var factory))
+            {
+                return factory();
+            }
+
+            // Unknown tag – return a generic element so parsing remains robust.
+            return new HtmlElement(tagName);
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if the specified tag name is registered in the factory.
+        /// </summary>
+        /// <param name="tagName">The HTML tag name to look up (case-insensitive).</param>
+        public static bool IsKnown(string tagName) =>
+            tagName is not null && _registry.ContainsKey(tagName);
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlParseException.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlParseException.cs
new file mode 100644
index 0000000..68de726
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlParseException.cs
@@ -0,0 +1,54 @@
+using System;
+
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Represents an error that occurs while tokenizing or parsing an HTML string.
+    /// </summary>
+    public class HtmlParseException : Exception
+    {
+        /// <summary>
+        /// Returns the zero-based character position in the input at which the
+        /// error was detected, or <c>-1</c> if the position is unknown.
+        /// </summary>
+        public int Position { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HtmlParseException"/> class
+        /// with the specified error message.
+        /// </summary>
+        /// <param name="message">A descriptive message that explains the reason for the failure.</param>
+        public HtmlParseException(string message)
+            : base(message)
+        {
+            Position = -1;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HtmlParseException"/> class
+        /// with the specified error message and the position in the input where the
+        /// error occurred.
+        /// </summary>
+        /// <param name="message">A descriptive message that explains the reason for the failure.</param>
+        /// <param name="position">The zero-based character position in the input where the error was detected.</param>
+        public HtmlParseException(string message, int position)
+            : base(message)
+        {
+            Position = position;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HtmlParseException"/> class
+        /// with the specified error message and a reference to the inner exception
+        /// that caused this exception.
+        /// </summary>
+        /// <param name="message">A descriptive message that explains the reason for the failure.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception,
+        /// or <c>null</c> if no inner exception is specified.</param>
+        public HtmlParseException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+            Position = -1;
+        }
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlParser.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlParser.cs
new file mode 100644
index 0000000..a3567f5
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlParser.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Parses an HTML string and reconstructs the corresponding
+    /// <see cref="IHtmlNode"/> object tree using the classes from
+    /// <c>WebExpress.WebCore.WebHtml</c>.
+    /// </summary>
+    /// <remarks>
+    /// The parser consumes the token stream produced by <see cref="HtmlTokenizer"/>
+    /// and builds a DOM-like hierarchy of <see cref="IHtmlNode"/> objects.  It is
+    /// deliberately tolerant: unknown tags are mapped to a generic
+    /// <see cref="HtmlElement"/>, and unclosed tags are automatically closed when
+    /// an end token for an ancestor is encountered (or when the token stream ends).
+    /// </remarks>
+    public class HtmlParser
+    {
+        // ------------------------------------------------------------------
+        // Public entry points
+        // ------------------------------------------------------------------
+
+        /// <summary>
+        /// Parses the supplied HTML string and returns the top-level nodes.
+        /// </summary>
+        /// <param name="html">The HTML string to parse.</param>
+        /// <returns>
+        /// A read-only list of <see cref="IHtmlNode"/> objects that form the
+        /// top-level content of the parsed document.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="html"/> is <c>null</c>.</exception>
+        /// <exception cref="HtmlParseException">Thrown when the HTML is so malformed that recovery is impossible.</exception>
+        public IReadOnlyList<IHtmlNode> Parse(string html)
+        {
+            if (html is null)
+            {
+                throw new ArgumentNullException(nameof(html));
+            }
+
+            var tokenizer = new HtmlTokenizer(html);
+            var tokens = tokenizer.Tokenize();
+            return ParseTokens(tokens);
+        }
+
+        /// <summary>
+        /// Parses the supplied HTML string and returns the single root node.
+        /// </summary>
+        /// <param name="html">The HTML string to parse.</param>
+        /// <returns>
+        /// The first top-level <see cref="IHtmlNode"/>, or <c>null</c> if the
+        /// input produces no nodes.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="html"/> is <c>null</c>.</exception>
+        public IHtmlNode ParseSingle(string html)
+        {
+            var nodes = Parse(html);
+            return nodes.Count > 0 ? nodes[0] : null;
+        }
+
+        // ------------------------------------------------------------------
+        // Core parsing logic
+        // ------------------------------------------------------------------
+
+        private IReadOnlyList<IHtmlNode> ParseTokens(IReadOnlyList<HtmlToken> tokens)
+        {
+            var index = 0;
+            var roots = new List<IHtmlNode>();
+
+            ParseNodes(tokens, ref index, null, roots);
+
+            return roots;
+        }
+
+        /// <summary>
+        /// Recursively consumes tokens and appends the resulting nodes to
+        /// <paramref name="target"/>.  Parsing stops when an end tag matching
+        /// <paramref name="parentTagName"/> is found or the stream ends.
+        /// </summary>
+        private void ParseNodes(
+            IReadOnlyList<HtmlToken> tokens,
+            ref int index,
+            string parentTagName,
+            List<IHtmlNode> target)
+        {
+            while (index < tokens.Count)
+            {
+                var token = tokens[index];
+
+                switch (token.Type)
+                {
+                    case HtmlTokenType.EndOfFile:
+                        return;
+
+                    case HtmlTokenType.Doctype:
+                        index++;
+                        // DOCTYPE tokens are informational; no node is emitted.
+                        break;
+
+                    case HtmlTokenType.Comment:
+                        index++;
+                        target.Add(new HtmlComment(token.Value));
+                        break;
+
+                    case HtmlTokenType.Text:
+                        index++;
+                        var textValue = token.Value;
+                        if (!string.IsNullOrEmpty(textValue))
+                        {
+                            target.Add(new HtmlText(textValue));
+                        }
+                        break;
+
+                    case HtmlTokenType.SelfClosingTag:
+                        index++;
+                        var selfClosing = HtmlElementFactory.Create(token.TagName);
+                        ApplyAttributes(selfClosing, token.Attributes);
+                        target.Add(selfClosing);
+                        break;
+
+                    case HtmlTokenType.StartTag:
+                        index++;
+                        var element = HtmlElementFactory.Create(token.TagName);
+                        ApplyAttributes(element, token.Attributes);
+
+                        if (element.CloseTag)
+                        {
+                            var children = new List<IHtmlNode>();
+                            ParseNodes(tokens, ref index, token.TagName, children);
+                            element.Add(children.ToArray());
+                        }
+
+                        target.Add(element);
+                        break;
+
+                    case HtmlTokenType.EndTag:
+                        if (string.Equals(token.TagName, parentTagName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            index++; // consume the matching end tag
+                        }
+                        // If it doesn't match our parent, stop and let the caller handle it.
+                        return;
+
+                    default:
+                        index++;
+                        break;
+                }
+            }
+        }
+
+        // ------------------------------------------------------------------
+        // Attribute mapping
+        // ------------------------------------------------------------------
+
+        private static void ApplyAttributes(HtmlElement element, IReadOnlyList<HtmlTokenAttribute> attributes)
+        {
+            if (attributes is null || attributes.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var attr in attributes)
+            {
+                if (attr.IsBoolean)
+                {
+                    element.AddUserAttribute(attr.Name);
+                }
+                else
+                {
+                    element.AddUserAttribute(attr.Name, attr.Value);
+                }
+            }
+        }
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlToken.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlToken.cs
new file mode 100644
index 0000000..ed21c05
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlToken.cs
@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Represents a single token produced by the <see cref="HtmlTokenizer"/>.
+    /// </summary>
+    public class HtmlToken
+    {
+        /// <summary>
+        /// Returns the type of this token.
+        /// </summary>
+        public HtmlTokenType Type { get; }
+
+        /// <summary>
+        /// Returns the tag name for start, end, and self-closing tokens, or the
+        /// doctype name for doctype tokens. Returns <c>null</c> for text, comment,
+        /// and end-of-file tokens.
+        /// </summary>
+        public string TagName { get; }
+
+        /// <summary>
+        /// Returns the raw text value for text and comment tokens. For start and
+        /// self-closing tokens this property is unused (<c>null</c>).
+        /// </summary>
+        public string Value { get; }
+
+        /// <summary>
+        /// Returns the attributes associated with start and self-closing tokens.
+        /// The key is the attribute name (lower-case) and the value is the
+        /// attribute value, or <c>null</c> for boolean (valueless) attributes.
+        /// </summary>
+        public IReadOnlyList<HtmlTokenAttribute> Attributes { get; }
+
+        /// <summary>
+        /// Initializes a new end-of-file token.
+        /// </summary>
+        public HtmlToken()
+        {
+            Type = HtmlTokenType.EndOfFile;
+            Attributes = [];
+        }
+
+        /// <summary>
+        /// Initializes a new text or comment token.
+        /// </summary>
+        /// <param name="type">The token type. Must be <see cref="HtmlTokenType.Text"/> or
+        /// <see cref="HtmlTokenType.Comment"/>.</param>
+        /// <param name="value">The raw text or comment content.</param>
+        public HtmlToken(HtmlTokenType type, string value)
+        {
+            Type = type;
+            Value = value;
+            Attributes = [];
+        }
+
+        /// <summary>
+        /// Initializes a new tag or doctype token.
+        /// </summary>
+        /// <param name="type">The token type.</param>
+        /// <param name="tagName">The tag or doctype name.</param>
+        /// <param name="attributes">The list of attributes. May be empty but must not be <c>null</c>.</param>
+        public HtmlToken(HtmlTokenType type, string tagName, IReadOnlyList<HtmlTokenAttribute> attributes)
+        {
+            Type = type;
+            TagName = tagName;
+            Attributes = attributes ?? [];
+        }
+
+        /// <summary>
+        /// Returns a human-readable description of this token for debugging purposes.
+        /// </summary>
+        public override string ToString() => Type switch
+        {
+            HtmlTokenType.StartTag => $"<{TagName}>",
+            HtmlTokenType.EndTag => $"</{TagName}>",
+            HtmlTokenType.SelfClosingTag => $"<{TagName}/>",
+            HtmlTokenType.Doctype => $"<!DOCTYPE {TagName}>",
+            HtmlTokenType.Text => $"\"{Value}\"",
+            HtmlTokenType.Comment => $"<!-- {Value} -->",
+            HtmlTokenType.EndOfFile => "<EOF>",
+            _ => base.ToString()
+        };
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenAttribute.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenAttribute.cs
new file mode 100644
index 0000000..04980e5
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenAttribute.cs
@@ -0,0 +1,51 @@
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Represents a single attribute within an HTML tag token.
+    /// </summary>
+    public class HtmlTokenAttribute
+    {
+        /// <summary>
+        /// Returns the attribute name (lower-cased).
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Returns the attribute value, or <c>null</c> if the attribute is boolean
+        /// (has no explicit value, e.g. <c>disabled</c>).
+        /// </summary>
+        public string Value { get; }
+
+        /// <summary>
+        /// Returns a value indicating whether this is a boolean (valueless) attribute.
+        /// </summary>
+        public bool IsBoolean => Value is null;
+
+        /// <summary>
+        /// Initializes a new valueless (boolean) attribute.
+        /// </summary>
+        /// <param name="name">The attribute name.</param>
+        public HtmlTokenAttribute(string name)
+        {
+            Name = name;
+            Value = null;
+        }
+
+        /// <summary>
+        /// Initializes a new attribute with a value.
+        /// </summary>
+        /// <param name="name">The attribute name.</param>
+        /// <param name="value">The attribute value.</param>
+        public HtmlTokenAttribute(string name, string value)
+        {
+            Name = name;
+            Value = value;
+        }
+
+        /// <summary>
+        /// Returns a human-readable description of this attribute for debugging purposes.
+        /// </summary>
+        public override string ToString() =>
+            IsBoolean ? Name : $"{Name}=\"{Value}\"";
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenType.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenType.cs
new file mode 100644
index 0000000..32a287a
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenType.cs
@@ -0,0 +1,43 @@
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Specifies the type of an HTML token produced by the tokenizer.
+    /// </summary>
+    public enum HtmlTokenType
+    {
+        /// <summary>
+        /// Represents a DOCTYPE declaration, e.g. <c>&lt;!DOCTYPE html&gt;</c>.
+        /// </summary>
+        Doctype,
+
+        /// <summary>
+        /// Represents an opening tag, e.g. <c>&lt;div class="foo"&gt;</c>.
+        /// </summary>
+        StartTag,
+
+        /// <summary>
+        /// Represents a closing tag, e.g. <c>&lt;/div&gt;</c>.
+        /// </summary>
+        EndTag,
+
+        /// <summary>
+        /// Represents a self-closing tag, e.g. <c>&lt;br/&gt;</c> or void elements like <c>&lt;img&gt;</c>.
+        /// </summary>
+        SelfClosingTag,
+
+        /// <summary>
+        /// Represents a text node.
+        /// </summary>
+        Text,
+
+        /// <summary>
+        /// Represents an HTML comment, e.g. <c>&lt;!-- remark --&gt;</c>.
+        /// </summary>
+        Comment,
+
+        /// <summary>
+        /// Represents the end of the token stream.
+        /// </summary>
+        EndOfFile
+    }
+}
diff --git a/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenizer.cs b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenizer.cs
new file mode 100644
index 0000000..b96e085
--- /dev/null
+++ b/src/WebExpress.WebCore/WebHtml/Parser/HtmlTokenizer.cs
@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WebExpress.WebCore.WebHtml.Parser
+{
+    /// <summary>
+    /// Breaks an HTML string into a flat sequence of <see cref="HtmlToken"/> objects.
+    /// </summary>
+    /// <remarks>
+    /// The tokenizer is deliberately lenient: it makes a best-effort attempt to
+    /// produce useful tokens even when the input HTML is malformed.  Recoverable
+    /// situations (e.g. an unclosed tag or an unquoted attribute value) are handled
+    /// silently; only situations that make further tokenization impossible result in a
+    /// <see cref="HtmlParseException"/>.
+    /// </remarks>
+    public class HtmlTokenizer
+    {
+        private readonly string _input;
+        private int _position;
+
+        /// <summary>
+        /// Returns the set of HTML void-element tag names that are always
+        /// treated as self-closing even when the input does not include a
+        /// trailing slash.
+        /// </summary>
+        private static readonly HashSet<string> VoidElements =
+            new(StringComparer.OrdinalIgnoreCase)
+            {
+                "area", "base", "br", "col", "embed", "hr", "img", "input",
+                "keygen", "link", "meta", "param", "source", "track", "wbr"
+            };
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HtmlTokenizer"/> class.
+        /// </summary>
+        /// <param name="input">The HTML string to tokenize.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="input"/> is <c>null</c>.</exception>
+        public HtmlTokenizer(string input)
+        {
+            _input = input ?? throw new ArgumentNullException(nameof(input));
+        }
+
+        /// <summary>
+        /// Tokenizes the entire input and returns all tokens, including a final
+        /// <see cref="HtmlTokenType.EndOfFile"/> token.
+        /// </summary>
+        /// <returns>A list of <see cref="HtmlToken"/> objects.</returns>
+        public IReadOnlyList<HtmlToken> Tokenize()
+        {
+            var tokens = new List<HtmlToken>();
+            _position = 0;
+
+            while (_position < _input.Length)
+            {
+                var token = ReadNextToken();
+                if (token != null)
+                {
+                    tokens.Add(token);
+                }
+            }
+
+            tokens.Add(new HtmlToken());
+            return tokens;
+        }
+
+        // ------------------------------------------------------------------
+        // Private helpers
+        // ------------------------------------------------------------------
+
+        private char Current => _position < _input.Length ? _input[_position] : '\0';
+        private char Peek(int offset = 1) => (_position + offset) < _input.Length ? _input[_position + offset] : '\0';
+
+        private HtmlToken ReadNextToken()
+        {
+            if (Current == '<')
+            {
+                return ReadTagOrSpecial();
+            }
+
+            return ReadText();
+        }
+
+        private HtmlToken ReadTagOrSpecial()
+        {
+            var start = _position;
+            _position++; // consume '<'
+
+            if (Current == '!')
+            {
+                return ReadBangToken(start);
+            }
+
+            if (Current == '/')
+            {
+                return ReadEndTag();
+            }
+
+            if (char.IsLetter(Current) || Current == '_')
+            {
+                return ReadStartTag();
+            }
+
+            // Anything else – treat the stray '<' as text.
+            return new HtmlToken(HtmlTokenType.Text, "<");
+        }
+
+        // Handles <!DOCTYPE ...> and <!-- ... -->
+        private HtmlToken ReadBangToken(int start)
+        {
+            _position++; // consume '!'
+
+            if (Current == '-' && Peek() == '-')
+            {
+                return ReadComment();
+            }
+
+            if (_input.IndexOf("DOCTYPE", _position, StringComparison.OrdinalIgnoreCase) == _position)
+            {
+                return ReadDoctype();
+            }
+
+            // Unknown bang construct – consume until '>' and emit as text.
+            var builder = new StringBuilder("<!");
+            while (_position < _input.Length && Current != '>')
+            {
+                builder.Append(Current);
+                _position++;
+            }
+            if (Current == '>')
+            {
+                builder.Append('>');
+                _position++;
+            }
+            return new HtmlToken(HtmlTokenType.Text, builder.ToString());
+        }
+
+        private HtmlToken ReadComment()
+        {
+            _position += 2; // consume '--'
+            var builder = new StringBuilder();
+
+            while (_position < _input.Length)
+            {
+                if (Current == '-' && Peek() == '-' && Peek(2) == '>')
+                {
+                    _position += 3; // consume '-->'
+                    break;
+                }
+                builder.Append(Current);
+                _position++;
+            }
+
+            return new HtmlToken(HtmlTokenType.Comment, builder.ToString().Trim());
+        }
+
+        private HtmlToken ReadDoctype()
+        {
+            _position += 7; // consume 'DOCTYPE'
+            SkipWhitespace();
+
+            var nameBuilder = new StringBuilder();
+            while (_position < _input.Length && Current != '>' && !char.IsWhiteSpace(Current))
+            {
+                nameBuilder.Append(Current);
+                _position++;
+            }
+
+            // Skip anything remaining until '>'
+            while (_position < _input.Length && Current != '>')
+            {
+                _position++;
+            }
+            if (Current == '>')
+            {
+                _position++;
+            }
+
+            return new HtmlToken(HtmlTokenType.Doctype, nameBuilder.ToString(), []);
+        }
+
+        private HtmlToken ReadEndTag()
+        {
+            _position++; // consume '/'
+            SkipWhitespace();
+
+            var tagName = ReadTagName();
+            SkipWhitespace();
+
+            // Consume closing '>'
+            if (Current == '>')
+            {
+                _position++;
+            }
+
+            return new HtmlToken(HtmlTokenType.EndTag, tagName.ToLowerInvariant(), []);
+        }
+
+        private HtmlToken ReadStartTag()
+        {
+            var tagName = ReadTagName().ToLowerInvariant();
+            var attributes = ReadAttributes();
+
+            var selfClose = false;
+            if (Current == '/')
+            {
+                selfClose = true;
+                _position++; // consume '/'
+            }
+
+            if (Current == '>')
+            {
+                _position++; // consume '>'
+            }
+
+            if (selfClose || VoidElements.Contains(tagName))
+            {
+                return new HtmlToken(HtmlTokenType.SelfClosingTag, tagName, attributes);
+            }
+
+            return new HtmlToken(HtmlTokenType.StartTag, tagName, attributes);
+        }
+
+        private string ReadTagName()
+        {
+            var builder = new StringBuilder();
+            while (_position < _input.Length && !char.IsWhiteSpace(Current) &&
+                   Current != '>' && Current != '/' && Current != '\0')
+            {
+                builder.Append(Current);
+                _position++;
+            }
+            return builder.ToString();
+        }
+
+        private IReadOnlyList<HtmlTokenAttribute> ReadAttributes()
+        {
+            var list = new List<HtmlTokenAttribute>();
+
+            while (_position < _input.Length)
+            {
+                SkipWhitespace();
+
+                if (Current == '>' || Current == '/' || Current == '\0')
+                {
+                    break;
+                }
+
+                var attr = ReadAttribute();
+                if (attr != null)
+                {
+                    list.Add(attr);
+                }
+            }
+
+            return list;
+        }
+
+        private HtmlTokenAttribute ReadAttribute()
+        {
+            var name = ReadAttributeName();
+            if (string.IsNullOrEmpty(name))
+            {
+                // Skip an unexpected character and continue.
+                if (_position < _input.Length)
+                {
+                    _position++;
+                }
+                return null;
+            }
+
+            SkipWhitespace();
+
+            if (Current != '=')
+            {
+                // Boolean attribute.
+                return new HtmlTokenAttribute(name.ToLowerInvariant());
+            }
+
+            _position++; // consume '='
+            SkipWhitespace();
+
+            var value = ReadAttributeValue();
+            return new HtmlTokenAttribute(name.ToLowerInvariant(), value);
+        }
+
+        private string ReadAttributeName()
+        {
+            var builder = new StringBuilder();
+            while (_position < _input.Length && Current != '=' && Current != '>' &&
+                   Current != '/' && !char.IsWhiteSpace(Current) && Current != '\0')
+            {
+                builder.Append(Current);
+                _position++;
+            }
+            return builder.ToString();
+        }
+
+        private string ReadAttributeValue()
+        {
+            if (Current == '"' || Current == '\'')
+            {
+                var quote = Current;
+                _position++; // consume opening quote
+                var builder = new StringBuilder();
+                while (_position < _input.Length && Current != quote)
+                {
+                    builder.Append(Current);
+                    _position++;
+                }
+                if (Current == quote)
+                {
+                    _position++; // consume closing quote
+                }
+                return builder.ToString();
+            }
+
+            // Unquoted value – read until whitespace or '>'.
+            var unquotedBuilder = new StringBuilder();
+            while (_position < _input.Length && !char.IsWhiteSpace(Current) &&
+                   Current != '>' && Current != '\0')
+            {
+                unquotedBuilder.Append(Current);
+                _position++;
+            }
+            return unquotedBuilder.ToString();
+        }
+
+        private HtmlToken ReadText()
+        {
+            var builder = new StringBuilder();
+            while (_position < _input.Length && Current != '<')
+            {
+                builder.Append(Current);
+                _position++;
+            }
+
+            var text = builder.ToString();
+            return text.Length > 0 ? new HtmlToken(HtmlTokenType.Text, text) : null;
+        }
+
+        private void SkipWhitespace()
+        {
+            while (_position < _input.Length && char.IsWhiteSpace(Current))
+            {
+                _position++;
+            }
+        }
+    }
+}