diff --git a/README.md b/README.md
index 2265d27..1bdd58a 100644
--- a/README.md
+++ b/README.md
@@ -42,9 +42,7 @@ T-strings work just like f-strings but use a `t` prefix and
 instead of strings.
 
 Once you have a `Template`, you can call this package's `html()` function to
-convert it into a tree of `Node` objects that represent your HTML structure.
-From there, you can render it to a string, manipulate it programmatically, or
-compose it with other templates for maximum flexibility.
+render it to a string.
 
 ### Getting Started
 
@@ -53,7 +51,6 @@ Import the `html` function and start creating templates:
 ```python
 from tdom import html
 greeting = html(t"<h1>Hello, World!</h1>")
-print(type(greeting))  # <class 'tdom.nodes.Element'>
 print(greeting)  # <h1>Hello, World!</h1>
 ```
 
@@ -145,7 +142,7 @@ classes:
 ```python
 classes = {"btn-primary": True, "btn-secondary": False}
 button = html(t'<button class="btn btn-secondary" class={classes}>Click me</button>')
-assert str(button) == '<button class="btn btn-primary">Click me</button>'
+assert button == '<button class="btn btn-primary">Click me</button>'
 ```
 
 #### The `style` Attribute
@@ -166,7 +163,7 @@ Style attributes can also be merged to extend a base style:
 ```python
 add_styles = {"font-weight": "bold"}
 para = html(t'<p style="color: red" style={add_styles}>Important text</p>')
-assert str(para) == '<p style="color: red; font-weight: bold">Important text</p>'
+assert para == '<p style="color: red; font-weight: bold">Important text</p>'
 ```
 
 #### The `data` and `aria` Attributes
@@ -332,11 +329,13 @@ content and attributes. Use these like custom HTML elements in your templates.
 The basic form of all component functions is:
 
 ```python
+from string.templatelib import Template
+
 from typing import Any, Iterable
-from tdom import Node, html
+from tdom import html
 
-def MyComponent(children: Iterable[Node], **attrs: Any) -> Node:
-    return html(t"<div {attrs}>Cool: {children}</div>")
+def MyComponent(children: Template, **attrs: Any) -> Template:
+    return t"<div {attrs}>Cool: {children}</div>"
 ```
 
 To _invoke_ your component within an HTML template, use the special
@@ -351,11 +350,13 @@ Because attributes are passed as keyword arguments, you can explicitly provide
 type hints for better editor support:
 
 ```python
+from string.templatelib import Template
+
 from typing import Any
-from tdom import Node, html
+from tdom import html
 
-def Link(*, href: str, text: str, data_value: int, **attrs: Any) -> Node:
-    return html(t'<a href="{href}" {attrs}>{text}: {data_value}</a>')
+def Link(*, href: str, text: str, data_value: int, **attrs: Any) -> Template:
+    return t'<a href="{href}" {attrs}>{text}: {data_value}</a>'
 
 result = html(t'<{Link} href="https://example.com" text="Example" data-value={42} target="_blank" />')
 # <a href="https://example.com" target="_blank">Example: 42</a>
@@ -380,23 +381,7 @@ def Greeting(name: str) -> Template:
     return t"<h1>Hello, {name}!</h1>"
 
 result = html(t"<{Greeting} name='Alice' />")
-assert str(result) == "<h1>Hello, Alice!</h1>"
-```
-
-You may also return an iterable:
-
-<!-- invisible-code-block: python
-from string.templatelib import Template
--->
-
-```python
-from typing import Iterable
-
-def Items() -> Iterable[Template]:
-    return [t"<li>first</li>", t"<li>second</li>"]
-
-result = html(t"<ul><{Items} /></ul>")
-assert str(result) == "<ul><li>first</li><li>second</li></ul>"
+assert result == "<h1>Hello, Alice!</h1>"
 ```
 
 #### Class-based components
@@ -410,24 +395,25 @@ One particularly useful pattern is to build class-based components with
 dataclasses:
 
 ```python
+from string.templatelib import Template
 from dataclasses import dataclass, field
 from typing import Any, Iterable
-from tdom import Node, html
+from tdom import html
 
 @dataclass
 class Card:
-    children: Iterable[Node]
+    children: Template
     title: str
     subtitle: str | None = None
 
-    def __call__(self) -> Node:
-        return html(t"""
+    def __call__(self) -> Template:
+        return t"""
             <div class='card'>
                 <h2>{self.title}</h2>
                 {self.subtitle and t'<h3>{self.subtitle}</h3>'}
                 <div class="content">{self.children}</div>
             </div>
-        """)
+        """
 
 result = html(t"<{Card} title='My Card' subtitle='A subtitle'><p>Card content</p></{Card}>")
 # <div class='card'>
@@ -452,7 +438,8 @@ syntax as HTML. You can create inline SVG graphics by simply including SVG tags
 in your templates:
 
 <!-- invisible-code-block: python
-from tdom import html, Node
+from string.templatelib import Template
+from tdom import html
 -->
 
 ```python
@@ -462,24 +449,24 @@ icon = html(t"""
         <path d="M12 6v6l4 2" stroke="currentColor" stroke-width="2"/>
     </svg>
 """)
-assert '<svg width="24" height="24"' in str(icon)
-assert '<circle cx="12" cy="12" r="10"' in str(icon)
+assert '<svg width="24" height="24"' in icon
+assert '<circle cx="12" cy="12" r="10"' in icon
 ```
 
 All the same interpolation, attribute handling, and component features work with
 SVG elements:
 
 ```python
-def Icon(*, size: int = 24, color: str = "currentColor") -> Node:
-    return html(t"""
+def Icon(*, size: int = 24, color: str = "currentColor") -> Template:
+    return t"""
         <svg width="{size}" height="{size}" viewBox="0 0 24 24" fill="none">
             <circle cx="12" cy="12" r="10" stroke="{color}" stroke-width="2"/>
         </svg>
-    """)
+    """
 
 result = html(t'<{Icon} size={48} color="blue" />')
-assert 'width="48"' in str(result)
-assert 'stroke="blue"' in str(result)
+assert 'width="48"' in result
+assert 'stroke="blue"' in result
 ```
 
 #### Context
@@ -497,14 +484,14 @@ options:
 ```python
 theme = {"primary": "blue", "spacing": "10px"}
 
-def Button(text: str) -> Node:
+def Button(text: str) -> Template:
     # Button has access to theme from enclosing scope
-    return html(t'<button style="color: {theme["primary"]}; margin: {theme["spacing"]}">{text}</button>')
+    return t'<button style="color: {theme["primary"]}; margin: {theme["spacing"]}">{text}</button>'
 
 result = html(t'<{Button} text="Click me" />')
-assert 'color: blue' in str(result)
-assert 'margin: 10px' in str(result)
-assert '>Click me</button>' in str(result)
+assert 'color: blue' in result
+assert 'margin: 10px' in result
+assert '>Click me</button>' in result
 ```
 
 3. **Use module-level or global state**: For truly application-wide
@@ -518,41 +505,6 @@ This explicit approach makes it clear where data comes from and avoids the
 
 ### The `tdom` Module
 
-#### Working with `Node` Objects
-
-While `html()` is the primary way to create nodes, you can also construct them
-directly for programmatic HTML generation:
-
-```python
-from tdom import Element, Text, Fragment, Comment, DocumentType
-
-# Create elements directly
-div = Element("div", attrs={"class": "container"}, children=[
-    Text("Hello, "),
-    Element("strong", children=[Text("World")]),
-])
-assert str(div) == '<div class="container">Hello, <strong>World</strong></div>'
-
-# Create fragments to group multiple nodes
-fragment = Fragment(children=[
-    Element("h1", children=[Text("Title")]),
-    Element("p", children=[Text("Paragraph")]),
-])
-assert str(fragment) == "<h1>Title</h1><p>Paragraph</p>"
-
-# Add comments
-page = Element("body", children=[
-    Comment("Navigation section"),
-    Element("nav", children=[Text("Nav content")]),
-])
-assert str(page) == "<body><!--Navigation section--><nav>Nav content</nav></body>"
-```
-
-All nodes implement the `__html__()` protocol, which means they can be used
-anywhere that expects an object with HTML representation. Converting a node to a
-string (via `str()` or `print()`) automatically renders it as HTML with proper
-escaping.
-
 #### Utilities
 
 The `tdom` package includes several utility functions for working with
diff --git a/docs/usage/components.md b/docs/usage/components.md
index cc341d4..5e7f04d 100644
--- a/docs/usage/components.md
+++ b/docs/usage/components.md
@@ -25,11 +25,11 @@ function with normal Python arguments and return values.
 ## Simple Heading
 
 Here is a component callable &mdash; a `Heading` function &mdash; which returns
-a `Node`:
+a `Template`:
 
 <!-- invisible-code-block: python
 from string.templatelib import Template
-from tdom import html, Node
+from tdom import html
 from typing import Callable, Iterable
 -->
 
@@ -39,7 +39,7 @@ def Heading() -> Template:
 
 
 result = html(t"<{Heading} />")
-assert str(result) == '<h1>My Title</h1>'
+assert result == '<h1>My Title</h1>'
 ```
 
 ## Simple Props
@@ -54,7 +54,7 @@ def Heading(title: str) -> Template:
 
 
 result = html(t'<{Heading} title="My Title"></{Heading}>')
-assert str(result) == '<h1>My Title</h1>'
+assert result == '<h1>My Title</h1>'
 ```
 
 ## Children As Props
@@ -63,32 +63,29 @@ If your template has children inside the component element, your component will
 receive them as a keyword argument:
 
 ```python
-def Heading(children: Iterable[Node], title: str) -> Node:
-  return html(t"<h1>{title}</h1><div>{children}</div>")
+def Heading(children: Template, title: str) -> Template:
+  return t"<h1>{title}</h1><div>{children}</div>"
 
 
 result = html(t'<{Heading} title="My Title">Child</{Heading}>')
-assert str(result) == '<h1>My Title</h1><div>Child</div>'
+assert result == '<h1>My Title</h1><div>Child</div>'
 ```
 
 Note how the component closes with `</{Heading}>` when it contains nested
 children, as opposed to the self-closing form in the first example. If no
 children are provided, the value of children is an empty tuple.
 
-Note also that components functions can return `Node` or `Template` values as
-they wish. Iterables of nodes and templates are also supported.
-
 The component does not have to list a `children` keyword argument. If it is
 omitted from the function parameters and passed in by the usage, it is silently
 ignored:
 
 ```python
-def Heading(title: str) -> Node:
-  return html(t"<h1>{title}</h1><div>Ignore the children.</div>")
+def Heading(title: str) -> Template:
+  return t"<h1>{title}</h1><div>Ignore the children.</div>"
 
 
 result = html(t'<{Heading} title="My Title">Child</{Heading}>')
-assert str(result) == '<h1>My Title</h1><div>Ignore the children.</div>'
+assert result == '<h1>My Title</h1><div>Ignore the children.</div>'
 ```
 
 ## Optional Props
@@ -102,7 +99,7 @@ def Heading(title: str = "My Title") -> Template:
 
 
 result = html(t"<{Heading} />")
-assert str(result) == '<h1>My Title</h1>'
+assert result == '<h1>My Title</h1>'
 ```
 
 ## Passsing Another Component as a Prop
@@ -121,7 +118,7 @@ def Body(heading: Callable) -> Template:
 
 
 result = html(t"<{Body} heading={DefaultHeading} />")
-assert str(result) == '<body><h1>Default Heading</h1></body>'
+assert result == '<body><h1>Default Heading</h1></body>'
 ```
 
 ## Default Component for Prop
@@ -139,11 +136,11 @@ def OtherHeading() -> Template:
 
 
 def Body(heading: Callable) -> Template:
-  return html(t"<body><{heading} /></body>")
+  return t"<body><{heading} /></body>"
 
 
 result = html(t"<{Body} heading={OtherHeading}></{Body}>")
-assert str(result) == '<body><h1>Other Heading</h1></body>'
+assert result == '<body><h1>Other Heading</h1></body>'
 ```
 
 ## Conditional Default
@@ -165,23 +162,7 @@ def Body(heading: Callable | None = None) -> Template:
 
 
 result = html(t"<{Body} heading={OtherHeading}></{Body}>")
-assert str(result) == '<body><h1>Other Heading</h1></body>'
-```
-
-## Generators as Components
-
-You can also have components that act as generators. For example, imagine you
-have a todo list. There might be a lot of todos, so you want to generate them in
-a memory-efficient way:
-
-```python
-def Todos() -> Iterable[Template]:
-  for todo in ["first", "second", "third"]:
-    yield t"<li>{todo}</li>"
-
-
-result = html(t"<ul><{Todos} /></ul>")
-assert str(result) == '<ul><li>first</li><li>second</li><li>third</li></ul>'
+assert result == '<body><h1>Other Heading</h1></body>'
 ```
 
 ## Nested Components
@@ -200,5 +181,5 @@ def TodoList(labels: Iterable[str]) -> Template:
 title = "My Todos"
 labels = ["first", "second", "third"]
 result = html(t"<h1>{title}</h1><{TodoList} labels={labels} />")
-assert str(result) == '<h1>My Todos</h1><ul><li>first</li><li>second</li><li>third</li></ul>'
+assert result == '<h1>My Todos</h1><ul><li>first</li><li>second</li><li>third</li></ul>'
 ```
diff --git a/docs/usage/looping.md b/docs/usage/looping.md
index 5b9b80b..ae91c36 100644
--- a/docs/usage/looping.md
+++ b/docs/usage/looping.md
@@ -25,7 +25,7 @@ result = html(
         </ul>
     """
 )
-assert str(result) == """
+assert result == """
         <ul title="Hello">
             <li>World</li><li>Universe</li>
         </ul>
@@ -35,12 +35,12 @@ assert str(result) == """
 ## Rendered Looping
 
 You could also move the generation of the items out of the "parent" template,
-then use that `Node` result in the next template:
+then use that result in the next template:
 
 ```python
 message = "Hello"
 names = ["World", "Universe"]
-items = [html(t"<li>{label}</li>") for label in names]
+items = [t"<li>{label}</li>" for label in names]
 result = html(t"<ul title={message}>{items}</ul>")
-assert str(result) == '<ul title="Hello"><li>World</li><li>Universe</li></ul>'
+assert result == '<ul title="Hello"><li>World</li><li>Universe</li></ul>'
 ```
diff --git a/docs/usage/static_string.md b/docs/usage/static_string.md
index 4f869d3..9237677 100644
--- a/docs/usage/static_string.md
+++ b/docs/usage/static_string.md
@@ -8,19 +8,18 @@ Let's start with the simplest form of templating: just a string, no tags, no
 attributes:
 
 <!-- invisible-code-block: python
-from tdom import html, Element, Text
+from tdom import html
 -->
 
 ```python
 result = html(t"Hello World")
-assert str(result) == 'Hello World'
+assert result == 'Hello World'
 ```
 
 We start by importing the `html` function from `tdom`.
 
 It takes a [Python 3.14 t-string](https://t-strings.help/introduction.html) and
-returns a `Element` with an `__str__` that converts to HTML. In this case, the
-node is an instance of `tdom.nodes.Text`, a subclass of `Element`.
+returns a `str()`.
 
 ## Simple Render
 
@@ -29,32 +28,9 @@ but done in one step:
 
 ```python
 result = html(t"<div>Hello World</div>")
-assert str(result) == '<div>Hello World</div>'
+assert result == '<div>Hello World</div>'
 ```
 
-## Show the `Element` Itself
-
-Let's take a look at that `Element` structure.
-
-This time, we'll inspect the returned value rather than rendering it to a
-string:
-
-```python
-result = html(t'<div class="container">Hello World</div>')
-assert result == Element(
-    "div",
-    attrs={"class": "container"},
-    children=[Text("Hello World")]
-)
-```
-
-In our test we see that we got back an `Element`. What does it look like?
-
-- The `result` is of type `tdom.nodes.Element` (a subclass of `Node`)
-- The name of the node (`<div>`)
-- The properties passed to that tag (in this case, `{"class": "container"}`)
-- The children of this tag (in this case, a `Text` node of `Hello World`)
-
 ## Interpolations as Attribute Values
 
 We can go one step further with this and use interpolations from PEP 750
@@ -64,36 +40,13 @@ braces:
 ```python
 my_class = "active"
 result = html(t'<div class={my_class}>Hello World</div>')
-assert str(result) == '<div class="active">Hello World</div>'
+assert result == '<div class="active">Hello World</div>'
 ```
 
 TODO: describe all the many many ways to express attribute values, including
 `tdom`'s special handling of boolean attributes, whole-tag spreads, `class`,
 `style`, `data` and `aria` attributes, etc.
 
-## Child Nodes in an `Element`
-
-Let's look at what more nesting would look like:
-
-```python
-result = html(t"<div>Hello <span>World<em>!</em></span></div>")
-assert result == Element(
-    "div",
-    children=[
-        Text("Hello "),
-        Element(
-            "span",
-            children=[
-                Text("World"),
-                Element("em", children=[Text("!")])
-            ]
-        )
-    ]
-)
-```
-
-It's a nested Python datastructure -- pretty simple to look at.
-
 ## Expressing the Document Type
 
 One last point: the HTML doctype can be a tricky one to get into the template.
@@ -101,7 +54,7 @@ In `tdom` this is straightforward:
 
 ```python
 result = html(t"<!DOCTYPE html><div>Hello World</div>")
-assert str(result) == '<!DOCTYPE html><div>Hello World</div>'
+assert result == '<!DOCTYPE html><div>Hello World</div>'
 ```
 
 ## Reducing Boolean Attribute Values
@@ -112,5 +65,5 @@ without a _value_:
 
 ```python
 result = html(t"<div editable={True}>Hello World</div>")
-assert str(result) == '<div editable>Hello World</div>'
+assert result == '<div editable>Hello World</div>'
 ```
diff --git a/tdom/__init__.py b/tdom/__init__.py
index a180b51..8679eae 100644
--- a/tdom/__init__.py
+++ b/tdom/__init__.py
@@ -1,18 +1,11 @@
 from markupsafe import Markup, escape
 
-from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
 from .processor import html, svg
 
 # We consider `Markup` and `escape` to be part of this module's public API
 
 __all__ = [
-    "Comment",
-    "DocumentType",
-    "Element",
-    "Fragment",
     "Markup",
-    "Node",
-    "Text",
     "escape",
     "html",
     "svg",
diff --git a/tdom/escaping.py b/tdom/escaping.py
index d23ce65..6b6c1ff 100644
--- a/tdom/escaping.py
+++ b/tdom/escaping.py
@@ -2,6 +2,8 @@
 
 from markupsafe import escape as markup_escape
 
+from .protocols import HasHTMLDunder
+
 escape_html_text = markup_escape  # unify api for test of project
 
 
@@ -9,10 +11,19 @@
 LT = "&lt;"
 
 
-def escape_html_comment(text: str) -> str:
+def escape_html_comment(text: str, allow_markup: bool = False) -> str:
     """Escape text injected into an HTML comment."""
     if not text:
         return text
+    if allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
+
+    if not allow_markup and type(text) is not str:
+        # String manipulation triggers regular html escapes on Markup
+        # so we coerce the subclass of `str` into a true `str` before
+        # we start string manipulating.
+        text = str(text)
+
     # - text must not start with the string ">"
     if text[0] == ">":
         text = GT + text[1:]
@@ -44,8 +55,10 @@ def escape_html_comment(text: str) -> str:
 )
 
 
-def escape_html_style(text: str) -> str:
+def escape_html_style(text: str, allow_markup: bool = False) -> str:
     """Escape text injected into an HTML style element."""
+    if allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
     for matche_re, replace_text in STYLE_RES:
         text = re.sub(matche_re, replace_text, text)
     return text
@@ -70,7 +83,7 @@ def escape_html_style(text: str) -> str:
 )
 
 
-def escape_html_script(text: str) -> str:
+def escape_html_script(text: str, allow_markup: bool = False) -> str:
     """
     Escape text injected into an HTML script element.
 
@@ -83,6 +96,8 @@ def escape_html_script(text: str) -> str:
     - "<script" as "\x3cscript"
     - "</script" as "\x3c/script"`
     """
+    if allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
     for match_re, replace_text in SCRIPT_RES:
         text = re.sub(match_re, replace_text, text)
     return text
diff --git a/tdom/escaping_test.py b/tdom/escaping_test.py
index a6f18cb..a74f8f2 100644
--- a/tdom/escaping_test.py
+++ b/tdom/escaping_test.py
@@ -1,4 +1,15 @@
-from .escaping import escape_html_comment, escape_html_script, escape_html_style
+from markupsafe import Markup
+
+from .escaping import (
+    escape_html_comment,
+    escape_html_script,
+    escape_html_style,
+    escape_html_text,
+)
+
+
+def test_escape_html_text() -> None:
+    assert escape_html_text("<div>") == "&lt;div&gt;"
 
 
 def test_escape_html_comment_empty() -> None:
@@ -27,6 +38,15 @@ def test_escape_html_comment_ends_with_lt_dash() -> None:
     assert escape_html_comment("This is a comment<!-") == "This is a comment&lt;!-"
 
 
+def test_escape_html_comment_markup() -> None:
+    input_text = "-->"
+    escaped_text = "--&gt;"
+    out = escape_html_comment(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_comment(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text
+
+
 def test_escape_html_style() -> None:
     input_text = "body { color: red; }</style> p { font-SIZE: 12px; }</STYLE>"
     expected_output = (
@@ -35,6 +55,15 @@ def test_escape_html_style() -> None:
     assert escape_html_style(input_text) == expected_output
 
 
+def test_escape_html_style_markup() -> None:
+    input_text = "</STYLE>"
+    escaped_text = "&lt;/STYLE>"
+    out = escape_html_style(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_style(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text
+
+
 def test_escape_html_script() -> None:
     input_text = "<!-- <script>var a = 1;</script> </SCRIPT>"
     expected_output = "\\x3c!-- \\x3cscript>var a = 1;\\x3c/script> \\x3c/SCRIPT>"
@@ -42,3 +71,12 @@ def test_escape_html_script() -> None:
     # Smoketest that escaping is working and we are not just escaping back to the same value.
     for text in ("<script", "</script", "<!--"):
         assert escape_html_script(text) != text
+
+
+def test_escape_html_script_markup() -> None:
+    input_text = "<script>"
+    escaped_text = "\\x3cscript>"
+    out = escape_html_script(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_script(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text
diff --git a/tdom/htmlspec.py b/tdom/htmlspec.py
index 11f9fa3..941dfb2 100644
--- a/tdom/htmlspec.py
+++ b/tdom/htmlspec.py
@@ -23,7 +23,6 @@
 RCDATA_CONTENT_ELEMENTS = frozenset(["textarea", "title"])
 CONTENT_ELEMENTS = CDATA_CONTENT_ELEMENTS | RCDATA_CONTENT_ELEMENTS
 
-
 SVG_TAG_FIX = {
     "altglyph": "altGlyph",
     "altglyphdef": "altGlyphDef",
@@ -125,3 +124,8 @@
     "ychannelselector": "yChannelSelector",
     "zoomandpan": "zoomAndPan",
 }
+
+
+# Used for fragments that do not have a tag
+# to assume that text is inside this element.
+DEFAULT_NORMAL_TEXT_ELEMENT = "div"
diff --git a/tdom/nodes.py b/tdom/nodes.py
deleted file mode 100644
index 76086ff..0000000
--- a/tdom/nodes.py
+++ /dev/null
@@ -1,118 +0,0 @@
-from dataclasses import dataclass, field
-
-from .escaping import (
-    escape_html_comment,
-    escape_html_script,
-    escape_html_style,
-    escape_html_text,
-)
-from .htmlspec import CONTENT_ELEMENTS, VOID_ELEMENTS
-
-# FUTURE: add a pretty-printer to nodes for debugging
-# FUTURE: make nodes frozen (and have the parser work with mutable builders)
-
-
-@dataclass(slots=True)
-class Node:
-    def __html__(self) -> str:
-        """Return the HTML representation of the node."""
-        # By default, just return the string representation
-        return str(self)
-
-
-@dataclass(slots=True)
-class Text(Node):
-    text: str  # which may be markupsafe.Markup in practice.
-
-    def __str__(self) -> str:
-        # Use markupsafe's escape to handle HTML escaping
-        return escape_html_text(self.text)
-
-    def __eq__(self, other: object) -> bool:
-        # This is primarily of use for testing purposes. We only consider
-        # two Text nodes equal if their string representations match.
-        return isinstance(other, Text) and str(self) == str(other)
-
-
-@dataclass(slots=True)
-class Fragment(Node):
-    children: list[Node] = field(default_factory=list)
-
-    def __str__(self) -> str:
-        return "".join(str(child) for child in self.children)
-
-
-@dataclass(slots=True)
-class Comment(Node):
-    text: str
-
-    def __str__(self) -> str:
-        return f"<!--{escape_html_comment(self.text)}-->"
-
-
-@dataclass(slots=True)
-class DocumentType(Node):
-    text: str = "html"
-
-    def __str__(self) -> str:
-        return f"<!DOCTYPE {self.text}>"
-
-
-@dataclass(slots=True)
-class Element(Node):
-    tag: str
-    attrs: dict[str, str | None] = field(default_factory=dict)
-    children: list[Node] = field(default_factory=list)
-
-    def __post_init__(self):
-        """Ensure all preconditions are met."""
-        if not self.tag:
-            raise ValueError("Element tag cannot be empty.")
-
-        # Void elements cannot have children
-        if self.is_void and self.children:
-            raise ValueError(f"Void element <{self.tag}> cannot have children.")
-
-    @property
-    def is_void(self) -> bool:
-        return self.tag in VOID_ELEMENTS
-
-    @property
-    def is_content(self) -> bool:
-        return self.tag in CONTENT_ELEMENTS
-
-    def _children_to_str(self):
-        if not self.children:
-            return ""
-        if self.tag in ("script", "style"):
-            chunks = []
-            for child in self.children:
-                if isinstance(child, Text):
-                    chunks.append(child.text)
-                else:
-                    raise TypeError(
-                        "Cannot serialize non-text content inside a script tag."
-                    )
-            raw_children_str = "".join(chunks)
-            if self.tag == "script":
-                return escape_html_script(raw_children_str)
-            elif self.tag == "style":
-                return escape_html_style(raw_children_str)
-            else:
-                raise ValueError("Unsupported tag for single-level bulk escaping.")
-        else:
-            return "".join(str(child) for child in self.children)
-
-    def __str__(self) -> str:
-        # We use markupsafe's escape to handle HTML escaping of attribute values
-        # which means it's possible to mark them as safe if needed.
-        attrs_str = "".join(
-            f" {key}" if value is None else f' {key}="{escape_html_text(value)}"'
-            for key, value in self.attrs.items()
-        )
-        if self.is_void:
-            return f"<{self.tag}{attrs_str} />"
-        if not self.children:
-            return f"<{self.tag}{attrs_str}></{self.tag}>"
-        children_str = self._children_to_str()
-        return f"<{self.tag}{attrs_str}>{children_str}</{self.tag}>"
diff --git a/tdom/nodes_test.py b/tdom/nodes_test.py
deleted file mode 100644
index ab57c9e..0000000
--- a/tdom/nodes_test.py
+++ /dev/null
@@ -1,244 +0,0 @@
-import pytest
-from markupsafe import Markup
-
-from .nodes import Comment, DocumentType, Element, Fragment, Text
-
-
-def test_comment():
-    comment = Comment("This is a comment")
-    assert str(comment) == "<!--This is a comment-->"
-
-
-def test_comment_empty():
-    comment = Comment("")
-    assert str(comment) == "<!---->"
-
-
-def test_comment_special_chars():
-    comment = Comment("Special chars: <>&\"'")
-    assert str(comment) == "<!--Special chars: <>&\"'-->"
-
-
-def test_doctype_default():
-    doctype = DocumentType()
-    assert str(doctype) == "<!DOCTYPE html>"
-
-
-def test_doctype_custom():
-    doctype = DocumentType("xml")
-    assert str(doctype) == "<!DOCTYPE xml>"
-
-
-def test_text():
-    text = Text("Hello, world!")
-    assert str(text) == "Hello, world!"
-
-
-def test_text_escaping():
-    text = Text("<script>alert('XSS')</script>")
-    assert str(text) == "&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;"
-
-
-def test_text_safe():
-    class CustomHTML(str):
-        def __html__(self) -> str:
-            return "<b>Bold Text</b>"
-
-    text = Text(CustomHTML())
-    assert str(text) == "<b>Bold Text</b>"
-
-
-def test_text_equality():
-    text1 = Text("<Hello>")
-    text2 = Text(Markup("&lt;Hello&gt;"))
-    text3 = Text(Markup("<Hello>"))
-    assert text1 == text2
-    assert text1 != text3
-
-
-def test_fragment_empty():
-    fragment = Fragment()
-    assert str(fragment) == ""
-
-
-def test_fragment_with_text():
-    fragment = Fragment(children=[Text("test")])
-    assert str(fragment) == "test"
-
-
-def test_fragment_with_multiple_texts():
-    fragment = Fragment(children=[Text("Hello"), Text(" "), Text("World")])
-    assert str(fragment) == "Hello World"
-
-
-def test_element_no_children():
-    div = Element("div")
-    assert not div.is_void
-    assert str(div) == "<div></div>"
-
-
-def test_void_element_no_children():
-    br = Element("br")
-    assert br.is_void
-    assert str(br) == "<br />"
-
-
-def test_element_invalid_empty_tag():
-    with pytest.raises(ValueError):
-        _ = Element("")
-
-
-def test_element_is_content():
-    assert Element("script").is_content
-    assert Element("title").is_content
-    assert not Element("div").is_content
-    assert not Element("br").is_content  # Void element
-
-
-def test_void_element_with_attributes():
-    br = Element("br", attrs={"class": "line-break", "hidden": None})
-    assert str(br) == '<br class="line-break" hidden />'
-
-
-def test_void_element_with_children():
-    with pytest.raises(ValueError):
-        _ = Element("br", children=[Text("should not be here")])
-
-
-def test_standard_element_with_attributes():
-    div = Element(
-        "div",
-        attrs={"id": "main", "data-role": "container", "hidden": None},
-    )
-    assert str(div) == '<div id="main" data-role="container" hidden></div>'
-
-
-def test_standard_element_with_text_child():
-    div = Element("div", children=[Text("Hello, world!")])
-    assert str(div) == "<div>Hello, world!</div>"
-
-
-def test_standard_element_with_element_children():
-    div = Element(
-        "div",
-        children=[
-            Element("h1", children=[Text("Title")]),
-            Element("p", children=[Text("This is a paragraph.")]),
-        ],
-    )
-    assert str(div) == "<div><h1>Title</h1><p>This is a paragraph.</p></div>"
-
-
-def test_element_with_fragment_with_children():
-    div = Element(
-        "div",
-        children=[
-            Fragment(
-                children=[
-                    Element("div", children=[Text("wow")]),
-                    Text("inside fragment"),
-                ]
-            )
-        ],
-    )
-    assert str(div) == "<div><div>wow</div>inside fragment</div>"
-
-
-def test_standard_element_with_mixed_children():
-    div = Element(
-        "div",
-        children=[
-            Text("Intro text."),
-            Element("h1", children=[Text("Title")]),
-            Text("Some more text."),
-            Element("hr"),
-            Element("p", children=[Text("This is a paragraph.")]),
-        ],
-    )
-    assert str(div) == (
-        "<div>Intro text.<h1>Title</h1>Some more text.<hr /><p>This is a paragraph.</p></div>"
-    )
-
-
-def test_complex_tree():
-    html = Fragment(
-        children=[
-            DocumentType(),
-            Element(
-                "html",
-                children=[
-                    Element(
-                        "head",
-                        children=[
-                            Element("title", children=[Text("Test Page")]),
-                            Element("meta", attrs={"charset": "UTF-8"}),
-                        ],
-                    ),
-                    Element(
-                        "body",
-                        attrs={"class": "main-body"},
-                        children=[
-                            Element("h1", children=[Text("Welcome to the Test Page")]),
-                            Element(
-                                "p",
-                                children=[
-                                    Text("This is a sample paragraph with "),
-                                    Element("strong", children=[Text("bold text")]),
-                                    Text(" and "),
-                                    Element("em", children=[Text("italic text")]),
-                                    Text("."),
-                                ],
-                            ),
-                            Element("br"),
-                            Element(
-                                "ul",
-                                children=[
-                                    Element("li", children=[Text("Item 1")]),
-                                    Element("li", children=[Text("Item 2")]),
-                                    Element("li", children=[Text("Item 3")]),
-                                ],
-                            ),
-                        ],
-                    ),
-                ],
-            ),
-        ]
-    )
-    assert str(html) == (
-        "<!DOCTYPE html><html><head><title>Test Page</title>"
-        '<meta charset="UTF-8" /></head><body class="main-body">'
-        "<h1>Welcome to the Test Page</h1>"
-        "<p>This is a sample paragraph with <strong>bold text</strong> and "
-        "<em>italic text</em>.</p><br /><ul><li>Item 1</li><li>Item 2</li>"
-        "<li>Item 3</li></ul></body></html>"
-    )
-
-
-def test_dunder_html_method():
-    div = Element("div", children=[Text("Hello")])
-    assert div.__html__() == str(div)
-
-
-def test_escaping_of_text_content():
-    div = Element("div", children=[Text("<script>alert('XSS')</script>")])
-    assert str(div) == "<div>&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;</div>"
-
-
-def test_escaping_of_attribute_values():
-    div = Element("div", attrs={"class": '">XSS<'})
-    assert str(div) == '<div class="&#34;&gt;XSS&lt;"></div>'
-
-
-def test_svg_rendering():
-    svg = Element(
-        "svg",
-        attrs={"viewBox": "0 0 10 10"},
-        children=[
-            Element("clipPath", attrs={"id": "clip"}),
-            Element("rect", attrs={"x": "0", "y": "0", "width": "10", "height": "10"}),
-        ],
-    )
-    assert (
-        str(svg)
-        == '<svg viewBox="0 0 10 10"><clipPath id="clip"></clipPath><rect x="0" y="0" width="10" height="10"></rect></svg>'
-    )
diff --git a/tdom/parser.py b/tdom/parser.py
index e1fc743..5ac501b 100644
--- a/tdom/parser.py
+++ b/tdom/parser.py
@@ -3,7 +3,7 @@
 from html.parser import HTMLParser
 from string.templatelib import Interpolation, Template
 
-from .htmlspec import SVG_ATTR_FIX, SVG_TAG_FIX, VOID_ELEMENTS
+from .htmlspec import VOID_ELEMENTS
 from .placeholders import PlaceholderState
 from .template_utils import combine_template_refs
 from .tnodes import (
@@ -86,10 +86,8 @@ class TemplateParser(HTMLParser):
     stack: list[OpenTag]
     placeholders: PlaceholderState
     source: SourceTracker | None
-    _svg_depth: int = 0
 
-    def __init__(self, *, convert_charrefs: bool = True, svg_context: bool = False):
-        self._initial_svg_depth = 1 if svg_context else 0
+    def __init__(self, *, convert_charrefs: bool = True):
         # This calls HTMLParser.reset() which we override to set up our state.
         super().__init__(convert_charrefs=convert_charrefs)
 
@@ -109,12 +107,10 @@ def append_child(self, child: TNode) -> None:
     # Attribute Helpers
     # ------------------------------------------
 
-    def make_tattr(self, attr: HTMLAttribute, svg_context: bool = False) -> TAttribute:
+    def make_tattr(self, attr: HTMLAttribute) -> TAttribute:
         """Build a TAttribute from a raw attribute tuple."""
 
         name, value = attr
-        if svg_context:
-            name = SVG_ATTR_FIX.get(name, name)
 
         name_ref = self.placeholders.remove_placeholders(name)
         value_ref = (
@@ -140,24 +136,20 @@ def make_tattr(self, attr: HTMLAttribute, svg_context: bool = False) -> TAttribu
             )
         return TSpreadAttribute(i_index=name_ref.i_indexes[0])
 
-    def make_tattrs(
-        self, attrs: Sequence[HTMLAttribute], svg_context: bool = False
-    ) -> tuple[TAttribute, ...]:
+    def make_tattrs(self, attrs: Sequence[HTMLAttribute]) -> tuple[TAttribute, ...]:
         """Build TAttributes from raw attribute tuples."""
-        return tuple(self.make_tattr(attr, svg_context) for attr in attrs)
+        return tuple(self.make_tattr(attr) for attr in attrs)
 
     # ------------------------------------------
     # Tag Helpers
     # ------------------------------------------
 
-    def make_open_tag(
-        self, tag: str, attrs: Sequence[HTMLAttribute], svg_context: bool = False
-    ) -> OpenTag:
+    def make_open_tag(self, tag: str, attrs: Sequence[HTMLAttribute]) -> OpenTag:
         """Build an OpenTag from a raw tag and attribute tuples."""
         tag_ref = self.placeholders.remove_placeholders(tag)
 
         if tag_ref.is_literal:
-            return OpenTElement(tag=tag, attrs=self.make_tattrs(attrs, svg_context))
+            return OpenTElement(tag=tag, attrs=self.make_tattrs(attrs))
 
         if not tag_ref.is_singleton:
             raise ValueError(
@@ -170,7 +162,7 @@ def make_open_tag(
         i_index = tag_ref.i_indexes[0]
         return OpenTComponent(
             start_i_index=i_index,
-            attrs=self.make_tattrs(attrs, svg_context),
+            attrs=self.make_tattrs(attrs),
         )
 
     def finalize_tag(
@@ -233,13 +225,7 @@ def validate_end_tag(self, tag: str, open_tag: OpenTag) -> int | None:
     # ------------------------------------------
 
     def handle_starttag(self, tag: str, attrs: Sequence[HTMLAttribute]) -> None:
-        if tag == "svg":
-            self._svg_depth += 1
-
-        if self._svg_depth > 0:
-            tag = SVG_TAG_FIX.get(tag, tag)
-
-        open_tag = self.make_open_tag(tag, attrs, svg_context=(self._svg_depth > 0))
+        open_tag = self.make_open_tag(tag, attrs)
         if isinstance(open_tag, OpenTElement) and open_tag.tag in VOID_ELEMENTS:
             final_tag = self.finalize_tag(open_tag)
             self.append_child(final_tag)
@@ -248,13 +234,7 @@ def handle_starttag(self, tag: str, attrs: Sequence[HTMLAttribute]) -> None:
 
     def handle_startendtag(self, tag: str, attrs: Sequence[HTMLAttribute]) -> None:
         """Dispatch a self-closing tag, `<tag />` to specialized handlers."""
-        is_svg_tag = tag == "svg"
-        effective_svg_context = (self._svg_depth > 0) or is_svg_tag
-
-        if effective_svg_context:
-            tag = SVG_TAG_FIX.get(tag, tag)
-
-        open_tag = self.make_open_tag(tag, attrs, svg_context=effective_svg_context)
+        open_tag = self.make_open_tag(tag, attrs)
         final_tag = self.finalize_tag(open_tag)
         self.append_child(final_tag)
 
@@ -262,12 +242,6 @@ def handle_endtag(self, tag: str) -> None:
         if not self.stack:
             raise ValueError(f"Unexpected closing tag </{tag}> with no open tag.")
 
-        if self._svg_depth > 0:
-            tag = SVG_TAG_FIX.get(tag, tag)
-
-        if tag == "svg":
-            self._svg_depth -= 1
-
         open_tag = self.stack.pop()
         endtag_i_index = self.validate_end_tag(tag, open_tag)
         final_tag = self.finalize_tag(open_tag, endtag_i_index)
@@ -311,7 +285,6 @@ def reset(self):
         self.stack = []
         self.placeholders = PlaceholderState()
         self.source = None
-        self._svg_depth = getattr(self, "_initial_svg_depth", 0)
 
     def close(self) -> None:
         if self.stack:
@@ -364,16 +337,13 @@ def feed_template(self, template: Template) -> None:
         self.feed_str(template.strings[-1])
 
     @staticmethod
-    def parse(t: Template, *, svg_context: bool = False) -> TNode:
+    def parse(t: Template) -> TNode:
         """
         Parse a Template containing valid HTML and substitutions and return
         a TNode tree representing its structure. This cachable structure can later
         be resolved against actual interpolation values to produce a Node tree.
-
-        Pass ``svg_context=True`` for SVG fragments that have no ``<svg>``
-        wrapper, so that tag and attribute case-fixing applies from the root.
         """
-        parser = TemplateParser(svg_context=svg_context)
+        parser = TemplateParser()
         parser.feed_template(t)
         parser.close()
         return parser.get_tnode()
diff --git a/tdom/processor.py b/tdom/processor.py
index e814385..59aab19 100644
--- a/tdom/processor.py
+++ b/tdom/processor.py
@@ -1,4 +1,3 @@
-import sys
 import typing as t
 from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass
@@ -8,12 +7,30 @@
 from markupsafe import Markup
 
 from .callables import CallableInfo, get_callable_info
+from .escaping import (
+    escape_html_comment as default_escape_html_comment,
+)
+from .escaping import (
+    escape_html_script as default_escape_html_script,
+)
+from .escaping import (
+    escape_html_style as default_escape_html_style,
+)
+from .escaping import (
+    escape_html_text as default_escape_html_text,
+)
 from .format import format_interpolation as base_format_interpolation
 from .format import format_template
-from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
+from .htmlspec import (
+    CDATA_CONTENT_ELEMENTS,
+    DEFAULT_NORMAL_TEXT_ELEMENT,
+    RCDATA_CONTENT_ELEMENTS,
+    SVG_ATTR_FIX,
+    SVG_TAG_FIX,
+    VOID_ELEMENTS,
+)
 from .parser import (
     HTMLAttribute,
-    HTMLAttributesDict,
     TAttribute,
     TComment,
     TComponent,
@@ -28,21 +45,11 @@
     TTemplatedAttribute,
     TText,
 )
-from .placeholders import TemplateRef
 from .protocols import HasHTMLDunder
-from .template_utils import template_from_parts
+from .sentinel import NOT_SET, NotSet
+from .template_utils import TemplateRef
 from .utils import CachableTemplate, LastUpdatedOrderedDict
 
-# TODO: in Ian's original PR, this caching was tethered to the
-# TemplateParser. Here, it's tethered to the processor. I suspect we'll
-# revisit this soon enough.
-
-
-@lru_cache(maxsize=0 if "pytest" in sys.modules else 512)
-def _parse_and_cache(cachable: CachableTemplate) -> TNode:
-    return TemplateParser.parse(cachable.template, svg_context=cachable.svg_context)
-
-
 type Attribute = tuple[str, object]
 type AttributesDict = dict[str, object]
 
@@ -325,7 +332,7 @@ def _resolve_t_attrs(
                 else:
                     new_attrs[name] = attr_value
             case TTemplatedAttribute(name=name, value_ref=ref):
-                attr_t = _resolve_ref(ref, interpolations)
+                attr_t = ref.resolve(interpolations)
                 attr_value = format_template(attr_t)
                 if name in ATTR_ACCUMULATOR_MAKERS:
                     if name not in attr_accs:
@@ -359,82 +366,16 @@ def _resolve_t_attrs(
     return new_attrs
 
 
-def _resolve_html_attrs(attrs: AttributesDict) -> HTMLAttributesDict:
+def _resolve_html_attrs(attrs: AttributesDict) -> Iterable[HTMLAttribute]:
     """Resolve attribute values for HTML output."""
-    html_attrs: HTMLAttributesDict = {}
     for key, value in attrs.items():
         match value:
             case True:
-                html_attrs[key] = None
+                yield key, None
             case False | None:
                 pass
             case _:
-                html_attrs[key] = str(value)
-    return html_attrs
-
-
-def _resolve_attrs(
-    attrs: Sequence[TAttribute], interpolations: tuple[Interpolation, ...]
-) -> HTMLAttributesDict:
-    """
-    Substitute placeholders in attributes for HTML elements.
-
-    This is the full pipeline: interpolation + HTML processing.
-    """
-    interpolated_attrs = _resolve_t_attrs(attrs, interpolations)
-    return _resolve_html_attrs(interpolated_attrs)
-
-
-def _flatten_nodes(nodes: Iterable[Node]) -> list[Node]:
-    """Flatten a list of Nodes, expanding any Fragments."""
-    flat: list[Node] = []
-    for node in nodes:
-        if isinstance(node, Fragment):
-            flat.extend(node.children)
-        else:
-            flat.append(node)
-    return flat
-
-
-def _substitute_and_flatten_children(
-    children: Iterable[TNode], interpolations: tuple[Interpolation, ...]
-) -> list[Node]:
-    """Substitute placeholders in a list of children and flatten any fragments."""
-    resolved = [_resolve_t_node(child, interpolations) for child in children]
-    flat = _flatten_nodes(resolved)
-    return flat
-
-
-def _node_from_value(value: object) -> Node:
-    """
-    Convert an arbitrary value to a Node.
-
-    This is the primary action performed when replacing interpolations in child
-    content positions.
-    """
-    match value:
-        case str():
-            return Text(value)
-        case Node():
-            return value
-        case Template():
-            return html(value)
-        # Consider: falsey values, not just False and None?
-        case False | None:
-            return Fragment(children=[])
-        case Iterable():
-            children = [_node_from_value(v) for v in value]
-            return Fragment(children=children)
-        case HasHTMLDunder():
-            # CONSIDER: should we do this lazily?
-            return Text(Markup(value.__html__()))
-        case c if callable(c):
-            # Treat all callable values in child content positions as if
-            # they are zero-arg functions that return a value to be rendered.
-            return _node_from_value(c())
-        case _:
-            # CONSIDER: should we do this lazily?
-            return Text(str(value))
+                yield key, str(value)
 
 
 def _kebab_to_snake(name: str) -> str:
@@ -445,8 +386,8 @@ def _kebab_to_snake(name: str) -> str:
 def _prep_component_kwargs(
     callable_info: CallableInfo,
     attrs: AttributesDict,
-    system_kwargs: dict[str, object],
-):
+    children: Template,
+) -> AttributesDict:
     if callable_info.requires_positional:
         raise TypeError(
             "Component callables cannot have required positional arguments."
@@ -460,9 +401,8 @@ def _prep_component_kwargs(
         if snake_name in callable_info.named_params or callable_info.kwargs:
             kwargs[snake_name] = attr_value
 
-    for attr_name, attr_value in system_kwargs.items():
-        if attr_name in callable_info.named_params or callable_info.kwargs:
-            kwargs[attr_name] = attr_value
+    if "children" in callable_info.named_params or callable_info.kwargs:
+        kwargs["children"] = children
 
     # Check to make sure we've fully satisfied the callable's requirements
     missing = callable_info.required_named_params - kwargs.keys()
@@ -474,135 +414,552 @@ def _prep_component_kwargs(
     return kwargs
 
 
-def _invoke_component(
-    attrs: AttributesDict,
-    children: list[Node],  # TODO: why not TNode, though?
-    interpolation: Interpolation,
-) -> Node:
+def serialize_html_attrs(
+    html_attrs: Iterable[HTMLAttribute], escape: Callable = default_escape_html_text
+) -> str:
+    return "".join(
+        (f' {k}="{escape(v)}"' if v is not None else f" {k}" for k, v in html_attrs)
+    )
+
+
+def _fix_svg_attrs(html_attrs: Iterable[HTMLAttribute]) -> Iterable[HTMLAttribute]:
     """
-    Invoke a component callable with the provided attributes and children.
+    Fix the attr name-case of any html attributes on a tag within an SVG namespace.
+    """
+    for k, v in html_attrs:
+        yield SVG_ATTR_FIX.get(k, k), v
 
-    Components are any callable that meets the required calling signature.
-    Typically, that's a function, but it could also be the constructor or
-    __call__() method for a class; dataclass constructors match our expected
-    invocation style.
 
-    We validate the callable's signature and invoke it with keyword-only
-    arguments, then convert the result to a Node.
+def make_ctx(parent_tag: str | None = None, ns: str | None = "html"):
+    return ProcessContext(parent_tag=parent_tag, ns=ns)
 
-    Component invocation rules:
 
-    1. All arguments are passed as keywords only. Components cannot require
-    positional arguments.
+@dataclass(frozen=True, slots=True)
+class ProcessContext:
+    # None means unknown not just a missing value.
+    parent_tag: str | None = None
+    # None means unknown not just a missing value.
+    ns: str | None = None
 
-    2. Children are passed via a "children" parameter when:
+    def copy(
+        self,
+        ns: NotSet | str | None = NOT_SET,
+        parent_tag: NotSet | str | None = NOT_SET,
+    ):
+        if isinstance(ns, NotSet):
+            resolved_ns = self.ns
+        else:
+            resolved_ns = ns
+        if isinstance(parent_tag, NotSet):
+            resolved_parent_tag = self.parent_tag
+        else:
+            resolved_parent_tag = parent_tag
+        return make_ctx(
+            parent_tag=resolved_parent_tag,
+            ns=resolved_ns,
+        )
 
-    - Child content exists in the template AND
-    - The callable accepts "children" OR has **kwargs
 
-    If no children exist but the callable accepts "children", we pass an
-    empty tuple.
+type FunctionComponent = Callable[..., Template]
+type FactoryComponent = Callable[..., ComponentObject]
+type ComponentCallable = FunctionComponent | FactoryComponent
+type ComponentObject = Callable[[], Template]
 
-    3. All other attributes are converted from kebab-case to snake_case
-    and passed as keyword arguments if the callable accepts them (or has
-    **kwargs). Attributes that don't match parameters are silently ignored.
-    """
 
-    value = format_interpolation(interpolation)
-    if not callable(value):
-        raise TypeError(
-            f"Expected a callable for component invocation, got {type(value).__name__}"
-        )
-    callable_info = get_callable_info(value)
+type NormalTextInterpolationValue = (
+    None
+    | bool  # to support `showValue and value` idiom
+    | str
+    | HasHTMLDunder
+    | Template
+    | Iterable[NormalTextInterpolationValue]
+    | object
+)
+# Applies to both escapable raw text and raw text.
+type RawTextExactInterpolationValue = (
+    None
+    | bool  # to support `showValue and value` idiom
+    | str
+    | HasHTMLDunder
+    | object
+)
+# Applies to both escapable raw text and raw text.
+type RawTextInexactInterpolationValue = (
+    None
+    | bool  # to support `showValue and value` idiom
+    | str
+    | object
+)
 
-    kwargs = _prep_component_kwargs(
-        callable_info, attrs, system_kwargs={"children": tuple(children)}
-    )
 
-    # The cast avoids `call-top-callable` from ty; there *must* be a smarter
-    # way, though... -Dave
-    result = t.cast(Callable[..., t.Any], value)(**kwargs)
-    return _node_from_value(result)
+@dataclass(frozen=True)
+class ParserService:
+    def to_tnode(self, template: Template) -> TNode:
+        return TemplateParser.parse(template)
 
 
-def _resolve_ref(
-    ref: TemplateRef, interpolations: tuple[Interpolation, ...]
-) -> Template:
-    resolved = [interpolations[i_index] for i_index in ref.i_indexes]
-    return template_from_parts(ref.strings, resolved)
-
-
-def _resolve_t_text_ref(
-    ref: TemplateRef, interpolations: tuple[Interpolation, ...]
-) -> Text | Fragment:
-    """Resolve a TText ref into Text or Fragment by processing interpolations."""
-    if ref.is_literal:
-        return Text(ref.strings[0])
-
-    parts = [
-        Text(part)
-        if isinstance(part, str)
-        else _node_from_value(format_interpolation(part))
-        for part in _resolve_ref(ref, interpolations)
-    ]
-    flat = _flatten_nodes(parts)
-
-    if len(flat) == 1 and isinstance(flat[0], Text):
-        return flat[0]
-
-    return Fragment(children=flat)
-
-
-def _resolve_t_node(t_node: TNode, interpolations: tuple[Interpolation, ...]) -> Node:
-    """Resolve a TNode tree into a Node tree by processing interpolations."""
-    match t_node:
-        case TText(ref=ref):
-            return _resolve_t_text_ref(ref, interpolations)
-        case TComment(ref=ref):
-            comment_t = _resolve_ref(ref, interpolations)
-            comment = format_template(comment_t)
-            return Comment(comment)
-        case TDocumentType(text=text):
-            return DocumentType(text)
-        case TFragment(children=children):
-            resolved_children = _substitute_and_flatten_children(
-                children, interpolations
+@dataclass(frozen=True)
+class CachedParserService(ParserService):
+    @lru_cache(512)  # noqa: B019
+    def _to_tnode(self, ct: CachableTemplate):
+        return super().to_tnode(ct.template)
+
+    def to_tnode(self, template: Template):
+        return self._to_tnode(CachableTemplate(template))
+
+
+@dataclass(frozen=True)
+class ProcessorService:
+    parser_api: ParserService
+
+    escape_html_text: Callable = default_escape_html_text
+
+    escape_html_comment: Callable = default_escape_html_comment
+
+    escape_html_script: Callable = default_escape_html_script
+
+    escape_html_style: Callable = default_escape_html_style
+
+    slash_void: bool = False  # Apply a xhtml-style slash to void html elements.
+
+    uppercase_doctype: bool = False  # DOCTYPE vs doctype
+
+    def process_template(
+        self, root_template: Template, assume_ctx: ProcessContext | None = None
+    ) -> str:
+        """
+        Process a TDOM compatible template into a string.
+        """
+        if assume_ctx is None:
+            # @DESIGN: What do we want to do here?  Should we assume we are in
+            # a tag with normal text?
+            assume_ctx = make_ctx(parent_tag=DEFAULT_NORMAL_TEXT_ELEMENT, ns="html")
+        root = self.parser_api.to_tnode(root_template)
+        return self._process_tnode(root_template, assume_ctx, root)
+
+    def _process_tnode(
+        self, template: Template, last_ctx: ProcessContext, tnode: TNode
+    ) -> str:
+        """
+        Process a tnode from a template's "t-tree" into a string.
+        """
+        match tnode:
+            case TDocumentType(text):
+                return self._process_document_type(last_ctx, text)
+            case TComment(ref):
+                return self._process_comment(template, last_ctx, ref)
+            case TFragment(children):
+                return self._process_fragment(template, last_ctx, children)
+            case TComponent(start_i_index, end_i_index, attrs, children):
+                return self._process_component(
+                    template, last_ctx, attrs, start_i_index, end_i_index
+                )
+            case TElement(tag, attrs, children):
+                return self._process_element(template, last_ctx, tag, attrs, children)
+            case TText(ref):
+                return self._process_texts(template, last_ctx, ref)
+            case _:
+                raise ValueError(f"Unrecognized tnode: {tnode}")
+
+    def _process_document_type(
+        self,
+        last_ctx: ProcessContext,
+        text: str,
+    ) -> str:
+        if last_ctx.ns != "html":
+            # Nit
+            raise ValueError(
+                "Cannot process document type in subtree of a foreign element."
+            )
+        if self.uppercase_doctype:
+            return f"<!DOCTYPE {text}>"
+        else:
+            return f"<!doctype {text}>"
+
+    def _process_fragment(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        children: Iterable[TNode],
+    ) -> str:
+        return "".join(
+            self._process_tnode(template, last_ctx, child) for child in children
+        )
+
+    def _process_texts(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        ref: TemplateRef,
+    ) -> str:
+        if last_ctx.parent_tag is None:
+            raise NotImplementedError(
+                "We cannot interpolate texts without knowing what tag they are contained in."
             )
-            return Fragment(children=resolved_children)
-        case TElement(tag=tag, attrs=attrs, children=children):
-            resolved_attrs = _resolve_attrs(attrs, interpolations)
-            resolved_children = _substitute_and_flatten_children(
-                children, interpolations
+        elif last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS:
+            # Must be handled all at once.
+            return self._process_raw_texts(template, last_ctx, ref)
+        elif last_ctx.parent_tag in RCDATA_CONTENT_ELEMENTS:
+            # We can handle all at once because there are no non-text children and everything must be string-ified.
+            return self._process_escapable_raw_texts(template, last_ctx, ref)
+        else:
+            return self._process_normal_texts(template, last_ctx, ref)
+
+    def _process_comment(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> str:
+        """
+        Process a comment into a string.
+        """
+        content_str = resolve_text_without_recursion(template, "<!--", content_ref)
+        escaped_comment_str = self.escape_html_comment(content_str, allow_markup=True)
+        return f"<!--{escaped_comment_str}-->"
+
+    def _process_element(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        tag: str,
+        attrs: tuple[TAttribute, ...],
+        children: tuple[TNode, ...],
+    ) -> str:
+        out: list[str] = []
+        if tag == "svg":
+            our_ctx = last_ctx.copy(parent_tag=tag, ns="svg")
+        elif tag == "math":
+            our_ctx = last_ctx.copy(parent_tag=tag, ns="math")
+        else:
+            our_ctx = last_ctx.copy(parent_tag=tag)
+        if our_ctx.ns == "svg":
+            starttag = endtag = SVG_TAG_FIX.get(tag, tag)
+        else:
+            starttag = endtag = tag
+        out.append(f"<{starttag}")
+        if attrs:
+            out.append(self._process_attrs(template, our_ctx, attrs))
+        # @TODO: How can we tell if we write out children or not in
+        # order to self-close in non-html contexts, ie. SVG?
+        if self.slash_void and tag in VOID_ELEMENTS:
+            out.append(" />")
+        else:
+            out.append(">")
+        if tag not in VOID_ELEMENTS:
+            # We were still in SVG but now we default back into HTML
+            if tag == "foreignobject":
+                child_ctx = our_ctx.copy(ns="html")
+            else:
+                child_ctx = our_ctx
+            out.extend(
+                self._process_tnode(template, child_ctx, child) for child in children
             )
-            return Element(tag=tag, attrs=resolved_attrs, children=resolved_children)
-        case TComponent(
-            start_i_index=start_i_index,
-            end_i_index=end_i_index,
-            attrs=t_attrs,
-            children=children,
+            out.append(f"</{endtag}>")
+        return "".join(out)
+
+    def _process_attrs(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        attrs: tuple[TAttribute, ...],
+    ) -> str:
+        """
+        Process an element's attributes into a string.
+        """
+        resolved_attrs = _resolve_t_attrs(attrs, template.interpolations)
+        if last_ctx.ns == "svg":
+            attrs_str = serialize_html_attrs(
+                _fix_svg_attrs(_resolve_html_attrs(resolved_attrs))
+            )
+        else:
+            attrs_str = serialize_html_attrs(_resolve_html_attrs(resolved_attrs))
+        if attrs_str:
+            return attrs_str
+        return ""
+
+    def _process_component(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        attrs: tuple[TAttribute, ...],
+        start_i_index: int,
+        end_i_index: int | None,
+    ) -> str:
+        """
+        Invoke a component and process the result into a string.
+        """
+        body_start_s_index = (
+            start_i_index
+            + 1
+            + len([1 for attr in attrs if not isinstance(attr, TLiteralAttribute)])
+        )
+        start_i = template.interpolations[start_i_index]
+        component_callable = t.cast(ComponentCallable, start_i.value)
+        if start_i_index != end_i_index and end_i_index is not None:
+            # @TODO: We should do this during parsing.
+            children_template = extract_embedded_template(
+                template, body_start_s_index, end_i_index
+            )
+            if component_callable != template.interpolations[end_i_index].value:
+                raise TypeError(
+                    "Component callable in start tag must match component callable in end tag."
+                )
+        else:
+            children_template = t""
+
+        if not callable(component_callable):
+            raise TypeError("Component callable must be callable.")
+
+        kwargs = _prep_component_kwargs(
+            get_callable_info(component_callable),
+            _resolve_t_attrs(attrs, template.interpolations),
+            children=children_template,
+        )
+
+        result_t = component_callable(**kwargs)
+        if (
+            result_t is not None
+            and not isinstance(result_t, Template)
+            and callable(result_t)
         ):
-            start_interpolation = interpolations[start_i_index]
-            end_interpolation = (
-                None if end_i_index is None else interpolations[end_i_index]
+            component_obj = t.cast(ComponentObject, result_t)  # ty: ignore[redundant-cast]
+            result_t = component_obj()
+        else:
+            component_obj = None
+
+        if isinstance(result_t, Template):
+            if result_t.strings == ("",):
+                # DO NOTHING
+                return ""
+            else:
+                result_root = self.parser_api.to_tnode(result_t)
+                return self._process_tnode(result_t, last_ctx, result_root)
+        else:
+            raise TypeError(f"Unknown component return value: {type(result_t)}")
+
+    def _process_raw_texts(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> str:
+        """
+        Process the given content into a string as "raw text".
+        """
+        assert last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        if last_ctx.parent_tag == "script":
+            return self.escape_html_script(
+                content,
+                allow_markup=True,
             )
-            resolved_attrs = _resolve_t_attrs(t_attrs, interpolations)
-            resolved_children = _substitute_and_flatten_children(
-                children, interpolations
+        elif last_ctx.parent_tag == "style":
+            return self.escape_html_style(
+                content,
+                allow_markup=True,
             )
-            # HERE ALSO BE DRAGONS: validate matching start/end callables, since
-            # the underlying TemplateParser cannot do that for us.
-            if (
-                end_interpolation is not None
-                and end_interpolation.value != start_interpolation.value
-            ):
-                raise TypeError("Mismatched component start and end callables.")
-            return _invoke_component(
-                attrs=resolved_attrs,
-                children=resolved_children,
-                interpolation=start_interpolation,
+        else:
+            raise NotImplementedError(
+                f"Parent tag {last_ctx.parent_tag} is not supported."
             )
-        case _:
-            raise ValueError(f"Unknown TNode type: {type(t_node).__name__}")
+
+    def _process_escapable_raw_texts(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> str:
+        """
+        Process the given content into a string as "escapable raw text".
+        """
+        assert last_ctx.parent_tag in RCDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        return self.escape_html_text(content)
+
+    def _process_normal_texts(
+        self, template: Template, last_ctx: ProcessContext, content_ref: TemplateRef
+    ):
+        """
+        Process the given context into a string as "normal text".
+        """
+        return "".join(
+            (
+                self.escape_html_text(part)
+                if isinstance(part, str)
+                else self._process_normal_text(template, last_ctx, t.cast(int, part))
+            )
+            for part in content_ref
+        )
+
+    def _process_normal_text(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        values_index: int,
+    ) -> str:
+        """
+        Process the value of the interpolation into a string as "normal text".
+
+        @NOTE: This is an interpolation that must be formatted to get the value.
+        """
+        value = format_interpolation(template.interpolations[values_index])
+        value = t.cast(NormalTextInterpolationValue, value)  # ty: ignore[redundant-cast]
+        return self._process_normal_text_from_value(template, last_ctx, value)
+
+    def _process_normal_text_from_value(
+        self,
+        template: Template,
+        last_ctx: ProcessContext,
+        value: NormalTextInterpolationValue,
+    ) -> str:
+        """
+        Process a single value into a string as "normal text".
+
+        @NOTE: This is an actual value and NOT an interpolation.  This is meant to be
+        used when processing an iterable of values as normal text.
+        """
+        if value is None or isinstance(value, bool):
+            return ""
+        elif isinstance(value, str):
+            # @NOTE: This would apply to Markup() but not to a custom object
+            # implementing HasHTMLDunder.
+            return self.escape_html_text(value)
+        elif isinstance(value, Template):
+            value_root = self.parser_api.to_tnode(value)
+            return self._process_tnode(value, last_ctx, value_root)
+        elif isinstance(value, Iterable):
+            return "".join(
+                self._process_normal_text_from_value(template, last_ctx, v)
+                for v in value
+            )
+        elif isinstance(value, HasHTMLDunder):
+            # @NOTE: markupsafe's escape does this for us but we put this in
+            # here for completeness.
+            # @NOTE: An actual Markup() would actually pass as a str() but a
+            # custom object with __html__ might not.
+            return Markup(value.__html__())
+        else:
+            # @DESIGN: Everything that isn't an object we recognize is
+            # coerced to a str() and emitted.
+            return self.escape_html_text(value)
+
+
+def resolve_text_without_recursion(
+    template: Template, parent_tag: str, content_ref: TemplateRef
+) -> str:
+    """
+    Resolve the text in the given template without recursing into more structured text.
+
+    This can be bypassed by interpolating an exact match with an object with `__html__()`.
+
+    A non-exact match is not allowed because we cannot process escaping
+    across the boundary between other content and the pass-through content.
+    """
+    if content_ref.is_singleton:
+        value = format_interpolation(template.interpolations[content_ref.i_indexes[0]])
+        value = t.cast(RawTextExactInterpolationValue, value)  # ty: ignore[redundant-cast]
+        if value is None or isinstance(value, bool):
+            return ""
+        elif isinstance(value, str):
+            return value
+        elif isinstance(value, HasHTMLDunder):
+            # @DESIGN: We could also force callers to use `:safe` to trigger
+            # the interpolation in this special case.
+            return Markup(value.__html__())
+        elif isinstance(value, (Template, Iterable)):
+            raise ValueError(
+                f"Recursive includes are not supported within {parent_tag}"
+            )
+        else:
+            return str(value)
+    else:
+        text = []
+        for part in content_ref:
+            if isinstance(part, str):
+                if part:
+                    text.append(part)
+                continue
+            value = format_interpolation(template.interpolations[part])
+            value = t.cast(RawTextInexactInterpolationValue, value)  # ty: ignore[redundant-cast]
+            if value is None or isinstance(value, bool):
+                continue
+            elif (
+                type(value) is str
+            ):  # type() check to avoid subclasses, probably something smarter here
+                if value:
+                    text.append(value)
+            elif not isinstance(value, str) and isinstance(value, (Template, Iterable)):
+                raise ValueError(
+                    f"Recursive includes are not supported within {parent_tag}"
+                )
+            elif isinstance(value, HasHTMLDunder):
+                raise ValueError(
+                    f"Non-exact trusted interpolations are not supported within {parent_tag}"
+                )
+            else:
+                value_str = str(value)
+                if value_str:
+                    text.append(value_str)
+        return "".join(text)
+
+
+def extract_embedded_template(
+    template: Template, body_start_s_index: int, end_i_index: int
+) -> Template:
+    """
+    Extract the template parts exclusively from start tag to end tag.
+
+    Note that interpolations INSIDE the start tag make this more complex
+    than just "the `s_index` after the component callable's `i_index`".
+
+    Example:
+    ```python
+    template = (
+        t'<{comp} attr={attr}>'
+            t'<div>{content} <span>{footer}</span></div>'
+        t'</{comp}>'
+    )
+    assert extract_children_template(template, 2, 4) == (
+        t'<div>{content} <span>{footer}</span></div>'
+    )
+    starttag = t'<{comp} attr={attr}>'
+    endtag = t'</{comp}>'
+    assert template == starttag + extract_children_template(template, 2, 4) + endtag
+    ```
+    @DESIGN: "There must be a better way."
+    """
+    # Copy the parts out of the containing template.
+    index = body_start_s_index
+    last_s_index = end_i_index
+    parts = []
+    while index <= last_s_index:
+        parts.append(template.strings[index])
+        if index != last_s_index:
+            parts.append(template.interpolations[index])
+        index += 1
+    # Now trim the first part to the end of the opening tag.
+    parts[0] = parts[0][parts[0].find(">") + 1 :]
+    # Now trim the last part (could also be the first) to the start of the closing tag.
+    parts[-1] = parts[-1][: parts[-1].rfind("<")]
+    return Template(*parts)
+
+
+def processor_service_factory(**config_kwargs):
+    return ProcessorService(parser_api=ParserService(), **config_kwargs)
+
+
+def cached_processor_service_factory(**config_kwargs):
+    return ProcessorService(parser_api=CachedParserService(), **config_kwargs)
+
+
+_default_processor_api = cached_processor_service_factory(
+    slash_void=True, uppercase_doctype=True
+)
 
 
 # --------------------------------------------------------------------------
@@ -610,15 +967,13 @@ def _resolve_t_node(t_node: TNode, interpolations: tuple[Interpolation, ...]) ->
 # --------------------------------------------------------------------------
 
 
-def html(template: Template) -> Node:
-    """Parse an HTML t-string, substitute values, and return a tree of Nodes."""
-    cachable = CachableTemplate(template)
-    t_node = _parse_and_cache(cachable)
-    return _resolve_t_node(t_node, template.interpolations)
+def html(template: Template, assume_ctx: ProcessContext | None = None) -> str:
+    """Parse an HTML t-string, substitute values, and return a string of HTML."""
+    return _default_processor_api.process_template(template, assume_ctx)
 
 
-def svg(template: Template) -> Node:
-    """Parse a standalone SVG fragment and return a tree of Nodes.
+def svg(template: Template, assume_ctx: ProcessContext | None = None) -> str:
+    """Parse a standalone SVG fragment and return a string of HTML.
 
     Use when the template does not contain an ``<svg>`` wrapper element.
     Tag and attribute case-fixing (e.g. ``clipPath``, ``viewBox``) are applied
@@ -627,6 +982,8 @@ def svg(template: Template) -> Node:
     When the template does contain ``<svg>``, use ``html()`` — the SVG context
     is detected automatically.
     """
-    cachable = CachableTemplate(template, svg_context=True)
-    t_node = _parse_and_cache(cachable)
-    return _resolve_t_node(t_node, template.interpolations)
+    if assume_ctx is None:
+        # We should probably be setting this to some sort of escaping function
+        # can raw text exist in SVG or MathML?
+        assume_ctx = make_ctx(parent_tag=DEFAULT_NORMAL_TEXT_ELEMENT, ns="svg")
+    return html(template, assume_ctx)
diff --git a/tdom/processor_test.py b/tdom/processor_test.py
index 1a3f728..f4fc5fa 100644
--- a/tdom/processor_test.py
+++ b/tdom/processor_test.py
@@ -1,16 +1,33 @@
 import datetime
 import typing as t
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass, field
-from itertools import product
+from collections.abc import Callable
+from dataclasses import dataclass
+from itertools import chain, product
 from string.templatelib import Template
 
 import pytest
 from markupsafe import Markup
+from markupsafe import escape as markupsafe_escape
 
 from .callables import get_callable_info
-from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
-from .processor import _prep_component_kwargs, html
+from .escaping import escape_html_text
+from .processor import (
+    CachedParserService,
+    cached_processor_service_factory,
+    make_ctx,
+    processor_service_factory,
+)
+from .processor import (
+    _prep_component_kwargs as prep_component_kwargs,
+)
+from .protocols import HasHTMLDunder
+
+processor_api = processor_service_factory(slash_void=True, uppercase_doctype=True)
+
+
+def html(*args, **kwargs):
+    return processor_api.process_template(*args, **kwargs)
+
 
 # --------------------------------------------------------------------------
 # Basic HTML parsing tests
@@ -20,1430 +37,1687 @@
 #
 # Text
 #
-def test_empty():
-    node = html(t"")
-    assert node == Fragment(children=[])
-    assert str(node) == ""
-
-
-def test_text_literal():
-    node = html(t"Hello, world!")
-    assert node == Text("Hello, world!")
-    assert str(node) == "Hello, world!"
-
-
-def test_text_singleton():
-    greeting = "Hello, Alice!"
-    node = html(t"{greeting}")
-    assert node == Text("Hello, Alice!")
-    assert str(node) == "Hello, Alice!"
-
-
-def test_text_template():
-    name = "Alice"
-    node = html(t"Hello, {name}!")
-    assert node == Fragment(children=[Text("Hello, "), Text("Alice"), Text("!")])
-    assert str(node) == "Hello, Alice!"
-
+class TestBareTemplate:
+    def test_empty(self):
+        assert html(t"") == ""
+
+    def test_text_literal(self):
+        assert html(t"Hello, world!") == "Hello, world!"
+
+    def test_text_singleton(self):
+        greeting = "Hello, Alice!"
+        assert html(t"{greeting}", make_ctx(parent_tag="div")) == "Hello, Alice!"
+        assert html(t"{greeting}", make_ctx(parent_tag="script")) == "Hello, Alice!"
+        assert html(t"{greeting}", make_ctx(parent_tag="style")) == "Hello, Alice!"
+        assert html(t"{greeting}", make_ctx(parent_tag="textarea")) == "Hello, Alice!"
+        assert html(t"{greeting}", make_ctx(parent_tag="title")) == "Hello, Alice!"
+
+    def test_text_singleton_without_parent(self):
+        greeting = "</script>"
+        with pytest.raises(NotImplementedError):
+            # Explicitly set the parent tag as None.
+            ctx = make_ctx(parent_tag=None, ns="html")
+            _ = html(t"{greeting}", assume_ctx=ctx)
+
+    def test_text_singleton_explicit_parent_script(self):
+        greeting = "</script>"
+        res = html(t"{greeting}", assume_ctx=make_ctx(parent_tag="script"))
+        assert res == "\\x3c/script>"
+        assert res != "</script>"
+
+    def test_text_singleton_explicit_parent_div(self):
+        greeting = "</div>"
+        res = html(t"{greeting}", assume_ctx=make_ctx(parent_tag="div"))
+        assert res == "&lt;/div&gt;"
+        assert res != "</div>"
+
+    def test_text_template(self):
+        name = "Alice"
+        assert (
+            html(t"Hello, {name}!", assume_ctx=make_ctx(parent_tag="div"))
+            == "Hello, Alice!"
+        )
 
-def test_text_template_escaping():
-    name = "Alice & Bob"
-    node = html(t"Hello, {name}!")
-    assert node == Fragment(children=[Text("Hello, "), Text("Alice & Bob"), Text("!")])
-    assert str(node) == "Hello, Alice &amp; Bob!"
+    def test_text_template_escaping(self):
+        name = "Alice & Bob"
+        assert (
+            html(t"Hello, {name}!", assume_ctx=make_ctx(parent_tag="div"))
+            == "Hello, Alice &amp; Bob!"
+        )
 
+    def test_parse_entities_are_escaped_no_parent_tag(self):
+        res = html(t"&lt;/p&gt;")
+        assert res == "&lt;/p&gt;", "Default to standard escaping."
 
-#
-# Comments.
-#
-def test_comment():
-    node = html(t"<!--This is a comment-->")
-    assert node == Comment("This is a comment")
-    assert str(node) == "<!--This is a comment-->"
 
+class LiteralHTML:
+    """Text is returned as is by __html__."""
 
-def test_comment_template():
-    text = "comment"
-    node = html(t"<!--This is a {text}-->")
-    assert node == Comment("This is a comment")
-    assert str(node) == "<!--This is a comment-->"
+    def __init__(self, text):
+        self.text = text
 
+    def __html__(self):
+        # In a real app, this would come from a sanitizer or trusted source
+        return self.text
 
-def test_comment_template_escaping():
-    text = "-->comment"
-    node = html(t"<!--This is a {text}-->")
-    assert node == Comment("This is a -->comment")
-    assert str(node) == "<!--This is a --&gt;comment-->"
 
+def test_literal_html_has_html_dunder():
+    assert isinstance(LiteralHTML, HasHTMLDunder)
 
-#
-# Document types.
-#
-def test_parse_document_type():
-    node = html(t"<!doctype html>")
-    assert node == DocumentType("html")
-    assert str(node) == "<!DOCTYPE html>"
 
+def test_markup_has_html_dunder():
+    assert isinstance(Markup, HasHTMLDunder)
 
-#
-# Elements
-#
-def test_parse_void_element():
-    node = html(t"<br>")
-    assert node == Element("br")
-    assert str(node) == "<br />"
-
-
-def test_parse_void_element_self_closed():
-    node = html(t"<br />")
-    assert node == Element("br")
-    assert str(node) == "<br />"
-
-
-def test_parse_chain_of_void_elements():
-    # Make sure our handling of CPython issue #69445 is reasonable.
-    node = html(t"<br><hr><img src='image.png' /><br /><hr>")
-    assert node == Fragment(
-        children=[
-            Element("br"),
-            Element("hr"),
-            Element("img", attrs={"src": "image.png"}),
-            Element("br"),
-            Element("hr"),
-        ],
-    )
-    assert str(node) == '<br /><hr /><img src="image.png" /><br /><hr />'
 
+class TestComment:
+    def test_literal(self):
+        assert html(t"<!--This is a comment-->") == "<!--This is a comment-->"
 
-def test_parse_element_with_text():
-    node = html(t"<p>Hello, world!</p>")
-    assert node == Element(
-        "p",
-        children=[
-            Text("Hello, world!"),
-        ],
-    )
-    assert str(node) == "<p>Hello, world!</p>"
+    #
+    # Singleton / Exact Match
+    #
+    def test_singleton_str(self):
+        text = "This is a comment"
+        assert html(t"<!--{text}-->") == "<!--This is a comment-->"
 
+    def test_singleton_object(self):
+        assert html(t"<!--{0}-->") == "<!--0-->"
 
-def test_parse_nested_elements():
-    node = html(t"<div><p>Hello</p><p>World</p></div>")
-    assert node == Element(
-        "div",
-        children=[
-            Element("p", children=[Text("Hello")]),
-            Element("p", children=[Text("World")]),
-        ],
-    )
-    assert str(node) == "<div><p>Hello</p><p>World</p></div>"
+    def test_singleton_none(self):
+        assert html(t"<!--{None}-->") == "<!---->"
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<!--{bool_value}-->") == "<!---->"
 
-def test_parse_entities_are_escaped():
-    node = html(t"<p>&lt;/p&gt;</p>")
-    assert node == Element(
-        "p",
-        children=[Text("</p>")],
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
     )
-    assert str(node) == "<p>&lt;/p&gt;</p>"
+    def test_singleton_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("-->")
+        assert html(t"<!--{content}-->") == "<!---->-->", (
+            "DO NOT DO THIS! This is just an advanced escape hatch."
+        )
 
+    def test_singleton_escaping(self):
+        text = "-->comment"
+        assert html(t"<!--{text}-->") == "<!----&gt;comment-->"
+
+    #
+    # Templated -- literal text mixed with interpolation(s)
+    #
+    def test_templated_str(self):
+        text = "comment"
+        assert html(t"<!--This is a {text}-->") == "<!--This is a comment-->"
+
+    def test_templated_object(self):
+        assert html(t"<!--This is a {0}-->") == "<!--This is a 0-->"
+
+    def test_templated_none(self):
+        assert html(t"<!--This is a {None}-->") == "<!--This is a -->"
+
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert html(t"<!--This is a {bool_value}-->") == "<!--This is a -->"
+
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_templated_has_html_dunder_error(self, html_dunder_cls):
+        """Objects with __html__ are not processed with literal text or other interpolations."""
+        text = html_dunder_cls("in a comment")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--This is a {text}-->")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--{None}{text}-->")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--This is a {Markup('Also check specialized cls.')}-->")
+
+    def test_templated_multiple_interpolations(self):
+        text = "comment"
+        assert (
+            html(t"<!--This is a {text} with {0} and {None}-->")
+            == "<!--This is a comment with 0 and -->"
+        )
 
-# --------------------------------------------------------------------------
-# Interpolated text content
-# --------------------------------------------------------------------------
+    def test_templated_escaping(self):
+        # @TODO: There doesn't seem to be a way to properly escape this
+        # so we just use an entity to break the special closing string
+        # even though it won't be actually unescaped by anything. There
+        # might be something better for this.
+        text = "-->comment"
+        assert html(t"<!--This is a {text}-->") == "<!--This is a --&gt;comment-->"
 
+    def test_not_supported__recursive_template_error(self):
+        text_t = t"comment"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--{text_t}-->")
 
-def test_interpolated_text_content():
-    name = "Alice"
-    node = html(t"<p>Hello, {name}!</p>")
-    assert node == Element("p", children=[Text("Hello, "), Text("Alice"), Text("!")])
-    assert str(node) == "<p>Hello, Alice!</p>"
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "comment"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--{texts}-->")
 
 
-def test_escaping_of_interpolated_text_content():
-    name = "<Alice & Bob>"
-    node = html(t"<p>Hello, {name}!</p>")
-    assert node == Element(
-        "p", children=[Text("Hello, "), Text("<Alice & Bob>"), Text("!")]
-    )
-    assert str(node) == "<p>Hello, &lt;Alice &amp; Bob&gt;!</p>"
+class TestDocumentType:
+    def test_literal(self):
+        assert html(t"<!doctype html>") == "<!DOCTYPE html>"
 
 
-class Convertible:
-    def __str__(self):
-        return "string"
-
-    def __repr__(self):
-        return "repr"
+class TestVoidElementLiteral:
+    def test_void(self):
+        assert html(t"<br>") == "<br />"
 
+    def test_void_self_closed(self):
+        assert html(t"<br />") == "<br />"
 
-def test_conversions():
-    c = Convertible()
-    assert f"{c!s}" == "string"
-    assert f"{c!r}" == "repr"
-    node = html(t"<li>{c!s}</li><li>{c!r}</li><li>{'😊'!a}</li>")
-    assert node == Fragment(
-        children=[
-            Element("li", children=[Text("string")]),
-            Element("li", children=[Text("repr")]),
-            Element("li", children=[Text("'\\U0001f60a'")]),
-        ],
-    )
-
-
-def test_interpolated_in_content_node():
-    # https://github.com/t-strings/tdom/issues/68
-    evil = "</style><script>alert('whoops');</script><style>"
-    node = html(t"<style>{evil}{evil}</style>")
-    assert node == Element(
-        "style",
-        children=[
-            Text("</style><script>alert('whoops');</script><style>"),
-            Text("</style><script>alert('whoops');</script><style>"),
-        ],
-    )
-    LT = "&lt;"
-    assert (
-        str(node)
-        == f"<style>{LT}/style><script>alert('whoops');</script><style>{LT}/style><script>alert('whoops');</script><style></style>"
-    )
-
+    def test_void_mixed_closing(self):
+        assert html(t"<br>Is this content?<br />") == "<br />Is this content?<br />"
 
-def test_interpolated_trusted_in_content_node():
-    # https://github.com/t-strings/tdom/issues/68
-    node = html(t"<script>if (a < b && c > d) {{ alert('wow'); }}</script>")
-    assert node == Element(
-        "script",
-        children=[Text("if (a < b && c > d) { alert('wow'); }")],
-    )
-    assert str(node) == ("<script>if (a < b && c > d) { alert('wow'); }</script>")
+    def test_chain_of_void_elements(self):
+        # Make sure our handling of CPython issue #69445 is reasonable.
+        assert (
+            html(t"<br><hr><img src='image.png' /><br /><hr>")
+            == '<br /><hr /><img src="image.png" /><br /><hr />'
+        )
 
 
-def test_script_elements_error():
-    nested_template = t"<div></div>"
-    # Putting non-text content inside a script is not allowed.
-    with pytest.raises(TypeError):
-        node = html(t"<script>{nested_template}</script>")
-        _ = str(node)
+class TestNormalTextElementLiteral:
+    def test_empty(self):
+        assert html(t"<div></div>") == "<div></div>"
 
+    def test_with_text(self):
+        assert html(t"<p>Hello, world!</p>") == "<p>Hello, world!</p>"
 
-# --------------------------------------------------------------------------
-# Interpolated non-text content
-# --------------------------------------------------------------------------
+    def test_nested_elements(self):
+        assert (
+            html(t"<div><p>Hello</p><p>World</p></div>")
+            == "<div><p>Hello</p><p>World</p></div>"
+        )
 
+    def test_entities_are_escaped(self):
+        """Literal entities interpreted by parser but escaped in output."""
+        res = html(t"<p>&lt;/p&gt;</p>")
+        assert res == "<p>&lt;/p&gt;</p>", res
 
-def test_interpolated_false_content():
-    node = html(t"<div>{False}</div>")
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
 
+class TestNormalTextElementDynamic:
+    def test_singleton_None(self):
+        assert html(t"<p>{None}</p>") == "<p></p>"
 
-def test_interpolated_none_content():
-    node = html(t"<div>{None}</div>")
-    assert node == Element("div", children=[])
-    assert str(node) == "<div></div>"
+    def test_singleton_str(self):
+        name = "Alice"
+        assert html(t"<p>{name}</p>") == "<p>Alice</p>"
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<p>{bool_value}</p>") == "<p></p>"
 
-def test_interpolated_zero_arg_function():
-    def get_value():
-        return "dynamic"
+    def test_singleton_object(self):
+        assert html(t"<p>{0}</p>") == "<p>0</p>"
 
-    node = html(t"<p>The value is {get_value:callback}.</p>")
-    assert node == Element(
-        "p", children=[Text("The value is "), Text("dynamic"), Text(".")]
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
     )
+    def test_singleton_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("<em>Alright!</em>")
+        assert html(t"<p>{content}</p>") == "<p><em>Alright!</em></p>"
 
+    def test_singleton_simple_template(self):
+        name = "Alice"
+        text_t = t"Hi {name}"
+        assert html(t"<p>{text_t}</p>") == "<p>Hi Alice</p>"
 
-def test_interpolated_multi_arg_function_fails():
-    def add(a, b):  # pragma: no cover
-        return a + b
-
-    with pytest.raises(TypeError):
-        _ = html(t"<p>The sum is {add:callback}.</p>")
-
-
-# --------------------------------------------------------------------------
-# Raw HTML injection tests
-# --------------------------------------------------------------------------
-
+    def test_singleton_simple_iterable(self):
+        strs = ["Strings", "...", "Yeah!", "Rock", "...", "Yeah!"]
+        assert html(t"<p>{strs}</p>") == "<p>Strings...Yeah!Rock...Yeah!</p>"
 
-def test_raw_html_injection_with_markupsafe():
-    raw_content = Markup("<strong>I am bold</strong>")
-    node = html(t"<div>{raw_content}</div>")
-    assert node == Element("div", children=[Text(text=raw_content)])
-    assert str(node) == "<div><strong>I am bold</strong></div>"
+    def test_singleton_escaping(self):
+        text = '''<>&'"'''
+        assert html(t"<p>{text}</p>") == "<p>&lt;&gt;&amp;&#39;&#34;</p>"
 
+    def test_templated_None(self):
+        assert html(t"<p>Response: {None}.</p>") == "<p>Response: .</p>"
 
-def test_raw_html_injection_with_dunder_html_protocol():
-    class SafeContent:
-        def __init__(self, text):
-            self._text = text
-
-        def __html__(self):
-            # In a real app, this would come from a sanitizer or trusted source
-            return f"<em>{self._text}</em>"
-
-    content = SafeContent("emphasized")
-    node = html(t"<p>Here is some {content}.</p>")
-    assert node == Element(
-        "p",
-        children=[
-            Text("Here is some "),
-            Text(Markup("<em>emphasized</em>")),
-            Text("."),
-        ],
-    )
-    assert str(node) == "<p>Here is some <em>emphasized</em>.</p>"
-
-
-def test_raw_html_injection_with_format_spec():
-    raw_content = "<u>underlined</u>"
-    node = html(t"<p>This is {raw_content:safe} text.</p>")
-    assert node == Element(
-        "p",
-        children=[
-            Text("This is "),
-            Text(Markup(raw_content)),
-            Text(" text."),
-        ],
-    )
-    assert str(node) == "<p>This is <u>underlined</u> text.</p>"
-
-
-def test_raw_html_injection_with_markupsafe_unsafe_format_spec():
-    supposedly_safe = Markup("<i>italic</i>")
-    node = html(t"<p>This is {supposedly_safe:unsafe} text.</p>")
-    assert node == Element(
-        "p",
-        children=[
-            Text("This is "),
-            Text(str(supposedly_safe)),
-            Text(" text."),
-        ],
-    )
-    assert str(node) == "<p>This is &lt;i&gt;italic&lt;/i&gt; text.</p>"
-
-
-# --------------------------------------------------------------------------
-# Conditional rendering and control flow
-# --------------------------------------------------------------------------
+    def test_templated_str(self):
+        name = "Alice"
+        assert html(t"<p>Response: {name}.</p>") == "<p>Response: Alice.</p>"
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert html(t"<p>Response: {bool_value}</p>") == "<p>Response: </p>"
 
-def test_conditional_rendering_with_if_else():
-    is_logged_in = True
-    user_profile = t"<span>Welcome, User!</span>"
-    login_prompt = t"<a href='/login'>Please log in</a>"
-    node = html(t"<div>{user_profile if is_logged_in else login_prompt}</div>")
+    def test_templated_object(self):
+        assert html(t"<p>Response: {0}.</p>") == "<p>Response: 0.</p>"
 
-    assert node == Element(
-        "div", children=[Element("span", children=[Text("Welcome, User!")])]
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
     )
-    assert str(node) == "<div><span>Welcome, User!</span></div>"
-
-    is_logged_in = False
-    node = html(t"<div>{user_profile if is_logged_in else login_prompt}</div>")
-    assert str(node) == '<div><a href="/login">Please log in</a></div>'
-
-
-def test_conditional_rendering_with_and():
-    show_warning = True
-    warning_message = t'<div class="warning">Warning!</div>'
-    node = html(t"<main>{show_warning and warning_message}</main>")
+    def test_templated_has_html_dunder(self, html_dunder_cls):
+        text = html_dunder_cls("<em>Alright!</em>")
+        assert (
+            html(t"<p>Response: {text}.</p>") == "<p>Response: <em>Alright!</em>.</p>"
+        )
 
-    assert node == Element(
-        "main",
-        children=[
-            Element("div", attrs={"class": "warning"}, children=[Text("Warning!")]),
-        ],
-    )
-    assert str(node) == '<main><div class="warning">Warning!</div></main>'
+    def test_templated_simple_template(self):
+        name = "Alice"
+        text_t = t"Hi {name}"
+        assert html(t"<p>Response: {text_t}.</p>") == "<p>Response: Hi Alice.</p>"
 
-    show_warning = False
-    node = html(t"<main>{show_warning and warning_message}</main>")
-    # Assuming False renders nothing
-    assert str(node) == "<main></main>"
+    def test_templated_simple_iterable(self):
+        strs = ["Strings", "...", "Yeah!", "Rock", "...", "Yeah!"]
+        assert (
+            html(t"<p>Response: {strs}.</p>")
+            == "<p>Response: Strings...Yeah!Rock...Yeah!.</p>"
+        )
 
+    def test_templated_escaping(self):
+        text = '''<>&'"'''
+        assert (
+            html(t"<p>Response: {text}.</p>")
+            == "<p>Response: &lt;&gt;&amp;&#39;&#34;.</p>"
+        )
 
-# --------------------------------------------------------------------------
-# Interpolated nesting of templates and elements
-# --------------------------------------------------------------------------
+    def test_templated_escaping_in_literals(self):
+        text = "This text is fine"
+        assert (
+            html(t"<p>The literal has &lt; in it: {text}.</p>")
+            == "<p>The literal has &lt; in it: This text is fine.</p>"
+        )
 
+    def test_iterable_of_templates(self):
+        items = ["Apple", "Banana", "Cherry"]
+        assert (
+            html(t"<ul>{[t'<li>{item}</li>' for item in items]}</ul>")
+            == "<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>"
+        )
 
-def test_interpolated_template_content():
-    child = t"<span>Child</span>"
-    node = html(t"<div>{child}</div>")
-    assert node == Element("div", children=[html(child)])
-    assert str(node) == "<div><span>Child</span></div>"
+    def test_iterable_of_templates_of_iterable_of_templates(self):
+        outer = ["fruit", "more fruit"]
+        inner = ["apple", "banana", "cherry"]
+        inner_items = [t"<li>{item}</li>" for item in inner]
+        outer_items = [
+            t"<li>{category}<ul>{inner_items}</ul></li>" for category in outer
+        ]
+        assert (
+            html(t"<ul>{outer_items}</ul>")
+            == "<ul><li>fruit<ul><li>apple</li><li>banana</li><li>cherry</li></ul></li><li>more fruit<ul><li>apple</li><li>banana</li><li>cherry</li></ul></li></ul>"
+        )
 
 
-def test_interpolated_element_content():
-    child = html(t"<span>Child</span>")
-    node = html(t"<div>{child}</div>")
-    assert node == Element("div", children=[child])
-    assert str(node) == "<div><span>Child</span></div>"
+class TestRawTextElementLiteral:
+    def test_script_empty(self):
+        assert html(t"<script></script>") == "<script></script>"
 
+    def test_style_empty(self):
+        assert html(t"<style></style>") == "<style></style>"
 
-def test_interpolated_nonstring_content():
-    number = 42
-    node = html(t"<p>The answer is {number}.</p>")
-    assert node == Element(
-        "p", children=[Text("The answer is "), Text("42"), Text(".")]
-    )
-    assert str(node) == "<p>The answer is 42.</p>"
-
-
-def test_list_items():
-    items = ["Apple", "Banana", "Cherry"]
-    node = html(t"<ul>{[t'<li>{item}</li>' for item in items]}</ul>")
-    assert node == Element(
-        "ul",
-        children=[
-            Element("li", children=[Text("Apple")]),
-            Element("li", children=[Text("Banana")]),
-            Element("li", children=[Text("Cherry")]),
-        ],
-    )
-    assert str(node) == "<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>"
-
-
-def test_nested_list_items():
-    # TODO XXX this is a pretty abusrd test case; clean it up when refactoring
-    outer = ["fruit", "more fruit"]
-    inner = ["apple", "banana", "cherry"]
-    inner_items = [t"<li>{item}</li>" for item in inner]
-    outer_items = [t"<li>{category}<ul>{inner_items}</ul></li>" for category in outer]
-    node = html(t"<ul>{outer_items}</ul>")
-    assert node == Element(
-        "ul",
-        children=[
-            Element(
-                "li",
-                children=[
-                    Text("fruit"),
-                    Element(
-                        "ul",
-                        children=[
-                            Element("li", children=[Text("apple")]),
-                            Element("li", children=[Text("banana")]),
-                            Element("li", children=[Text("cherry")]),
-                        ],
-                    ),
-                ],
-            ),
-            Element(
-                "li",
-                children=[
-                    Text("more fruit"),
-                    Element(
-                        "ul",
-                        children=[
-                            Element("li", children=[Text("apple")]),
-                            Element("li", children=[Text("banana")]),
-                            Element("li", children=[Text("cherry")]),
-                        ],
-                    ),
-                ],
-            ),
-        ],
-    )
-    assert (
-        str(node)
-        == "<ul><li>fruit<ul><li>apple</li><li>banana</li><li>cherry</li></ul></li><li>more fruit<ul><li>apple</li><li>banana</li><li>cherry</li></ul></li></ul>"
-    )
+    def test_script_with_content(self):
+        assert html(t"<script>var x = 1;</script>") == "<script>var x = 1;</script>"
 
+    def test_style_with_content(self):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            html(t"<style>.red {{ color: red; }}</style>")
+            == "<style>.red { color: red; }</style>"
+        )
 
-# --------------------------------------------------------------------------
-# Attributes
-# --------------------------------------------------------------------------
+    def test_script_with_content_escaped_in_normal_text(self):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            html(t"<script>function CompareNumbers(a, b) {{ return a < b; }}</script>")
+            == "<script>function CompareNumbers(a, b) { return a < b; }</script>"
+        ), "The < should not be escaped."
+
+    def test_style_with_content_escaped_in_normal_text(self):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            html(t"<style>section > h4 {{ background-color: red; }}</style>")
+            == "<style>section > h4 { background-color: red; }</style>"
+        ), "The > should not be escaped."
+
+    def test_not_supported_recursive_template_error(self):
+        text_t = t"comment"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--{text_t}-->")
+
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "comment"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<!--{texts}-->")
+
+
+class TestEscapableRawTextElementLiteral:
+    def test_title_empty(self):
+        assert html(t"<title></title>") == "<title></title>"
+
+    def test_textarea_empty(self):
+        assert html(t"<textarea></textarea>") == "<textarea></textarea>"
+
+    def test_title_with_content(self):
+        assert html(t"<title>Content</title>") == "<title>Content</title>"
+
+    def test_textarea_with_content(self):
+        assert html(t"<textarea>Content</textarea>") == "<textarea>Content</textarea>"
+
+    def test_title_with_escapable_content(self):
+        assert (
+            html(t"<title>Are t-strings > everything?</title>")
+            == "<title>Are t-strings &gt; everything?</title>"
+        ), "The > can be escaped in this content type."
+
+    def test_textarea_with_escapable_content(self):
+        assert (
+            html(t"<textarea><p>Welcome To TDOM</p></textarea>")
+            == "<textarea>&lt;p&gt;Welcome To TDOM&lt;/p&gt;</textarea>"
+        ), "The p tags can be escaped in this content type."
+
+
+class TestRawTextScriptDynamic:
+    def test_singleton_none(self):
+        assert html(t"<script>{None}</script>") == "<script></script>"
+
+    def test_singleton_str(self):
+        content = "var x = 1;"
+        assert html(t"<script>{content}</script>") == "<script>var x = 1;</script>"
+
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<script>{bool_value}</script>") == "<script></script>"
+
+    def test_singleton_object(self):
+        content = 0
+        assert html(t"<script>{content}</script>") == "<script>0</script>"
+
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_singleton_has_html_dunder_pitfall(self, html_dunder_cls):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        # Or just disable this and if people want to do this then put the
+        # content in a SCRIPT and inject the whole thing with a __html__?
+        content = html_dunder_cls("</script>")
+        assert html(t"<script>{content}</script>") == "<script></script></script>", (
+            "DO NOT DO THIS! This is just an advanced escape hatch! Use a data attribute and parseJSON!"
+        )
 
+    def test_singleton_escaping(self):
+        content = "</script>"
+        script_t = t"<script>{content}</script>"
+        bad_output = script_t.strings[0] + content + script_t.strings[1]
+        assert html(script_t) == "<script>\\x3c/script></script>"
+        assert html(script_t) != bad_output, "Sanity check."
+
+    def test_templated_none(self):
+        assert (
+            html(t"<script>var x = 1;{None};</script>")
+            == "<script>var x = 1;;</script>"
+        )
 
-def test_literal_attrs():
-    node = html(
-        t"<a "
-        t" id=example_link"  # no quotes allowed without spaces
-        t" autofocus"  # bare / boolean
-        t' title=""'  # empty attribute
-        t' href="https://example.com" target="_blank"'
-        t"></a>"
-    )
-    assert node == Element(
-        "a",
-        attrs={
-            "id": "example_link",
-            "autofocus": None,
-            "title": "",
-            "href": "https://example.com",
-            "target": "_blank",
-        },
-    )
-    assert (
-        str(node)
-        == '<a id="example_link" autofocus title="" href="https://example.com" target="_blank"></a>'
-    )
+    def test_templated_str(self):
+        content = "var x = 1"
+        assert (
+            html(t"<script>var x = 0;{content};</script>")
+            == "<script>var x = 0;var x = 1;</script>"
+        )
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert (
+            html(t"<script>var x = 15; {bool_value}</script>")
+            == "<script>var x = 15; </script>"
+        )
 
-def test_literal_attr_escaped():
-    node = html(t'<a title="&lt;"></a>')
-    assert node == Element(
-        "a",
-        attrs={"title": "<"},
-    )
-    assert str(node) == '<a title="&lt;"></a>'
+    def test_templated_object(self):
+        content = 0
+        assert (
+            html(t"<script>var x = {content};</script>")
+            == "<script>var x = 0;</script>"
+        )
 
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_templated_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("anything")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<script>var x = 1;{content}</script>")
+
+    def test_templated_escaping(self):
+        content = "</script>"
+        script_t = t"<script>var x = '{content}';</script>"
+        bad_output = script_t.strings[0] + content + script_t.strings[1]
+        assert html(script_t) == "<script>var x = '\\x3c/script>';</script>"
+        assert html(script_t) != bad_output, "Sanity check."
+
+    def test_templated_multiple_interpolations(self):
+        assert (
+            html(t"<script>var x = {1}; var y = {2};</script>")
+            == "<script>var x = 1; var y = 2;</script>"
+        )
 
-def test_interpolated_attr():
-    url = "https://example.com/"
-    node = html(t'<a href="{url}"></a>')
-    assert node == Element("a", attrs={"href": "https://example.com/"})
-    assert str(node) == '<a href="https://example.com/"></a>'
+    def test_not_supported_recursive_template_error(self):
+        text_t = t"script"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<script>{text_t}</script>")
 
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "script"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<script>{texts}</script>")
 
-def test_interpolated_attr_escaped():
-    url = 'https://example.com/?q="test"&lang=en'
-    node = html(t'<a href="{url}"></a>')
-    assert node == Element(
-        "a",
-        attrs={"href": 'https://example.com/?q="test"&lang=en'},
-    )
-    assert (
-        str(node) == '<a href="https://example.com/?q=&#34;test&#34;&amp;lang=en"></a>'
-    )
 
+class TestRawTextStyleDynamic:
+    def test_singleton_none(self):
+        assert html(t"<style>{None}</style>") == "<style></style>"
 
-def test_interpolated_attr_unquoted():
-    id = "roquefort"
-    node = html(t"<div id={id}></div>")
-    assert node == Element("div", attrs={"id": "roquefort"})
-    assert str(node) == '<div id="roquefort"></div>'
+    def test_singleton_str(self):
+        content = "div { background-color: red; }"
+        assert (
+            html(t"<style>{content}</style>")
+            == "<style>div { background-color: red; }</style>"
+        )
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<style>{bool_value}</style>") == "<style></style>"
+
+    def test_singleton_object(self):
+        content = 0
+        assert html(t"<style>{content}</style>") == "<style>0</style>"
+
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_singleton_has_html_dunder_pitfall(self, html_dunder_cls):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        # Or just disable this and if people want to do this then put the
+        # content in a STYLE and inject the whole thing with a __html__?
+        content = html_dunder_cls("</style>")
+        assert html(t"<style>{content}</style>") == "<style></style></style>", (
+            "DO NOT DO THIS! This is just an advanced escape hatch!"
+        )
 
-def test_interpolated_attr_true():
-    disabled = True
-    node = html(t"<button disabled={disabled}></button>")
-    assert node == Element("button", attrs={"disabled": None})
-    assert str(node) == "<button disabled></button>"
+    def test_singleton_escaping(self):
+        content = "</style>"
+        style_t = t"<style>{content}</style>"
+        bad_output = style_t.strings[0] + content + style_t.strings[1]
+        assert html(style_t) == "<style>&lt;/style></style>"
+        assert html(style_t) != bad_output, "Sanity check."
+
+    def test_templated_none(self):
+        assert (
+            html(t"<style>h1 {{ background-color: red; }}{None}</style>")
+            == "<style>h1 { background-color: red; }</style>"
+        )
 
+    def test_templated_str(self):
+        content = " h2 { background-color: blue; }"
+        assert (
+            html(t"<style>h1 {{ background-color: red; }}{content}</style>")
+            == "<style>h1 { background-color: red; } h2 { background-color: blue; }</style>"
+        )
 
-def test_interpolated_attr_false():
-    disabled = False
-    node = html(t"<button disabled={disabled}></button>")
-    assert node == Element("button")
-    assert str(node) == "<button></button>"
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert (
+            html(t"<style>h1 {{ background-color: red; }};{bool_value}</style>")
+            == "<style>h1 { background-color: red; };</style>"
+        )
 
+    def test_templated_object(self):
+        padding_right = 0
+        assert (
+            html(t"<style>h1 {{ padding-right: {padding_right}px; }}</style>")
+            == "<style>h1 { padding-right: 0px; }</style>"
+        )
 
-def test_interpolated_attr_none():
-    disabled = None
-    node = html(t"<button disabled={disabled}></button>")
-    assert node == Element("button")
-    assert str(node) == "<button></button>"
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_templated_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("anything")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<style>h1 {{ color: red; }};{content}</style>")
+
+    def test_templated_escaping(self):
+        content = "</style>"
+        style_t = t"<style>div {{ background-color: red; }} {content}</style>"
+        bad_output = style_t.strings[0] + content + style_t.strings[1]
+        assert (
+            html(style_t) == "<style>div { background-color: red; } &lt;/style></style>"
+        )
+        assert html(style_t) != bad_output, "Sanity check."
 
+    def test_templated_multiple_interpolations(self):
+        assert (
+            html(
+                t"<style>h1 {{ background-color: {'red'}; }} h2 {{ background-color: {'blue'}; }}</style>"
+            )
+            == "<style>h1 { background-color: red; } h2 { background-color: blue; }</style>"
+        )
 
-def test_interpolate_attr_empty_string():
-    node = html(t'<div title=""></div>')
-    assert node == Element(
-        "div",
-        attrs={"title": ""},
-    )
-    assert str(node) == '<div title=""></div>'
+    def test_not_supported_recursive_template_error(self):
+        text_t = t"style"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<style>{text_t}</style>")
+
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "style"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<style>{texts}</style>")
+
+
+class TestEscapableRawTextTitleDynamic:
+    def test_singleton_none(self):
+        assert html(t"<title>{None}</title>") == "<title></title>"
+
+    def test_singleton_str(self):
+        content = "Welcome To TDOM"
+        assert html(t"<title>{content}</title>") == "<title>Welcome To TDOM</title>"
+
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<title>{bool_value}</title>") == "<title></title>"
+
+    def test_singleton_object(self):
+        content = 0
+        assert html(t"<title>{content}</title>") == "<title>0</title>"
+
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_singleton_has_html_dunder_pitfall(self, html_dunder_cls):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        content = html_dunder_cls("</title>")
+        assert html(t"<title>{content}</title>") == "<title></title></title>", (
+            "DO NOT DO THIS! This is just an advanced escape hatch!"
+        )
 
+    def test_singleton_escaping(self):
+        content = "</title>"
+        assert html(t"<title>{content}</title>") == "<title>&lt;/title&gt;</title>"
 
-def test_spread_attr():
-    attrs = {"href": "https://example.com/", "target": "_blank"}
-    node = html(t"<a {attrs}></a>")
-    assert node == Element(
-        "a",
-        attrs={"href": "https://example.com/", "target": "_blank"},
-    )
-    assert str(node) == '<a href="https://example.com/" target="_blank"></a>'
+    def test_templated_none(self):
+        assert (
+            html(t"<title>A great story about: {None}</title>")
+            == "<title>A great story about: </title>"
+        )
 
+    def test_templated_str(self):
+        content = "TDOM"
+        assert (
+            html(t"<title>A great story about: {content}</title>")
+            == "<title>A great story about: TDOM</title>"
+        )
 
-def test_spread_attr_none():
-    attrs = None
-    node = html(t"<a {attrs}></a>")
-    assert node == Element("a")
-    assert str(node) == "<a></a>"
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert (
+            html(t"<title>A great story; {bool_value}</title>")
+            == "<title>A great story; </title>"
+        )
 
+    def test_templated_object(self):
+        content = 0
+        assert (
+            html(t"<title>A great number: {content}</title>")
+            == "<title>A great number: 0</title>"
+        )
 
-def test_spread_attr_type_errors():
-    for attrs in (0, [], (), False, True):
-        with pytest.raises(TypeError):
-            _ = html(t"<a {attrs}></a>")
-
-
-def test_templated_attr_mixed_interpolations_start_end_and_nest():
-    left, middle, right = 1, 3, 5
-    prefix, suffix = t'<div data-range="', t'"></div>'
-    # Check interpolations at start, middle and/or end of templated attr
-    # or a combination of those to make sure text is not getting dropped.
-    for left_part, middle_part, right_part in product(
-        (t"{left}", Template(str(left))),
-        (t"{middle}", Template(str(middle))),
-        (t"{right}", Template(str(right))),
-    ):
-        test_t = prefix + left_part + t"-" + middle_part + t"-" + right_part + suffix
-        node = html(test_t)
-        assert node == Element(
-            "div",
-            attrs={"data-range": "1-3-5"},
-        )
-        assert str(node) == '<div data-range="1-3-5"></div>'
-
-
-def test_templated_attr_no_quotes():
-    start = 1
-    end = 5
-    node = html(t"<div data-range={start}-{end}></div>")
-    assert node == Element(
-        "div",
-        attrs={"data-range": "1-5"},
-    )
-    assert str(node) == '<div data-range="1-5"></div>'
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_templated_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("No")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<title>Literal html?: {content}</title>")
+
+    def test_templated_escaping(self):
+        content = "</title>"
+        assert (
+            html(t"<title>The end tag: {content}.</title>")
+            == "<title>The end tag: &lt;/title&gt;.</title>"
+        )
 
+    def test_templated_multiple_interpolations(self):
+        assert (
+            html(t"<title>The number {0} is less than {1}.</title>")
+            == "<title>The number 0 is less than 1.</title>"
+        )
 
-def test_attr_merge_disjoint_interpolated_attr_spread_attr():
-    attrs = {"href": "https://example.com/", "id": "link1"}
-    target = "_blank"
-    node = html(t"<a {attrs} target={target}></a>")
-    assert node == Element(
-        "a",
-        attrs={"href": "https://example.com/", "id": "link1", "target": "_blank"},
-    )
-    assert str(node) == '<a href="https://example.com/" id="link1" target="_blank"></a>'
+    def test_not_supported_recursive_template_error(self):
+        text_t = t"title"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<title>{text_t}</title>")
 
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "title"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<title>{texts}</title>")
 
-def test_attr_merge_overlapping_spread_attrs():
-    attrs1 = {"href": "https://example.com/", "id": "overwrtten"}
-    attrs2 = {"target": "_blank", "id": "link1"}
-    node = html(t"<a {attrs1} {attrs2}></a>")
-    assert node == Element(
-        "a",
-        attrs={"href": "https://example.com/", "target": "_blank", "id": "link1"},
-    )
-    assert str(node) == '<a href="https://example.com/" target="_blank" id="link1"></a>'
 
+class TestEscapableRawTextTextareaDynamic:
+    def test_singleton_none(self):
+        assert html(t"<textarea>{None}</textarea>") == "<textarea></textarea>"
 
-def test_attr_merge_replace_literal_attr_str_str():
-    attrs = {"title": "fresh"}
-    node = html(t'<div title="default" {attrs}></div>')
-    assert node == Element("div", {"title": "fresh"})
-    assert str(node) == '<div title="fresh"></div>'
+    def test_singleton_str(self):
+        content = "Welcome To TDOM"
+        assert (
+            html(t"<textarea>{content}</textarea>")
+            == "<textarea>Welcome To TDOM</textarea>"
+        )
 
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_singleton_bool(self, bool_value):
+        assert html(t"<textarea>{bool_value}</textarea>") == "<textarea></textarea>"
+
+    def test_singleton_object(self):
+        content = 0
+        assert html(t"<textarea>{content}</textarea>") == "<textarea>0</textarea>"
+
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_singleton_has_html_dunder_pitfall(self, html_dunder_cls):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        content = html_dunder_cls("</textarea>")
+        assert (
+            html(t"<textarea>{content}</textarea>")
+            == "<textarea></textarea></textarea>"
+        ), "DO NOT DO THIS! This is just an advanced escape hatch!"
+
+    def test_singleton_escaping(self):
+        content = "</textarea>"
+        assert (
+            html(t"<textarea>{content}</textarea>")
+            == "<textarea>&lt;/textarea&gt;</textarea>"
+        )
 
-def test_attr_merge_replace_literal_attr_str_true():
-    attrs = {"title": True}
-    node = html(t'<div title="default" {attrs}></div>')
-    assert node == Element("div", {"title": None})
-    assert str(node) == "<div title></div>"
+    def test_templated_none(self):
+        assert (
+            html(t"<textarea>A great story about: {None}</textarea>")
+            == "<textarea>A great story about: </textarea>"
+        )
 
+    def test_templated_str(self):
+        content = "TDOM"
+        assert (
+            html(t"<textarea>A great story about: {content}</textarea>")
+            == "<textarea>A great story about: TDOM</textarea>"
+        )
 
-def test_attr_merge_replace_literal_attr_true_str():
-    attrs = {"title": "fresh"}
-    node = html(t"<div title {attrs}></div>")
-    assert node == Element("div", {"title": "fresh"})
-    assert str(node) == '<div title="fresh"></div>'
+    @pytest.mark.parametrize("bool_value", (True, False))
+    def test_templated_bool(self, bool_value):
+        assert (
+            html(t"<textarea>This is great.{bool_value}</textarea>")
+            == "<textarea>This is great.</textarea>"
+        )
 
+    def test_templated_object(self):
+        content = 0
+        assert (
+            html(t"<textarea>A great number: {content}</textarea>")
+            == "<textarea>A great number: 0</textarea>"
+        )
 
-def test_attr_merge_remove_literal_attr_str_none():
-    attrs = {"title": None}
-    node = html(t'<div title="default" {attrs}></div>')
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
+    @pytest.mark.parametrize(
+        "html_dunder_cls",
+        (
+            LiteralHTML,
+            Markup,
+        ),
+    )
+    def test_templated_has_html_dunder(self, html_dunder_cls):
+        content = html_dunder_cls("No")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<textarea>Literal html?: {content}</textarea>")
+
+    def test_templated_multiple_interpolations(self):
+        assert (
+            html(t"<textarea>The number {0} is less than {1}.</textarea>")
+            == "<textarea>The number 0 is less than 1.</textarea>"
+        )
 
+    def test_templated_escaping(self):
+        content = "</textarea>"
+        assert (
+            html(t"<textarea>The end tag: {content}.</textarea>")
+            == "<textarea>The end tag: &lt;/textarea&gt;.</textarea>"
+        )
 
-def test_attr_merge_remove_literal_attr_true_none():
-    attrs = {"title": None}
-    node = html(t"<div title {attrs}></div>")
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
+    def test_not_supported_recursive_template_error(self):
+        text_t = t"textarea"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<textarea>{text_t}</textarea>")
 
+    def test_not_supported_recursive_iterable_error(self):
+        texts = ["This", "is", "a", "textarea"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = html(t"<textarea>{texts}</textarea>")
 
-def test_attr_merge_other_literal_attr_intact():
-    attrs = {"alt": "fresh"}
-    node = html(t'<img title="default" {attrs}>')
-    assert node == Element("img", {"title": "default", "alt": "fresh"})
-    assert str(node) == '<img title="default" alt="fresh" />'
 
+class Convertible:
+    def __str__(self):
+        return "string"
 
-#
-# Special data attribute handling.
-#
-def test_interpolated_data_attributes():
-    data = {"user-id": 123, "role": "admin", "wild": True, "false": False, "none": None}
-    node = html(t"<div data={data}>User Info</div>")
-    assert node == Element(
-        "div",
-        attrs={"data-user-id": "123", "data-role": "admin", "data-wild": None},
-        children=[Text("User Info")],
-    )
-    assert (
-        str(node)
-        == '<div data-user-id="123" data-role="admin" data-wild>User Info</div>'
-    )
+    def __repr__(self):
+        return "repr"
 
 
-def test_data_attr_toggle_to_str():
-    data_dict = {"selected": "yes"}
-    for node in [
-        html(t"<div data-selected data={data_dict}></div>"),
-        html(t'<div data-selected="no" data={data_dict}></div>'),
-    ]:
-        assert node == Element("div", {"data-selected": "yes"})
-        assert str(node) == '<div data-selected="yes"></div>'
+def test_convertible_fixture():
+    """Make sure test fixture is working correctly."""
+    c = Convertible()
+    assert f"{c!s}" == "string"
+    assert f"{c!r}" == "repr"
 
 
-def test_data_attr_toggle_to_true():
-    data_dict = {"selected": True}
-    node = html(t'<div data-selected="yes" data={data_dict}></div>')
-    assert node == Element("div", {"data-selected": None})
-    assert str(node) == "<div data-selected></div>"
+def wrap_template_in_tags(
+    start_tag: str, template: Template, end_tag: str | None = None
+):
+    """Utility for testing templated text but with different containing tags."""
+    if end_tag is None:
+        end_tag = start_tag
+    return Template(f"<{start_tag}>") + template + Template(f"</{end_tag}>")
 
 
-def test_data_attr_unrelated_unaffected():
-    data_dict = {"active": True}
-    node = html(t"<div data-selected data={data_dict}></div>")
-    assert node == Element("div", {"data-selected": None, "data-active": None})
-    assert str(node) == "<div data-selected data-active></div>"
+def wrap_text_in_tags(start_tag: str, content: str, end_tag: str | None = None):
+    """Utility for testing expected text but with different containing tags."""
+    if end_tag is None:
+        end_tag = start_tag
+    # Stringify to flatten `Markup()`
+    content = str(content)
+    return f"<{start_tag}>" + content + f"</{end_tag}>"
 
 
-def test_data_attr_templated_error():
-    data1 = {"user-id": "user-123"}
-    data2 = {"role": "admin"}
-    with pytest.raises(TypeError):
-        node = html(t'<div data="{data1} {data2}"></div>')
-        print(str(node))
+class TestInterpolationConversion:
+    def test_str(self):
+        c = Convertible()
+        for tag in ("p", "script", "title"):
+            assert html(wrap_template_in_tags(tag, t"{c!s}")) == wrap_text_in_tags(
+                tag, "string"
+            )
 
+    def test_repr(self):
+        c = Convertible()
+        for tag in ("p", "script", "title"):
+            assert html(wrap_template_in_tags(tag, t"{c!r}")) == wrap_text_in_tags(
+                tag, "repr"
+            )
 
-def test_data_attr_none():
-    button_data = None
-    node = html(t"<button data={button_data}>X</button>")
-    assert node == Element("button", children=[Text("X")])
-    assert str(node) == "<button>X</button>"
+    def test_ascii_raw_text(self):
+        # single quotes are not escaped in raw text
+        assert html(wrap_template_in_tags("script", t"{'😊'!a}")) == wrap_text_in_tags(
+            "script", ascii("😊")
+        )
 
+    def test_ascii_escapable_normal_and_raw(self):
+        # single quotes are escaped
+        for tag in ("p", "title"):
+            assert html(wrap_template_in_tags(tag, t"{'😊'!a}")) == wrap_text_in_tags(
+                tag, escape_html_text(ascii("😊"))
+            )
 
-def test_data_attr_errors():
-    for v in [False, [], (), 0, "data?"]:
-        with pytest.raises(TypeError):
-            _ = html(t"<button data={v}>X</button>")
 
+class TestInterpolationFormatSpec:
+    def test_normal_text_safe(self):
+        raw_content = "<u>underlined</u>"
+        assert (
+            html(t"<p>This is {raw_content:safe} text.</p>")
+            == "<p>This is <u>underlined</u> text.</p>"
+        )
 
-def test_data_literal_attr_bypass():
-    # Trigger overall attribute resolution with an unrelated interpolated attr.
-    node = html(t'<p data="passthru" id={"resolved"}></p>')
-    assert node == Element(
-        "p",
-        attrs={"data": "passthru", "id": "resolved"},
-    ), "A single literal attribute should not trigger data expansion."
+    def test_raw_text_safe(self):
+        # @TODO: What should even happen here?
+        raw_content = "</script>"
+        assert (
+            html(t"<script>{raw_content:safe}</script>") == "<script></script></script>"
+        ), "DO NOT DO THIS! This is an advanced escape hatch."
+
+    def test_escapable_raw_text_safe(self):
+        raw_content = "<u>underlined</u>"
+        assert (
+            html(t"<textarea>{raw_content:safe}</textarea>")
+            == "<textarea><u>underlined</u></textarea>"
+        )
 
+    def test_normal_text_unsafe(self):
+        supposedly_safe = Markup("<i>italic</i>")
+        assert (
+            html(t"<p>This is {supposedly_safe:unsafe} text.</p>")
+            == "<p>This is &lt;i&gt;italic&lt;/i&gt; text.</p>"
+        )
 
-#
-# Special aria attribute handling.
-#
-def test_aria_templated_attr_error():
-    aria1 = {"label": "close"}
-    aria2 = {"hidden": "true"}
-    with pytest.raises(TypeError):
-        node = html(t'<div aria="{aria1} {aria2}"></div>')
-        print(str(node))
-
-
-def test_aria_interpolated_attr_dict():
-    aria = {"label": "Close", "hidden": True, "another": False, "more": None}
-    node = html(t"<button aria={aria}>X</button>")
-    assert node == Element(
-        "button",
-        attrs={"aria-label": "Close", "aria-hidden": "true", "aria-another": "false"},
-        children=[Text("X")],
-    )
-    assert (
-        str(node)
-        == '<button aria-label="Close" aria-hidden="true" aria-another="false">X</button>'
-    )
+    def test_raw_text_unsafe(self):
+        # @TODO: What should even happen here?
+        supposedly_safe = "</script>"
+        assert (
+            html(t"<script>{supposedly_safe:unsafe}</script>")
+            == "<script>\\x3c/script></script>"
+        )
+        assert (
+            html(t"<script>{supposedly_safe:unsafe}</script>")
+            != "<script></script></script>"
+        )  # Sanity check
+
+    def test_escapable_raw_text_unsafe(self):
+        supposedly_safe = Markup("<i>italic</i>")
+        assert (
+            html(t"<textarea>{supposedly_safe:unsafe}</textarea>")
+            == "<textarea>&lt;i&gt;italic&lt;/i&gt;</textarea>"
+        )
 
+    def test_all_text_callback(self):
+        def get_value():
+            return "dynamic"
+
+        for tag in ("p", "script", "style"):
+            assert (
+                html(
+                    Template(f"<{tag}>")
+                    + t"The value is {get_value:callback}."
+                    + Template(f"</{tag}>")
+                )
+                == f"<{tag}>The value is dynamic.</{tag}>"
+            )
 
-def test_aria_interpolate_attr_none():
-    button_aria = None
-    node = html(t"<button aria={button_aria}>X</button>")
-    assert node == Element("button", children=[Text("X")])
-    assert str(node) == "<button>X</button>"
+    def test_callback_nonzero_callable_error(self):
+        def add(a, b):
+            return a + b
 
+        assert add(1, 2) == 3, "Make sure fixture could work..."
 
-def test_aria_attr_errors():
-    for v in [False, [], (), 0, "aria?"]:
         with pytest.raises(TypeError):
-            _ = html(t"<button aria={v}>X</button>")
-
-
-def test_aria_literal_attr_bypass():
-    # Trigger overall attribute resolution with an unrelated interpolated attr.
-    node = html(t'<p aria="passthru" id={"resolved"}></p>')
-    assert node == Element(
-        "p",
-        attrs={"aria": "passthru", "id": "resolved"},
-    ), "A single literal attribute should not trigger aria expansion."
-
-
-#
-# Special class attribute handling.
-#
-def test_interpolated_class_attribute():
-    class_list = ["btn", "btn-primary", "one two", None]
-    class_dict = {"active": True, "btn-secondary": False}
-    class_str = "blue"
-    class_space_sep_str = "green yellow"
-    class_none = None
-    class_empty_list = []
-    class_empty_dict = {}
-    button_t = (
-        t"<button "
-        t' class="red" class={class_list} class={class_dict}'
-        t" class={class_empty_list} class={class_empty_dict}"  # ignored
-        t" class={class_none}"  # ignored
-        t" class={class_str} class={class_space_sep_str}"
-        t" >Click me</button>"
-    )
-    node = html(button_t)
-    assert node == Element(
-        "button",
-        attrs={"class": "red btn btn-primary one two active blue green yellow"},
-        children=[Text("Click me")],
-    )
-    assert (
-        str(node)
-        == '<button class="red btn btn-primary one two active blue green yellow">Click me</button>'
-    )
-
-
-def test_interpolated_class_attribute_with_multiple_placeholders():
-    classes1 = ["btn", "btn-primary"]
-    classes2 = [False, None, {"active": True}]
-    node = html(t'<button class="{classes1} {classes2}">Click me</button>')
-    # CONSIDER: Is this what we want? Currently, when we have multiple
-    # placeholders in a single attribute, we treat it as a string attribute.
-    assert node == Element(
-        "button",
-        attrs={"class": "['btn', 'btn-primary'] [False, None, {'active': True}]"},
-        children=[Text("Click me")],
-    )
-
-
-def test_interpolated_attribute_spread_with_class_attribute():
-    attrs = {"id": "button1", "class": ["btn", "btn-primary"]}
-    node = html(t"<button {attrs}>Click me</button>")
-    assert node == Element(
-        "button",
-        attrs={"id": "button1", "class": "btn btn-primary"},
-        children=[Text("Click me")],
-    )
-    assert str(node) == '<button id="button1" class="btn btn-primary">Click me</button>'
-
-
-def test_class_literal_attr_bypass():
-    # Trigger overall attribute resolution with an unrelated interpolated attr.
-    node = html(t'<p class="red red" id={"veryred"}></p>')
-    assert node == Element(
-        "p",
-        attrs={"class": "red red", "id": "veryred"},
-    ), "A single literal attribute should not trigger class accumulator."
+            for tag in ("p", "script", "style"):
+                _ = html(
+                    Template(f"<{tag}>")
+                    + t"The sum is {add:callback}."
+                    + Template(f"</{tag}>")
+                )
 
 
-def test_class_none_ignored():
-    class_item = None
-    node = html(t"<p class={class_item}></p>")
-    assert node == Element("p")
-    # Also ignored inside a sequence.
-    node = html(t"<p class={[class_item]}></p>")
-    assert node == Element("p")
-
-
-def test_class_type_errors():
-    for class_item in (False, True, 0):
-        with pytest.raises(TypeError):
-            _ = html(t"<p class={class_item}></p>")
-        with pytest.raises(TypeError):
-            _ = html(t"<p class={[class_item]}></p>")
-
+# --------------------------------------------------------------------------
+# Conditional rendering and control flow
+# --------------------------------------------------------------------------
 
-def test_class_merge_literals():
-    node = html(t'<p class="red" class="blue"></p>')
-    assert node == Element("p", {"class": "red blue"})
 
+class TestUsagePatterns:
+    def test_conditional_rendering_with_if_else(self):
+        is_logged_in = True
+        user_profile = t"<span>Welcome, User!</span>"
+        login_prompt = t"<a href='/login'>Please log in</a>"
+        assert (
+            html(t"<div>{user_profile if is_logged_in else login_prompt}</div>")
+            == "<div><span>Welcome, User!</span></div>"
+        )
 
-def test_class_merge_literal_then_interpolation():
-    class_item = "blue"
-    node = html(t'<p class="red" class="{[class_item]}"></p>')
-    assert node == Element("p", {"class": "red blue"})
+        is_logged_in = False
+        assert (
+            html(t"<div>{user_profile if is_logged_in else login_prompt}</div>")
+            == '<div><a href="/login">Please log in</a></div>'
+        )
 
 
-#
-# Special style attribute handling.
-#
-def test_style_literal_attr_passthru():
-    p_id = "para1"  # non-literal attribute to cause attr resolution
-    node = html(t'<p style="color: red" id={p_id}>Warning!</p>')
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red", "id": "para1"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red" id="para1">Warning!</p>'
+# --------------------------------------------------------------------------
+# Attributes
+# --------------------------------------------------------------------------
+class TestLiteralAttribute:
+    """Test literal (non-dynamic) attributes."""
+
+    def test_literal_attrs(self):
+        assert (
+            html(
+                t"<a "
+                t" id=example_link"  # no quotes required if value has no surrounding whitespace
+                t" autofocus"  # bare / boolean
+                t' title=""'  # empty attribute
+                t' href="https://example.com" target="_blank"'
+                t"></a>"
+            )
+            == '<a id="example_link" autofocus title="" href="https://example.com" target="_blank"></a>'
+        )
 
+    def test_literal_attr_escaped(self):
+        assert (
+            html(t'<a title="&lt;&gt;&amp;&#39;&#34;"></a>')
+            == '<a title="&lt;&gt;&amp;&#39;&#34;"></a>'
+        )
 
-def test_style_in_interpolated_attr():
-    styles = {"color": "red", "font-weight": "bold", "font-size": "16px"}
-    node = html(t"<p style={styles}>Warning!</p>")
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red; font-weight: bold; font-size: 16px"},
-        children=[Text("Warning!")],
-    )
-    assert (
-        str(node)
-        == '<p style="color: red; font-weight: bold; font-size: 16px">Warning!</p>'
-    )
 
+class TestInterpolatedAttribute:
+    """Test interpolated attributes, entire value is an exact interpolation."""
 
-def test_style_in_templated_attr():
-    color = "red"
-    node = html(t'<p style="color: {color}">Warning!</p>')
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red">Warning!</p>'
+    def test_interpolated_attr(self):
+        url = "https://example.com/"
+        assert html(t'<a href="{url}"></a>') == '<a href="https://example.com/"></a>'
 
+    def test_interpolated_attr_escaped(self):
+        url = 'https://example.com/?q="test"&lang=en'
+        assert (
+            html(t'<a href="{url}"></a>')
+            == '<a href="https://example.com/?q=&#34;test&#34;&amp;lang=en"></a>'
+        )
 
-def test_style_in_spread_attr():
-    attrs = {"style": {"color": "red"}}
-    node = html(t"<p {attrs}>Warning!</p>")
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red">Warning!</p>'
+    def test_interpolated_attr_unquoted(self):
+        id = "roquefort"
+        assert html(t"<div id={id}></div>") == '<div id="roquefort"></div>'
 
+    def test_interpolated_attr_true(self):
+        disabled = True
+        assert (
+            html(t"<button disabled={disabled}></button>")
+            == "<button disabled></button>"
+        )
 
-def test_style_merged_from_all_attrs():
-    attrs = {"style": {"font-size": "15px"}}
-    style = {"font-weight": "bold"}
-    color = "red"
-    node = html(
-        t'<p style="font-family: serif" style="color: {color}" style={style} {attrs}></p>'
-    )
-    assert node == Element(
-        "p",
-        {"style": "font-family: serif; color: red; font-weight: bold; font-size: 15px"},
-    )
-    assert (
-        str(node)
-        == '<p style="font-family: serif; color: red; font-weight: bold; font-size: 15px"></p>'
-    )
+    def test_interpolated_attr_false(self):
+        disabled = False
+        assert html(t"<button disabled={disabled}></button>") == "<button></button>"
 
+    def test_interpolated_attr_none(self):
+        disabled = None
+        assert html(t"<button disabled={disabled}></button>") == "<button></button>"
 
-def test_style_override_left_to_right():
-    suffix = t"></p>"
-    cb_dict = {"color": "blue"}
-    scy_dict = {"style": {"color": "yellow"}}
-    parts = [
-        (t'<p style="color: red"', "color: red"),
-        (t" style={cb_dict}", "color: blue"),
-        (t''' style="color: {"green"}"''', "color: green"),
-        (t""" {scy_dict}""", "color: yellow"),
-    ]
-    for index in range(len(parts)):
-        expected_style = parts[index][1]
-        t = sum((part[0] for part in parts[: index + 1]), t"") + suffix
-        node = html(t)
-        assert node == Element("p", {"style": expected_style})
-        assert str(node) == f'<p style="{expected_style}"></p>'
-
-
-def test_interpolated_style_attribute_multiple_placeholders():
-    styles1 = {"color": "red"}
-    styles2 = {"font-weight": "bold"}
-    # CONSIDER: Is this what we want? Currently, when we have multiple
-    # placeholders in a single attribute, we treat it as a string attribute
-    # which produces an invalid style attribute.
-    with pytest.raises(ValueError):
-        _ = html(t"<p style='{styles1} {styles2}'>Warning!</p>")
-
-
-def test_interpolated_style_attribute_merged():
-    styles1 = {"color": "red"}
-    styles2 = {"font-weight": "bold"}
-    node = html(t"<p style={styles1} style={styles2}>Warning!</p>")
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red; font-weight: bold"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red; font-weight: bold">Warning!</p>'
+    def test_interpolate_attr_empty_string(self):
+        assert html(t'<div title=""></div>') == '<div title=""></div>'
 
 
-def test_interpolated_style_attribute_merged_override():
-    styles1 = {"color": "red", "font-weight": "normal"}
-    styles2 = {"font-weight": "bold"}
-    node = html(t"<p style={styles1} style={styles2}>Warning!</p>")
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red; font-weight: bold"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red; font-weight: bold">Warning!</p>'
+class TestSpreadAttribute:
+    """Test spread attributes."""
 
+    def test_spread_attr(self):
+        attrs = {"href": "https://example.com/", "target": "_blank"}
+        assert (
+            html(t"<a {attrs}></a>")
+            == '<a href="https://example.com/" target="_blank"></a>'
+        )
 
-def test_style_attribute_str():
-    styles = "color: red; font-weight: bold;"
-    node = html(t"<p style={styles}>Warning!</p>")
-    assert node == Element(
-        "p",
-        attrs={"style": "color: red; font-weight: bold"},
-        children=[Text("Warning!")],
-    )
-    assert str(node) == '<p style="color: red; font-weight: bold">Warning!</p>'
+    def test_spread_attr_none(self):
+        attrs = None
+        assert html(t"<a {attrs}></a>") == "<a></a>"
+
+    def test_spread_attr_type_errors(self):
+        for attrs in (0, [], (), False, True):
+            with pytest.raises(TypeError):
+                _ = html(t"<a {attrs}></a>")
+
+
+class TestTemplatedAttribute:
+    def test_templated_attr_mixed_interpolations_start_end_and_nest(self):
+        left, middle, right = 1, 3, 5
+        prefix, suffix = t'<div data-range="', t'"></div>'
+        # Check interpolations at start, middle and/or end of templated attr
+        # or a combination of those to make sure text is not getting dropped.
+        for left_part, middle_part, right_part in product(
+            (t"{left}", Template(str(left))),
+            (t"{middle}", Template(str(middle))),
+            (t"{right}", Template(str(right))),
+        ):
+            test_t = (
+                prefix + left_part + t"-" + middle_part + t"-" + right_part + suffix
+            )
+            assert html(test_t) == '<div data-range="1-3-5"></div>'
+
+    def test_templated_attr_no_quotes(self):
+        start = 1
+        end = 5
+        assert (
+            html(t"<div data-range={start}-{end}></div>")
+            == '<div data-range="1-5"></div>'
+        )
 
 
-def test_style_attribute_non_str_non_dict():
-    with pytest.raises(TypeError):
-        styles = [1, 2]
-        _ = html(t"<p style={styles}>Warning!</p>")
+class TestAttributeMerging:
+    def test_attr_merge_disjoint_interpolated_attr_spread_attr(self):
+        attrs = {"href": "https://example.com/", "id": "link1"}
+        target = "_blank"
+        assert (
+            html(t"<a {attrs} target={target}></a>")
+            == '<a href="https://example.com/" id="link1" target="_blank"></a>'
+        )
 
+    def test_attr_merge_overlapping_spread_attrs(self):
+        attrs1 = {"href": "https://example.com/", "id": "overwrtten"}
+        attrs2 = {"target": "_blank", "id": "link1"}
+        assert (
+            html(t"<a {attrs1} {attrs2}></a>")
+            == '<a href="https://example.com/" target="_blank" id="link1"></a>'
+        )
 
-def test_style_literal_attr_bypass():
-    # Trigger overall attribute resolution with an unrelated interpolated attr.
-    node = html(t'<p style="invalid;invalid:" id={"resolved"}></p>')
-    assert node == Element(
-        "p",
-        attrs={"style": "invalid;invalid:", "id": "resolved"},
-    ), "A single literal attribute should bypass style accumulator."
+    def test_attr_merge_replace_literal_attr_str_str(self):
+        assert (
+            html(t'<div title="default" { {"title": "fresh"} }></div>')
+            == '<div title="fresh"></div>'
+        )
 
+    def test_attr_merge_replace_literal_attr_str_true(self):
+        assert (
+            html(t'<div title="default" { {"title": True} }></div>')
+            == "<div title></div>"
+        )
 
-def test_style_none():
-    styles = None
-    node = html(t"<p style={styles}></p>")
-    assert node == Element("p")
+    def test_attr_merge_replace_literal_attr_true_str(self):
+        assert (
+            html(t"<div title { {'title': 'fresh'} }></div>")
+            == '<div title="fresh"></div>'
+        )
 
+    def test_attr_merge_remove_literal_attr_str_none(self):
+        assert html(t'<div title="default" { {"title": None} }></div>') == "<div></div>"
 
-# --------------------------------------------------------------------------
-# Function component interpolation tests
-# --------------------------------------------------------------------------
+    def test_attr_merge_remove_literal_attr_true_none(self):
+        assert html(t"<div title { {'title': None} }></div>") == "<div></div>"
 
+    def test_attr_merge_other_literal_attr_intact(self):
+        assert (
+            html(t'<img title="default" { {"alt": "fresh"} }>')
+            == '<img title="default" alt="fresh" />'
+        )
 
-def FunctionComponent(
-    children: Iterable[Node], first: str, second: int, third_arg: str, **attrs: t.Any
-) -> Template:
-    # Ensure type correctness of props at runtime for testing purposes
-    assert isinstance(first, str)
-    assert isinstance(second, int)
-    assert isinstance(third_arg, str)
-    new_attrs = {
-        "id": third_arg,
-        "data": {"first": first, "second": second},
-        **attrs,
-    }
-    return t"<div {new_attrs}>Component: {children}</div>"
 
+class TestSpecialDataAttribute:
+    """Special data attribute handling."""
+
+    def test_interpolated_data_attributes(self):
+        data = {
+            "user-id": 123,
+            "role": "admin",
+            "wild": True,
+            "false": False,
+            "none": None,
+        }
+        assert (
+            html(t"<div data={data}>User Info</div>")
+            == '<div data-user-id="123" data-role="admin" data-wild>User Info</div>'
+        )
 
-def test_interpolated_template_component():
-    node = html(
-        t'<{FunctionComponent} first=1 second={99} third-arg="comp1" class="my-comp">Hello, Component!</{FunctionComponent}>'
-    )
-    assert node == Element(
-        "div",
-        attrs={
-            "id": "comp1",
-            "data-first": "1",
-            "data-second": "99",
-            "class": "my-comp",
-        },
-        children=[Text("Component: "), Text("Hello, Component!")],
-    )
-    assert (
-        str(node)
-        == '<div id="comp1" data-first="1" data-second="99" class="my-comp">Component: Hello, Component!</div>'
-    )
+    def test_data_attr_toggle_to_str(self):
+        for res in [
+            html(t"<div data-selected data={ {'selected': 'yes'} }></div>"),
+            html(t'<div data-selected="no" data={ {"selected": "yes"} }></div>'),
+        ]:
+            assert res == '<div data-selected="yes"></div>'
 
+    def test_data_attr_toggle_to_true(self):
+        res = html(t'<div data-selected="yes" data={ {"selected": True} }></div>')
+        assert res == "<div data-selected></div>"
 
-def test_interpolated_template_component_no_children_provided():
-    """Same test, but the caller didn't provide any children."""
-    node = html(
-        t'<{FunctionComponent} first=1 second={99} third-arg="comp1" class="my-comp" />'
-    )
-    assert node == Element(
-        "div",
-        attrs={
-            "id": "comp1",
-            "data-first": "1",
-            "data-second": "99",
-            "class": "my-comp",
-        },
-        children=[
-            Text("Component: "),
-        ],
-    )
-    assert (
-        str(node)
-        == '<div id="comp1" data-first="1" data-second="99" class="my-comp">Component: </div>'
-    )
+    def test_data_attr_unrelated_unaffected(self):
+        res = html(t"<div data-selected data={ {'active': True} }></div>")
+        assert res == "<div data-selected data-active></div>"
 
+    def test_data_attr_templated_error(self):
+        data1 = {"user-id": "user-123"}
+        data2 = {"role": "admin"}
+        with pytest.raises(TypeError):
+            _ = html(t'<div data="{data1} {data2}"></div>')
+
+    def test_data_attr_none(self):
+        button_data = None
+        res = html(t"<button data={button_data}>X</button>")
+        assert res == "<button>X</button>"
+
+    def test_data_attr_errors(self):
+        for v in [False, [], (), 0, "data?"]:
+            with pytest.raises(TypeError):
+                _ = html(t"<button data={v}>X</button>")
+
+    def test_data_literal_attr_bypass(self):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = html(t'<p data="passthru" id={"resolved"}></p>')
+        assert res == '<p data="passthru" id="resolved"></p>', (
+            "A single literal attribute should not trigger data expansion."
+        )
 
-def test_invalid_component_invocation():
-    with pytest.raises(TypeError):
-        _ = html(t"<{FunctionComponent}>Missing props</{FunctionComponent}>")
 
+class TestSpecialAriaAttribute:
+    """Special aria attribute handling."""
 
-def test_prep_component_kwargs_named():
-    def InputElement(size=10, type="text"):
-        pass
+    def test_aria_templated_attr_error(self):
+        aria1 = {"label": "close"}
+        aria2 = {"hidden": "true"}
+        with pytest.raises(TypeError):
+            _ = html(t'<div aria="{aria1} {aria2}"></div>')
+
+    def test_aria_interpolated_attr_dict(self):
+        aria = {"label": "Close", "hidden": True, "another": False, "more": None}
+        res = html(t"<button aria={aria}>X</button>")
+        assert (
+            res
+            == '<button aria-label="Close" aria-hidden="true" aria-another="false">X</button>'
+        )
 
-    callable_info = get_callable_info(InputElement)
-    assert _prep_component_kwargs(callable_info, {"size": 20}, system_kwargs={}) == {
-        "size": 20
-    }
-    assert _prep_component_kwargs(
-        callable_info, {"type": "email"}, system_kwargs={}
-    ) == {"type": "email"}
-    assert _prep_component_kwargs(callable_info, {}, system_kwargs={}) == {}
-
-
-def FunctionComponentNoChildren(first: str, second: int, third_arg: str) -> Template:
-    # Ensure type correctness of props at runtime for testing purposes
-    assert isinstance(first, str)
-    assert isinstance(second, int)
-    assert isinstance(third_arg, str)
-    new_attrs = {
-        "id": third_arg,
-        "data": {"first": first, "second": second},
-    }
-    return t"<div {new_attrs}>Component: ignore children</div>"
+    def test_aria_interpolate_attr_none(self):
+        button_aria = None
+        res = html(t"<button aria={button_aria}>X</button>")
+        assert res == "<button>X</button>"
+
+    def test_aria_attr_errors(self):
+        for v in [False, [], (), 0, "aria?"]:
+            with pytest.raises(TypeError):
+                _ = html(t"<button aria={v}>X</button>")
+
+    def test_aria_literal_attr_bypass(self):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = html(t'<p aria="passthru" id={"resolved"}></p>')
+        assert res == '<p aria="passthru" id="resolved"></p>', (
+            "A single literal attribute should not trigger aria expansion."
+        )
 
 
-def test_interpolated_template_component_ignore_children():
-    node = html(
-        t'<{FunctionComponentNoChildren} first=1 second={99} third-arg="comp1">Hello, Component!</{FunctionComponentNoChildren}>'
-    )
-    assert node == Element(
-        "div",
-        attrs={
-            "id": "comp1",
-            "data-first": "1",
-            "data-second": "99",
-        },
-        children=[Text(text="Component: ignore children")],
-    )
-    assert (
-        str(node)
-        == '<div id="comp1" data-first="1" data-second="99">Component: ignore children</div>'
-    )
+class TestSpecialClassAttribute:
+    """Special class attribute handling."""
+
+    def test_interpolated_class_attribute(self):
+        class_list = ["btn", "btn-primary", "one two", None]
+        class_dict = {"active": True, "btn-secondary": False}
+        class_str = "blue"
+        class_space_sep_str = "green yellow"
+        class_none = None
+        class_empty_list = []
+        class_empty_dict = {}
+        button_t = (
+            t"<button "
+            t' class="red" class={class_list} class={class_dict}'
+            t" class={class_empty_list} class={class_empty_dict}"  # ignored
+            t" class={class_none}"  # ignored
+            t" class={class_str} class={class_space_sep_str}"
+            t" >Click me</button>"
+        )
+        res = html(button_t)
+        assert (
+            res
+            == '<button class="red btn btn-primary one two active blue green yellow">Click me</button>'
+        )
 
+    def test_interpolated_class_attribute_with_multiple_placeholders(self):
+        classes1 = ["btn", "btn-primary"]
+        classes2 = [None, {"active": True}]
+        res = html(t'<button class="{classes1} {classes2}">Click me</button>')
+        # CONSIDER: Is this what we want? Currently, when we have multiple
+        # placeholders in a single attribute, we treat it as a string attribute.
+        assert (
+            res
+            == f'<button class="{escape_html_text(str(classes1))} {escape_html_text(str(classes2))}">Click me</button>'
+        ), (
+            "Interpolations that are not exact, or singletons, are instead interpreted as templates and therefore these dictionaries are strified."
+        )
 
-def FunctionComponentKeywordArgs(first: str, **attrs: t.Any) -> Template:
-    # Ensure type correctness of props at runtime for testing purposes
-    assert isinstance(first, str)
-    assert "children" in attrs
-    _ = attrs.pop("children")
-    new_attrs = {"data-first": first, **attrs}
-    return t"<div {new_attrs}>Component with kwargs</div>"
+    def test_interpolated_attribute_spread_with_class_attribute(self):
+        attrs = {"id": "button1", "class": ["btn", "btn-primary"]}
+        res = html(t"<button {attrs}>Click me</button>")
+        assert res == '<button id="button1" class="btn btn-primary">Click me</button>'
 
+    def test_class_literal_attr_bypass(self):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = html(t'<p class="red red" id={"veryred"}></p>')
+        assert res == '<p class="red red" id="veryred"></p>', (
+            "A single literal attribute should not trigger class accumulator."
+        )
 
-def test_children_always_passed_via_kwargs():
-    node = html(
-        t'<{FunctionComponentKeywordArgs} first="value" extra="info">Child content</{FunctionComponentKeywordArgs}>'
-    )
-    assert node == Element(
-        "div",
-        attrs={
-            "data-first": "value",
-            "extra": "info",
-        },
-        children=[Text("Component with kwargs")],
-    )
-    assert (
-        str(node) == '<div data-first="value" extra="info">Component with kwargs</div>'
-    )
+    def test_class_none_ignored(self):
+        class_item = None
+        res = html(t"<p class={class_item}></p>")
+        assert res == "<p></p>"
+        # Also ignored inside a sequence.
+        res = html(t"<p class={[class_item]}></p>")
+        assert res == "<p></p>"
+
+    def test_class_type_errors(self):
+        for class_item in (False, True, 0):
+            with pytest.raises(TypeError):
+                _ = html(t"<p class={class_item}></p>")
+            with pytest.raises(TypeError):
+                _ = html(t"<p class={[class_item]}></p>")
+
+    def test_class_merge_literals(self):
+        res = html(t'<p class="red" class="blue"></p>')
+        assert res == '<p class="red blue"></p>'
+
+    def test_class_merge_literal_then_interpolation(self):
+        class_item = "blue"
+        res = html(t'<p class="red" class="{[class_item]}"></p>')
+        assert res == '<p class="red blue"></p>'
+
+
+class TestSpecialStyleAttribute:
+    """Special style attribute handling."""
+
+    def test_style_literal_attr_passthru(self):
+        p_id = "para1"  # non-literal attribute to cause attr resolution
+        res = html(t'<p style="color: red" id={p_id}>Warning!</p>')
+        assert res == '<p style="color: red" id="para1">Warning!</p>'
+
+    def test_style_in_interpolated_attr(self):
+        styles = {"color": "red", "font-weight": "bold", "font-size": "16px"}
+        res = html(t"<p style={styles}>Warning!</p>")
+        assert (
+            res
+            == '<p style="color: red; font-weight: bold; font-size: 16px">Warning!</p>'
+        )
 
+    def test_style_in_templated_attr(self):
+        color = "red"
+        res = html(t'<p style="color: {color}">Warning!</p>')
+        assert res == '<p style="color: red">Warning!</p>'
+
+    def test_style_in_spread_attr(self):
+        attrs = {"style": {"color": "red"}}
+        res = html(t"<p {attrs}>Warning!</p>")
+        assert res == '<p style="color: red">Warning!</p>'
+
+    def test_style_merged_from_all_attrs(self):
+        attrs = {"style": "font-size: 15px"}
+        style = {"font-weight": "bold"}
+        color = "red"
+        res = html(
+            t'<p style="font-family: serif" style="color: {color}" style={style} {attrs}></p>'
+        )
+        assert (
+            res
+            == '<p style="font-family: serif; color: red; font-weight: bold; font-size: 15px"></p>'
+        )
 
-def test_children_always_passed_via_kwargs_even_when_empty():
-    node = html(t'<{FunctionComponentKeywordArgs} first="value" extra="info" />')
-    assert node == Element(
-        "div",
-        attrs={
-            "data-first": "value",
-            "extra": "info",
-        },
-        children=[Text("Component with kwargs")],
-    )
-    assert (
-        str(node) == '<div data-first="value" extra="info">Component with kwargs</div>'
-    )
+    def test_style_override_left_to_right(self):
+        suffix = t"></p>"
+        parts = [
+            (t'<p style="color: red"', "color: red"),
+            (t" style={ {'color': 'blue'} }", "color: blue"),
+            (t' style="color: {"green"}"', "color: green"),
+            (t""" { {"style": {"color": "yellow"}} }""", "color: yellow"),
+        ]
+        for index in range(len(parts)):
+            expected_style = parts[index][1]
+            t = sum((part[0] for part in parts[: index + 1]), t"") + suffix
+            res = html(t)
+            assert res == f'<p style="{expected_style}"></p>'
+
+    def test_interpolated_style_attribute_multiple_placeholders(self):
+        styles1 = {"color": "red"}
+        styles2 = {"font-weight": "bold"}
+        # CONSIDER: Is this what we want? Currently, when we have multiple
+        # placeholders in a single attribute, we treat it as a string attribute
+        # which produces an invalid style attribute.
+        with pytest.raises(ValueError):
+            _ = html(t"<p style='{styles1} {styles2}'>Warning!</p>")
+
+    def test_interpolated_style_attribute_merged(self):
+        styles1 = {"color": "red"}
+        styles2 = {"font-weight": "bold"}
+        res = html(t"<p style={styles1} style={styles2}>Warning!</p>")
+        assert res == '<p style="color: red; font-weight: bold">Warning!</p>'
+
+    def test_interpolated_style_attribute_merged_override(self):
+        styles1 = {"color": "red", "font-weight": "normal"}
+        styles2 = {"font-weight": "bold"}
+        res = html(t"<p style={styles1} style={styles2}>Warning!</p>")
+        assert res == '<p style="color: red; font-weight: bold">Warning!</p>'
+
+    def test_style_attribute_str(self):
+        styles = "color: red; font-weight: bold;"
+        res = html(t"<p style={styles}>Warning!</p>")
+        assert res == '<p style="color: red; font-weight: bold">Warning!</p>'
+
+    def test_style_attribute_non_str_non_dict(self):
+        with pytest.raises(TypeError):
+            styles = [1, 2]
+            _ = html(t"<p style={styles}>Warning!</p>")
+
+    def test_style_literal_attr_bypass(self):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = html(t'<p style="invalid;invalid:" id={"resolved"}></p>')
+        assert res == '<p style="invalid;invalid:" id="resolved"></p>', (
+            "A single literal attribute should bypass style accumulator."
+        )
 
+    def test_style_none(self):
+        styles = None
+        res = html(t"<p style={styles}></p>")
+        assert res == "<p></p>"
+
+
+class TestPrepComponentKwargs:
+    def test_named(self):
+        def InputElement(size=10, type="text"):
+            pass
+
+        callable_info = get_callable_info(InputElement)
+        assert prep_component_kwargs(callable_info, {"size": 20}, children=t"") == {
+            "size": 20
+        }
+        assert prep_component_kwargs(
+            callable_info, {"type": "email"}, children=t""
+        ) == {"type": "email"}
+        assert prep_component_kwargs(callable_info, {}, children=t"") == {}
+
+    @pytest.mark.skip("Should we just ignore unused user-specified kwargs?")
+    def test_unused_kwargs(self):
+        def InputElement(size=10, type="text"):
+            pass
+
+        callable_info = get_callable_info(InputElement)
+        with pytest.raises(ValueError):
+            assert (
+                prep_component_kwargs(callable_info, {"type2": 15}, children=t"") == {}
+            )
 
-def ColumnsComponent() -> Template:
-    return t"""<td>Column 1</td><td>Column 2</td>"""
-
-
-def test_fragment_from_component():
-    # This test assumes that if a component returns a template that parses
-    # into multiple root elements, they are treated as a fragment.
-    node = html(t"<table><tr><{ColumnsComponent} /></tr></table>")
-    assert node == Element(
-        "table",
-        children=[
-            Element(
-                "tr",
-                children=[
-                    Element("td", children=[Text("Column 1")]),
-                    Element("td", children=[Text("Column 2")]),
-                ],
-            ),
-        ],
-    )
-    assert str(node) == "<table><tr><td>Column 1</td><td>Column 2</td></tr></table>"
+    def test_accepts_children(self):
+        def DivWrapper(
+            children: Template, add_classes: list[str] | None = None
+        ) -> Template:
+            return t"<div class={add_classes}>{children}</div>"
+
+        callable_info = get_callable_info(DivWrapper)
+        kwargs = prep_component_kwargs(callable_info, {}, children=t"")
+        assert tuple(kwargs.keys()) == ("children",)
+        assert isinstance(kwargs["children"], Template) and kwargs[
+            "children"
+        ].strings == ("",)
+
+        add_classes = ["red"]
+        kwargs = prep_component_kwargs(
+            callable_info, {"add_classes": add_classes}, children=t"<span></span>"
+        )
+        assert set(kwargs.keys()) == {"children", "add_classes"}
+        assert isinstance(kwargs["children"], Template) and kwargs[
+            "children"
+        ].strings == ("<span></span>",)
+        assert kwargs["add_classes"] == add_classes
+
+    def test_no_children(self):
+        def SpanMaker(content_text: str) -> Template:
+            return t"<span>{content_text}</span>"
+
+        callable_info = get_callable_info(SpanMaker)
+        content_text = "inner"
+        kwargs = prep_component_kwargs(
+            callable_info, {"content_text": content_text}, children=t"<div></div>"
+        )
+        assert kwargs == {"content_text": content_text}  # no children
 
 
-def test_component_passed_as_attr_value():
-    def Wrapper(
-        children: Iterable[Node], sub_component: Callable, **attrs: t.Any
+class TestFunctionComponent:
+    @staticmethod
+    def FunctionComponent(
+        children: Template, first: str, second: int, third_arg: str, **attrs: t.Any
     ) -> Template:
-        return t"<{sub_component} {attrs}>{children}</{sub_component}>"
-
-    node = html(
-        t'<{Wrapper} sub-component={FunctionComponent} class="wrapped" first=1 second={99} third-arg="comp1"><p>Inside wrapper</p></{Wrapper}>'
-    )
-    assert node == Element(
-        "div",
-        attrs={
-            "id": "comp1",
-            "data-first": "1",
-            "data-second": "99",
-            "class": "wrapped",
-        },
-        children=[Text("Component: "), Element("p", children=[Text("Inside wrapper")])],
-    )
-    assert (
-        str(node)
-        == '<div id="comp1" data-first="1" data-second="99" class="wrapped">Component: <p>Inside wrapper</p></div>'
-    )
-
-
-def test_nested_component_gh23():
-    # See https://github.com/t-strings/tdom/issues/23 for context
-    def Header():
-        return html(t"{'Hello World'}")
-
-    node = html(t"<{Header} />")
-    assert node == Text("Hello World")
-    assert str(node) == "Hello World"
-
-
-def test_component_returning_iterable():
-    def Items() -> Iterable:
-        for i in range(2):
-            yield t"<li>Item {i + 1}</li>"
-        yield html(t"<li>Item {3}</li>")
-
-    node = html(t"<ul><{Items} /></ul>")
-    assert node == Element(
-        "ul",
-        children=[
-            Element("li", children=[Text("Item "), Text("1")]),
-            Element("li", children=[Text("Item "), Text("2")]),
-            Element("li", children=[Text("Item "), Text("3")]),
-        ],
-    )
-    assert str(node) == "<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>"
+        # Ensure type correctness of props at runtime for testing purposes
+        assert isinstance(first, str)
+        assert isinstance(second, int)
+        assert isinstance(third_arg, str)
+        new_attrs = {
+            "id": third_arg,
+            "data": {"first": first, "second": second},
+            **attrs,
+        }
+        return t"<div {new_attrs}>Component: {children}</div>"
+
+    def test_with_children(self):
+        res = html(
+            t'<{self.FunctionComponent} first=1 second={99} third-arg="comp1" class="my-comp">Hello, Component!</{self.FunctionComponent}>'
+        )
+        assert (
+            res
+            == '<div id="comp1" data-first="1" data-second="99" class="my-comp">Component: Hello, Component!</div>'
+        )
 
+    def test_with_no_children(self):
+        """Same test, but the caller didn't provide any children."""
+        res = html(
+            t'<{self.FunctionComponent} first=1 second={99} third-arg="comp1" class="my-comp" />'
+        )
+        assert (
+            res
+            == '<div id="comp1" data-first="1" data-second="99" class="my-comp">Component: </div>'
+        )
 
-def test_component_returning_fragment():
-    def Items() -> Node:
-        return html(t"<li>Item {1}</li><li>Item {2}</li><li>Item {3}</li>")
+    def test_missing_props_error(self):
+        with pytest.raises(TypeError):
+            _ = html(
+                t"<{self.FunctionComponent}>Missing props</{self.FunctionComponent}>"
+            )
 
-    node = html(t"<ul><{Items} /></ul>")
-    assert node == Element(
-        "ul",
-        children=[
-            Element("li", children=[Text("Item "), Text("1")]),
-            Element("li", children=[Text("Item "), Text("2")]),
-            Element("li", children=[Text("Item "), Text("3")]),
-        ],
-    )
-    assert str(node) == "<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>"
 
+class TestFunctionComponentNoChildren:
+    @staticmethod
+    def FunctionComponentNoChildren(
+        first: str, second: int, third_arg: str
+    ) -> Template:
+        # Ensure type correctness of props at runtime for testing purposes
+        assert isinstance(first, str)
+        assert isinstance(second, int)
+        assert isinstance(third_arg, str)
+        new_attrs = {
+            "id": third_arg,
+            "data": {"first": first, "second": second},
+        }
+        return t"<div {new_attrs}>Component: ignore children</div>"
+
+    def test_interpolated_template_component_ignore_children(self):
+        res = html(
+            t'<{self.FunctionComponentNoChildren} first=1 second={99} third-arg="comp1">Hello, Component!</{self.FunctionComponentNoChildren}>'
+        )
+        assert (
+            res
+            == '<div id="comp1" data-first="1" data-second="99">Component: ignore children</div>'
+        )
 
-@dataclass
-class ClassComponent:
-    """Example class-based component."""
 
-    user_name: str
-    image_url: str
-    homepage: str = "#"
-    children: Iterable[Node] = field(default_factory=list)
+class TestFunctionComponentKeywordArgs:
+    @staticmethod
+    def FunctionComponentKeywordArgs(first: str, **attrs: t.Any) -> Template:
+        # Ensure type correctness of props at runtime for testing purposes
+        assert isinstance(first, str)
+        assert "children" in attrs
+        children = attrs.pop("children")
+        new_attrs = {"data-first": first, **attrs}
+        return t"<div {new_attrs}>Component with kwargs: {children}</div>"
 
-    def __call__(self) -> Node:
-        return html(
-            t"<div class='avatar'>"
-            t"<a href={self.homepage}>"
-            t"<img src='{self.image_url}' alt='{f'Avatar of {self.user_name}'}' />"
-            t"</a>"
-            t"<span>{self.user_name}</span>"
-            t"{self.children}"
-            t"</div>",
+    def test_children_always_passed_via_kwargs(self):
+        res = html(
+            t'<{self.FunctionComponentKeywordArgs} first="value" extra="info">Child content</{self.FunctionComponentKeywordArgs}>'
+        )
+        assert (
+            res
+            == '<div data-first="value" extra="info">Component with kwargs: Child content</div>'
         )
 
+    def test_children_always_passed_via_kwargs_even_when_empty(self):
+        res = html(
+            t'<{self.FunctionComponentKeywordArgs} first="value" extra="info" />'
+        )
+        assert (
+            res == '<div data-first="value" extra="info">Component with kwargs: </div>'
+        )
 
-def test_class_component_implicit_invocation_with_children():
-    node = html(
-        t"<{ClassComponent} user-name='Alice' image-url='https://example.com/alice.png'>Fun times!</{ClassComponent}>"
-    )
-    assert node == Element(
-        "div",
-        attrs={"class": "avatar"},
-        children=[
-            Element(
-                "a",
-                attrs={"href": "#"},
-                children=[
-                    Element(
-                        "img",
-                        attrs={
-                            "src": "https://example.com/alice.png",
-                            "alt": "Avatar of Alice",
-                        },
-                    )
-                ],
-            ),
-            Element("span", children=[Text("Alice")]),
-            Text("Fun times!"),
-        ],
-    )
-    assert (
-        str(node)
-        == '<div class="avatar"><a href="#"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span>Fun times!</div>'
-    )
-
-
-def test_class_component_direct_invocation():
-    avatar = ClassComponent(
-        user_name="Alice",
-        image_url="https://example.com/alice.png",
-        homepage="https://example.com/users/alice",
-    )
-    node = html(t"<{avatar} />")
-    assert node == Element(
-        "div",
-        attrs={"class": "avatar"},
-        children=[
-            Element(
-                "a",
-                attrs={"href": "https://example.com/users/alice"},
-                children=[
-                    Element(
-                        "img",
-                        attrs={
-                            "src": "https://example.com/alice.png",
-                            "alt": "Avatar of Alice",
-                        },
-                    )
-                ],
-            ),
-            Element("span", children=[Text("Alice")]),
-        ],
-    )
-    assert (
-        str(node)
-        == '<div class="avatar"><a href="https://example.com/users/alice"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span></div>'
-    )
 
+class TestComponentSpecialUsage:
+    @staticmethod
+    def ColumnsComponent() -> Template:
+        return t"""<td>Column 1</td><td>Column 2</td>"""
 
-@dataclass
-class ClassComponentNoChildren:
-    """Example class-based component that does not ask for children."""
+    def test_fragment_from_component(self):
+        # This test assumes that if a component returns a template that parses
+        # into multiple root elements, they are treated as a fragment.
+        res = html(t"<table><tr><{self.ColumnsComponent} /></tr></table>")
+        assert res == "<table><tr><td>Column 1</td><td>Column 2</td></tr></table>"
 
-    user_name: str
-    image_url: str
-    homepage: str = "#"
+    def test_component_passed_as_attr_value(self):
+        def Wrapper(
+            children: Template, sub_component: Callable, **attrs: t.Any
+        ) -> Template:
+            return t"<{sub_component} {attrs}>{children}</{sub_component}>"
 
-    def __call__(self) -> Node:
-        return html(
-            t"<div class='avatar'>"
-            t"<a href={self.homepage}>"
-            t"<img src='{self.image_url}' alt='{f'Avatar of {self.user_name}'}' />"
-            t"</a>"
-            t"<span>{self.user_name}</span>"
-            t"ignore children"
-            t"</div>",
+        res = html(
+            t'<{Wrapper} sub-component={TestFunctionComponent.FunctionComponent} class="wrapped" first=1 second={99} third-arg="comp1"><p>Inside wrapper</p></{Wrapper}>'
+        )
+        assert (
+            res
+            == '<div id="comp1" data-first="1" data-second="99" class="wrapped">Component: <p>Inside wrapper</p></div>'
         )
 
+    def test_nested_component_gh23(self):
+        # @DESIGN: Do we need this?  Should we recommend an alternative?
+        # See https://github.com/t-strings/tdom/issues/23 for context
+        def Header() -> Template:
+            return t"{'Hello World'}"
+
+        res = html(t"<{Header} />", assume_ctx=make_ctx(parent_tag="div"))
+        assert res == "Hello World"
+
+
+class TestClassComponent:
+    @dataclass
+    class ClassComponent:
+        """Example class-based component."""
+
+        user_name: str
+        image_url: str
+        children: Template
+        homepage: str = "#"
+
+        def __call__(self) -> Template:
+            return (
+                t"<div class='avatar'>"
+                t"<a href={self.homepage}>"
+                t"<img src='{self.image_url}' alt='{f'Avatar of {self.user_name}'}' />"
+                t"</a>"
+                t"<span>{self.user_name}</span>"
+                t"{self.children}"
+                t"</div>"
+            )
 
-def test_class_component_implicit_invocation_ignore_children():
-    node = html(
-        t"<{ClassComponentNoChildren} user-name='Alice' image-url='https://example.com/alice.png'>Fun times!</{ClassComponentNoChildren}>"
-    )
-    assert node == Element(
-        "div",
-        attrs={"class": "avatar"},
-        children=[
-            Element(
-                "a",
-                attrs={"href": "#"},
-                children=[
-                    Element(
-                        "img",
-                        attrs={
-                            "src": "https://example.com/alice.png",
-                            "alt": "Avatar of Alice",
-                        },
-                    )
-                ],
-            ),
-            Element("span", children=[Text("Alice")]),
-            Text("ignore children"),
-        ],
-    )
-    assert (
-        str(node)
-        == '<div class="avatar"><a href="#"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span>ignore children</div>'
-    )
+    def test_class_component_implicit_invocation_with_children(self):
+        res = html(
+            t"<{self.ClassComponent} user-name='Alice' image-url='https://example.com/alice.png'>Fun times!</{self.ClassComponent}>"
+        )
+        assert (
+            res
+            == '<div class="avatar"><a href="#"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span>Fun times!</div>'
+        )
 
+    def test_class_component_direct_invocation(self):
+        avatar = self.ClassComponent(
+            user_name="Alice",
+            image_url="https://example.com/alice.png",
+            homepage="https://example.com/users/alice",
+            children=t"",  # Children is required so we set it to an empty template.
+        )
+        res = html(t"<{avatar} />")
+        assert (
+            res
+            == '<div class="avatar"><a href="https://example.com/users/alice"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span></div>'
+        )
 
-def AttributeTypeComponent(
-    data_int: int,
-    data_true: bool,
-    data_false: bool,
-    data_none: None,
-    data_float: float,
-    data_dt: datetime.datetime,
-    **kws: dict[str, object | None],
-) -> Template:
-    """Component to test that we don't incorrectly convert attribute types."""
-    assert isinstance(data_int, int)
-    assert data_true is True
-    assert data_false is False
-    assert data_none is None
-    assert isinstance(data_float, float)
-    assert isinstance(data_dt, datetime.datetime)
-    for kw, v_type in [
-        ("spread_true", True),
-        ("spread_false", False),
-        ("spread_int", int),
-        ("spread_none", None),
-        ("spread_float", float),
-        ("spread_dt", datetime.datetime),
-        ("spread_dict", dict),
-        ("spread_list", list),
-    ]:
-        if v_type in (True, False, None):
-            assert kw in kws and kws[kw] is v_type, (
-                f"{kw} should be {v_type} but got {kws=}"
-            )
-        else:
-            assert kw in kws and isinstance(kws[kw], v_type), (
-                f"{kw} should instance of {v_type} but got {kws=}"
+    @dataclass
+    class ClassComponentNoChildren:
+        """Example class-based component that does not ask for children."""
+
+        user_name: str
+        image_url: str
+        homepage: str = "#"
+
+        def __call__(self) -> Template:
+            return (
+                t"<div class='avatar'>"
+                t"<a href={self.homepage}>"
+                t"<img src='{self.image_url}' alt='{f'Avatar of {self.user_name}'}' />"
+                t"</a>"
+                t"<span>{self.user_name}</span>"
+                t"ignore children"
+                t"</div>"
             )
-    return t"Looks good!"
+
+    def test_implicit_invocation_ignore_children(self):
+        res = html(
+            t"<{self.ClassComponentNoChildren} user-name='Alice' image-url='https://example.com/alice.png'>Fun times!</{self.ClassComponentNoChildren}>"
+        )
+        assert (
+            res
+            == '<div class="avatar"><a href="#"><img src="https://example.com/alice.png" alt="Avatar of Alice" /></a><span>Alice</span>ignore children</div>'
+        )
 
 
 def test_attribute_type_component():
+    def AttributeTypeComponent(
+        data_int: int,
+        data_true: bool,
+        data_false: bool,
+        data_none: None,
+        data_float: float,
+        data_dt: datetime.datetime,
+        **kws: dict[str, object | None],
+    ) -> Template:
+        """Component to test that we don't incorrectly convert attribute types."""
+        assert isinstance(data_int, int)
+        assert data_true is True
+        assert data_false is False
+        assert data_none is None
+        assert isinstance(data_float, float)
+        assert isinstance(data_dt, datetime.datetime)
+        for kw, v_type in [
+            ("spread_true", True),
+            ("spread_false", False),
+            ("spread_int", int),
+            ("spread_none", None),
+            ("spread_float", float),
+            ("spread_dt", datetime.datetime),
+            ("spread_dict", dict),
+            ("spread_list", list),
+        ]:
+            if v_type in (True, False, None):
+                assert kw in kws and kws[kw] is v_type, (
+                    f"{kw} should be {v_type} but got {kws=}"
+                )
+            else:
+                assert kw in kws and isinstance(kws[kw], v_type), (
+                    f"{kw} should instance of {v_type} but got {kws=}"
+                )
+        return t"Looks good!"
+
     an_int: int = 42
     a_true: bool = True
     a_false: bool = False
@@ -1462,31 +1736,370 @@ def test_attribute_type_component():
         "spread_dict": {},
         "spread_list": ["eggs", "milk"],
     }
-    node = html(
+    res = html(
         t"<{AttributeTypeComponent} data-int={an_int} data-true={a_true} "
         t"data-false={a_false} data-none={a_none} data-float={a_float} "
         t"data-dt={a_dt} {spread_attrs}/>"
     )
-    assert node == Text("Looks good!")
-    assert str(node) == "Looks good!"
+    assert res == "Looks good!"
+
+
+class TestComponentErrors:
+    def test_component_non_callable_fails(self):
+        with pytest.raises(TypeError):
+            _ = html(t"<{'not a function'} />")
+
+    def test_component_requiring_positional_arg_fails(self):
+        def RequiresPositional(whoops: int, /) -> Template:  # pragma: no cover
+            return t"<p>Positional arg: {whoops}</p>"
+
+        with pytest.raises(TypeError):
+            _ = html(t"<{RequiresPositional} />")
+
+    def test_mismatched_component_closing_tag_fails(self):
+        def OpenTag(children: Template) -> Template:
+            return t"<div>open</div>"
+
+        def CloseTag(children: Template) -> Template:
+            return t"<div>close</div>"
+
+        with pytest.raises(TypeError):
+            _ = html(t"<{OpenTag}>Hello</{CloseTag}>")
+
+
+def test_integration_basic():
+    comment_text = "comment is not literal"
+    interpolated_class = "red"
+    text_in_element = "text is not literal"
+    templated = "not literal"
+    spread_attrs = {"data-on": True}
+    markup_content = Markup("<div>safe</div>")
+
+    def WrapperComponent(children):
+        return t"<div>{children}</div>"
+
+    smoke_t = t"""<!doctype html>
+<html>
+<body>
+<!-- literal -->
+<span attr="literal">literal</span>
+<!-- {comment_text} -->
+<span>{text_in_element}</span>
+<span attr="literal" class={interpolated_class} title="is {templated}" {spread_attrs}>{text_in_element}</span>
+<{WrapperComponent}><span>comp body</span></{WrapperComponent}>
+{markup_content}
+</body>
+</html>"""
+    smoke_str = """<!DOCTYPE html>
+<html>
+<body>
+<!-- literal -->
+<span attr="literal">literal</span>
+<!-- comment is not literal -->
+<span>text is not literal</span>
+<span attr="literal" title="is not literal" data-on class="red">text is not literal</span>
+<div><span>comp body</span></div>
+<div>safe</div>
+</body>
+</html>"""
+    assert html(smoke_t) == smoke_str
+
+
+def struct_repr(st):
+    """Breakdown Templates into comparable parts for test verification."""
+    return st.strings, tuple(
+        (i.value, i.expression, i.conversion, i.format_spec) for i in st.interpolations
+    )
+
+
+def test_process_template_internal_cache():
+    """Test that cache and non-cache both generally work as expected."""
+    # @NOTE: We use a made-up custom element so that we can be sure to
+    # miss the cache.  If this element is used elsewhere than the global
+    # cache might cache it and it will ruin our counting, specifically
+    # the first miss will instead be a hit.
+    sample_t = t"<div>{'content'}<tdom-cache-test-element /></div>"
+    sample_diff_t = t"<div>{'diffcontent'}<tdom-cache-test-element /></div>"
+    alt_t = t"<span>{'content'}</span>"
+    process_api = processor_service_factory()
+    cached_process_api = cached_processor_service_factory()
+    # Because the cache is stored on the class itself this can be affect by
+    # other tests, so save this off and take the difference to determine the result,
+    # this is not great and hopefully we can find a better solution.
+    assert isinstance(cached_process_api.parser_api, CachedParserService)
+    start_ci = cached_process_api.parser_api._to_tnode.cache_info()
+    tnode1 = process_api.parser_api.to_tnode(sample_t)
+    tnode2 = process_api.parser_api.to_tnode(sample_t)
+    cached_tnode1 = cached_process_api.parser_api.to_tnode(sample_t)
+    cached_tnode2 = cached_process_api.parser_api.to_tnode(sample_t)
+    cached_tnode3 = cached_process_api.parser_api.to_tnode(sample_diff_t)
+    # Check that the uncached and cached services are actually
+    # returning non-identical results.
+    assert tnode1 is not cached_tnode1
+    assert tnode1 is not cached_tnode2
+    assert tnode1 is not cached_tnode3
+    # Check that the uncached service returns a brand new result everytime.
+    assert tnode1 is not tnode2
+    # Check that the cached service is returning the exact same, identical, result.
+    assert cached_tnode1 is cached_tnode2
+    # Even if the input templates are not identical (but are still equivalent).
+    assert cached_tnode1 is cached_tnode3 and sample_t is not sample_diff_t
+    # Check that the cached service and uncached services return
+    # results that are equivalent (even though they are not (id)entical).
+    assert tnode1 == cached_tnode1
+    assert tnode2 == cached_tnode1
+    # Now that we are setup we check that the cache is internally
+    # working as we intended.
+    ci = cached_process_api.parser_api._to_tnode.cache_info()
+    # cached_tnode2 and cached_tnode3 are hits after cached_tnode1
+    assert ci.hits - start_ci.hits == 2
+    # cached_tf1 was a miss because cache was empty (brand new)
+    assert ci.misses - start_ci.misses == 1
+    cached_tnode4 = cached_process_api.parser_api.to_tnode(alt_t)
+    # A different template produces a brand new tf.
+    assert cached_tnode1 is not cached_tnode4
+    # The template is new AND has a different structure so it also
+    # produces an unequivalent tf.
+    assert cached_tnode1 != cached_tnode4
+
+
+def test_repeat_calls():
+    """Crude check for any unintended state being kept between calls."""
+
+    def get_sample_t(idx, spread_attrs, button_text):
+        return t"""<div><button data-key={idx} {spread_attrs}>{button_text}</button></div>"""
+
+    for idx in range(3):
+        spread_attrs = {"data-enabled": True}
+        button_text = "PROCESS"
+        sample_t = get_sample_t(idx, spread_attrs, button_text)
+        assert (
+            html(sample_t)
+            == f'<div><button data-key="{idx}" data-enabled>PROCESS</button></div>'
+        )
+
+
+def get_select_t_with_list(options, selected_values):
+    return t"""<select>{
+        [
+            t"<option value={opt[0]} selected={opt[0] in selected_values}>{opt[1]}</option>"
+            for opt in options
+        ]
+    }</select>"""
+
+
+def get_select_t_with_generator(options, selected_values):
+    return t"""<select>{
+        (
+            t"<option value={opt[0]} selected={opt[0] in selected_values}>{opt[1]}</option>"
+            for opt in options
+        )
+    }</select>"""
+
+
+def get_select_t_with_concat(options, selected_values):
+    parts = [t"<select>"]
+    parts.extend(
+        [
+            t"<option value={opt[0]} selected={opt[0] in selected_values}>{opt[1]}</option>"
+            for opt in options
+        ]
+    )
+    parts.append(t"</select>")
+    return sum(parts, t"")
+
+
+@pytest.mark.parametrize(
+    "provider",
+    (
+        get_select_t_with_list,
+        get_select_t_with_generator,
+        get_select_t_with_concat,
+    ),
+)
+def test_process_template_iterables(provider):
+    def get_color_select_t(selected_values: set, provider: Callable) -> Template:
+        PRIMARY_COLORS = [("R", "Red"), ("Y", "Yellow"), ("B", "Blue")]
+        assert set(selected_values).issubset({opt[0] for opt in PRIMARY_COLORS})
+        return provider(PRIMARY_COLORS, selected_values)
+
+    no_selection_t = get_color_select_t(set(), provider)
+    assert (
+        html(no_selection_t)
+        == '<select><option value="R">Red</option><option value="Y">Yellow</option><option value="B">Blue</option></select>'
+    )
+    selected_yellow_t = get_color_select_t({"Y"}, provider)
+    assert (
+        html(selected_yellow_t)
+        == '<select><option value="R">Red</option><option value="Y" selected>Yellow</option><option value="B">Blue</option></select>'
+    )
 
 
-def test_component_non_callable_fails():
-    with pytest.raises(TypeError):
-        _ = html(t"<{'not a function'} />")
+def test_component_integration():
+    """Broadly test that common template component usage works."""
 
+    def PageComponent(children, root_attrs=None):
+        return t"""<div class="content" {root_attrs}>{children}</div>"""
 
-def RequiresPositional(whoops: int, /) -> Template:  # pragma: no cover
-    return t"<p>Positional arg: {whoops}</p>"
+    def FooterComponent(classes=("footer-default",)):
+        return t'<div class="footer" class={classes}><a href="about">About</a></div>'
 
+    def LayoutComponent(children, body_classes=None):
+        return t"""<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <script src="scripts.js"></script>
+    <link rel="stylesheet" href="styles.css">
+  </head>
+  <body class={body_classes}>
+    {children}
+    <{FooterComponent} />
+  </body>
+</html>
+"""
 
-def test_component_requiring_positional_arg_fails():
-    with pytest.raises(TypeError):
-        _ = html(t"<{RequiresPositional} />")
+    content = "HTML never goes out of style."
+    content_str = html(
+        t"<{LayoutComponent} body_classes={['theme-default']}><{PageComponent}>{content}</{PageComponent}></{LayoutComponent}>"
+    )
+    assert (
+        content_str
+        == """<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="scripts.js"></script>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body class="theme-default">
+    <div class="content">HTML never goes out of style.</div>
+    <div class="footer footer-default"><a href="about">About</a></div>
+  </body>
+</html>
+"""
+    )
+
+
+class TestInterpolatingHTMLInTemplateWithDynamicParentTag:
+    """
+    When a template does not have a parent tag we cannot determine the type
+    of text that should be allowed and therefore we cannot determine how to
+    escape that text.  Once the type is known we should escape any
+    interpolations in that text correctly.
+    """
+
+    def test_dynamic_raw_text(self):
+        """Type raw text should fail because template is already not allowed."""
+        content = '<script>console.log("123!");</script>'
+        content_t = t"{content}"
+        with pytest.raises(
+            ValueError, match="Recursive includes are not supported within script"
+        ):
+            content_t = t'<script>console.log("{123}!");</script>'
+            _ = html(t"<script>{content_t}</script>")
+
+    def test_dynamic_escapable_raw_text(self):
+        """Type escapable raw text should fail because template is already not allowed."""
+        content = '<script>console.log("123!");</script>'
+        content_t = t"{content}"
+        with pytest.raises(
+            ValueError, match="Recursive includes are not supported within textarea"
+        ):
+            _ = html(t"<textarea>{content_t}</textarea>")
+
+    def test_dynamic_normal_text(self):
+        """Escaping should be applied when normal text type is goes into effect."""
+        content = '<script>console.log("123!");</script>'
+        content_t = t"{content}"
+        LT, GT, DQ = map(markupsafe_escape, ["<", ">", '"'])
+        assert (
+            html(t"<div>{content_t}</div>")
+            == f"<div>{LT}script{GT}console.log({DQ}123!{DQ});{LT}/script{GT}</div>"
+        )
 
 
-def test_mismatched_component_closing_tag_fails():
-    with pytest.raises(TypeError):
-        _ = html(
-            t"<{FunctionComponent} first=1 second={99} third-arg='comp1'>Hello</{ClassComponent}>"
+class TestPagerComponentExample:
+    @dataclass
+    class Pager:
+        left_pages: tuple = ()
+        page: int = 0
+        right_pages: tuple = ()
+        prev_page: int | None = None
+        next_page: int | None = None
+
+    @dataclass
+    class PagerDisplay:
+        pager: TestPagerComponentExample.Pager
+        paginate_url: Callable[[int], str]
+        root_classes: tuple[str, ...] = ("cb", "tc", "w-100")
+        part_classes: tuple[str, ...] = ("dib", "pa1")
+
+        def __call__(self) -> Template:
+            parts = [t"<div class={self.root_classes}>"]
+            if self.pager.prev_page:
+                parts.append(
+                    t"<a class={self.part_classes} href={self.paginate_url(self.pager.prev_page)}>Prev</a>"
+                )
+            for left_page in self.pager.left_pages:
+                parts.append(
+                    t'<a class={self.part_classes} href="{self.paginate_url(left_page)}">{left_page}</a>'
+                )
+            parts.append(t"<span class={self.part_classes}>{self.pager.page}</span>")
+            for right_page in self.pager.right_pages:
+                parts.append(
+                    t'<a class={self.part_classes} href="{self.paginate_url(right_page)}">{right_page}</a>'
+                )
+            if self.pager.next_page:
+                parts.append(
+                    t"<a class={self.part_classes} href={self.paginate_url(self.pager.next_page)}>Next</a>"
+                )
+            parts.append(t"</div>")
+            return Template(*chain.from_iterable(parts))
+
+    def test_example(self):
+        def paginate_url(page: int) -> str:
+            return f"/pages?page={page}"
+
+        def Footer(pager, paginate_url, footer_classes=("footer",)) -> Template:
+            return t"<div class={footer_classes}><{self.PagerDisplay} pager={pager} paginate_url={paginate_url} /></div>"
+
+        pager = self.Pager(
+            left_pages=(1, 2), page=3, right_pages=(4, 5), next_page=6, prev_page=None
         )
+        content_t = t"<{Footer} pager={pager} paginate_url={paginate_url} />"
+        res = html(content_t)
+        print(res)
+        assert (
+            res
+            == '<div class="footer"><div class="cb tc w-100"><a href="/pages?page=1" class="dib pa1">1</a><a href="/pages?page=2" class="dib pa1">2</a><span class="dib pa1">3</span><a href="/pages?page=4" class="dib pa1">4</a><a href="/pages?page=5" class="dib pa1">5</a><a href="/pages?page=6" class="dib pa1">Next</a></div></div>'
+        )
+
+
+def test_mathml():
+    num = 1
+    denom = 3
+    mathml_t = t"""<p>
+  The fraction
+  <math>
+    <mfrac>
+      <mn>{num}</mn>
+      <mn>{denom}</mn>
+    </mfrac>
+  </math>
+  is not a decimal number.
+</p>"""
+    res = html(mathml_t)
+    assert (
+        str(res)
+        == """<p>
+  The fraction
+  <math>
+    <mfrac>
+      <mn>1</mn>
+      <mn>3</mn>
+    </mfrac>
+  </math>
+  is not a decimal number.
+</p>"""
+    )
diff --git a/tdom/svg_test.py b/tdom/svg_test.py
index db48236..4b61d04 100644
--- a/tdom/svg_test.py
+++ b/tdom/svg_test.py
@@ -1,26 +1,28 @@
+from string.templatelib import Template
+
 from tdom import html, svg
 
 # svg() — tag case-fixing
 
 
 def test_svg_clippath_case_fixed():
-    node = svg(t"<clipPath id='mask'></clipPath>")
-    assert str(node) == '<clipPath id="mask"></clipPath>'
+    result = svg(t"<clipPath id='mask'></clipPath>")
+    assert result == '<clipPath id="mask"></clipPath>'
 
 
 def test_svg_lineargradient_case_fixed():
-    node = svg(t"<linearGradient id='grad'></linearGradient>")
-    assert str(node) == '<linearGradient id="grad"></linearGradient>'
+    result = svg(t"<linearGradient id='grad'></linearGradient>")
+    assert result == '<linearGradient id="grad"></linearGradient>'
 
 
 def test_svg_femergenode_self_closing_case_fixed():
-    node = svg(t"<feMergeNode />")
-    assert str(node) == "<feMergeNode></feMergeNode>"
+    result = svg(t"<feMergeNode />")
+    assert result == "<feMergeNode></feMergeNode>"
 
 
 def test_svg_nested_tags_case_fixed():
-    node = svg(t"<g><clipPath id='c'><rect /></clipPath></g>")
-    assert str(node) == '<g><clipPath id="c"><rect></rect></clipPath></g>'
+    result = svg(t"<g><clipPath id='c'><rect /></clipPath></g>")
+    assert result == '<g><clipPath id="c"><rect></rect></clipPath></g>'
 
 
 # ------------------------------
@@ -29,50 +31,50 @@ def test_svg_nested_tags_case_fixed():
 
 
 def test_svg_viewbox_attr_case_fixed():
-    node = svg(t'<rect viewBox="0 0 10 10" />')
-    assert str(node) == '<rect viewBox="0 0 10 10"></rect>'
+    result = svg(t'<rect viewBox="0 0 10 10" />')
+    assert result == '<rect viewBox="0 0 10 10"></rect>'
 
 
 def test_svg_case_sensitivity():
     # SVG attributes like viewBox are case-sensitive
-    node = html(t'<svg viewBox="0 0 100 100"></svg>')
+    result = html(t'<svg viewBox="0 0 100 100"></svg>')
     # We expect viewBox, not viewbox
-    assert "viewBox" in str(node)
+    assert "viewBox" in result
 
 
 def test_svg_tag_case_sensitivity():
     # SVG tags like linearGradient are case-sensitive
-    node = html(t"<svg><linearGradient></linearGradient></svg>")
-    assert "linearGradient" in str(node)
+    result = html(t"<svg><linearGradient></linearGradient></svg>")
+    assert "linearGradient" in result
 
 
 def test_svg_tag_case_sensitivity_outside_svg():
     # Outside SVG, tags should be lowercased
-    node = html(t"<linearGradient></linearGradient>")
-    assert "lineargradient" in str(node)
+    result = html(t"<linearGradient></linearGradient>")
+    assert "lineargradient" in result
 
 
 def test_svg_attr_case_sensitivity_outside_svg():
     # Outside SVG, attributes should be lowercased
-    node = html(t'<div viewBox="0 0 100 100"></div>')
-    assert "viewbox" in str(node)
+    result = html(t'<div viewBox="0 0 100 100"></div>')
+    assert "viewbox" in result
 
 
 def test_svg_interpolated_attr():
     cx, cy, r = 50, 50, 40
-    node = svg(t'<circle cx="{cx}" cy="{cy}" r="{r}" />')
-    assert str(node) == '<circle cx="50" cy="50" r="40"></circle>'
+    result = svg(t'<circle cx="{cx}" cy="{cy}" r="{r}" />')
+    assert result == '<circle cx="50" cy="50" r="40"></circle>'
 
 
 def test_svg_interpolated_child():
     label = "hello"
-    node = svg(t"<text>{label}</text>")
-    assert str(node) == "<text>hello</text>"
+    result = svg(t"<text>{label}</text>")
+    assert result == "<text>hello</text>"
 
 
 def test_svg_fragment_multiple_roots():
-    node = svg(t"<circle /><rect />")
-    assert str(node) == "<circle></circle><rect></rect>"
+    result = svg(t"<circle /><rect />")
+    assert result == "<circle></circle><rect></rect>"
 
 
 # ---------------------------------------------------------
@@ -82,16 +84,16 @@ def test_svg_fragment_multiple_roots():
 
 def test_svg_and_html_produce_different_results_for_same_strings():
     # html() lowercases clipPath (no SVG context); svg() preserves it.
-    html_node = html(t"<clipPath></clipPath>")
-    svg_node = svg(t"<clipPath></clipPath>")
-    assert str(html_node) == "<clippath></clippath>"
-    assert str(svg_node) == "<clipPath></clipPath>"
+    html_result = html(t"<clipPath></clipPath>")
+    svg_result = svg(t"<clipPath></clipPath>")
+    assert html_result == "<clippath></clippath>"
+    assert svg_result == "<clipPath></clipPath>"
 
 
 def test_html_full_svg_document_still_works():
     # html() auto-detects SVG context when <svg> is present — no regression.
-    node = html(t"<svg><clipPath id='c'></clipPath></svg>")
-    assert str(node) == '<svg><clipPath id="c"></clipPath></svg>'
+    result = html(t"<svg><clipPath id='c'></clipPath></svg>")
+    assert result == '<svg><clipPath id="c"></clipPath></svg>'
 
 
 # -------------------------------
@@ -100,11 +102,53 @@ def test_html_full_svg_document_still_works():
 
 
 def test_svg_fragment_embedded_in_html():
-    def icon():
-        return svg(t'<circle cx="50" cy="50" r="40" />')
+    def icon() -> Template:
+        return t'<rect viewBox="0 0 10 10" />'
+
+    result = html(t'<div class="icon"><svg>{icon()}</svg></div>')
+    assert (
+        result == '<div class="icon"><svg><rect viewBox="0 0 10 10"></rect></svg></div>'
+    )
 
-    node = html(t'<div class="icon"><svg>{icon()}</svg></div>')
+
+def test_svg_fragment_with_spread_attr():
+    def icon(attrs: dict[str, str]) -> Template:
+        return t"<rect {attrs} />"
+
+    rect_attrs = {"viewbox": "0 0 10 10"}
+    result = html(t'<div class="icon"><svg>{icon(attrs=rect_attrs)}</svg></div>')
     assert (
-        str(node)
-        == '<div class="icon"><svg><circle cx="50" cy="50" r="40"></circle></svg></div>'
+        result == '<div class="icon"><svg><rect viewBox="0 0 10 10"></rect></svg></div>'
     )
+
+
+def test_svg_nesting():
+    svg_doc = t"""<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf8">
+  </head>
+  <body>
+  <svg width=1000 height=1000>
+  <rect width="100%" height="100%" fill="red"></rect>
+    <foreignObject width=500 height=500>
+      text,fo,svg,html
+      <div>
+          <!-- This should be lowercased because it is actually in HTML. -->
+          <foreignObject></foreignObject>
+          text,div,fo,svg,html
+          <svg width=300 height=300>
+            <rect width="100%" height="100%" fill="blue"></rect>
+            <circle cx=50 cy=50 r="15" fill="green"></circle>
+            <foreignObject width=100 height=100>
+              <span style="font-size: 10px">text,span,fo,svg,div,fo,svg,html</span>
+            </foreignObject>
+          </svg>
+          <math><mi>&pi;</mi></math>
+        </div>
+      </foreignObject>
+    </svg>
+  </body>
+</html>"""
+    res = html(svg_doc)
+    assert res.count("<foreignObject") == 2
diff --git a/tdom/utils.py b/tdom/utils.py
index 0062ab6..5f69c83 100644
--- a/tdom/utils.py
+++ b/tdom/utils.py
@@ -15,17 +15,13 @@ class CachableTemplate:
 
     # CONSIDER: what about interpolation format specs, convsersions, etc.?
 
-    def __init__(self, template: Template, svg_context: bool = False) -> None:
+    def __init__(self, template: Template) -> None:
         self.template = template
-        self.svg_context = svg_context
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, CachableTemplate):
             return NotImplemented
-        return (
-            self.template.strings == other.template.strings
-            and self.svg_context == other.svg_context
-        )
+        return self.template.strings == other.template.strings
 
     def __hash__(self) -> int:
-        return hash((self.template.strings, self.svg_context))
+        return hash(self.template.strings)