diff --git a/README.md b/README.md
index 2265d27..cfef056 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.
+convert it into a str.
 
 ### 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
@@ -312,18 +309,6 @@ page = html(t"<div>{content}</div>")
 # <div><h1>My Site</h1></div>
 ```
 
-In the example above, `content` is a `Template` object that gets correctly
-parsed and embedded within the outer template. You can also explicitly call
-`html()` on nested templates if you prefer:
-
-```python
-content = html(t"<h1>My Site</h1>")
-page = html(t"<div>{content}</div>")
-# <div><h1>My Site</h1></div>
-```
-
-The result is the same either way.
-
 #### Component Functions
 
 You can create reusable component functions that generate templates with dynamic
@@ -333,10 +318,11 @@ The basic form of all component functions is:
 
 ```python
 from typing import Any, Iterable
-from tdom import Node, html
+from tdom import html
+from string.templatelib import Template
 
-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
@@ -352,10 +338,11 @@ type hints for better editor support:
 
 ```python
 from typing import Any
-from tdom import Node, html
+from tdom import html
+from string.templatelib import Template
 
-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>
@@ -364,12 +351,7 @@ result = html(t'<{Link} href="https://example.com" text="Example" data-value={42
 Note that attributes with hyphens (like `data-value`) are converted to
 underscores (`data_value`) in the function signature.
 
-Component functions build children and can return _any_ type of value; the
-returned value will be treated exactly as if it were placed directly in a child
-position in the template.
-
-Among other things, this means you can return a `Template` directly from a
-component function:
+Component functions build Templates that conceptually will replace the component tags with the new template.
 
 <!-- invisible-code-block: python
 from string.templatelib import Template
@@ -380,23 +362,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
@@ -416,18 +382,18 @@ from tdom import Node, 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'>
@@ -442,7 +408,7 @@ class, making it easier to manage complex components.
 
 As a note, `children` are optional in component signatures. If a component
 requests children, it will receive them if provided. If no children are
-provided, the value of children is an empty tuple. If the component does _not_
+provided, the value of children is an empty Template, ie. `t""`. If the component does _not_
 ask for children, but they are provided, then they are silently ignored.
 
 #### SVG Support
@@ -470,12 +436,12 @@ 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)
@@ -497,9 +463,9 @@ 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)
@@ -518,41 +484,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..fb65cd4 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.
+children are provided, the value of children is an empty `Template`, ie. `t""`.
 
 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,7 +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>'
+assert result == '<body><h1>Other Heading</h1></body>'
 ```
 
 ## Generators as Components
@@ -175,13 +172,11 @@ 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>"
-
+def Todos() -> Template:
+  return t'<ul>{(t"<li>{todo}</li>" for todo in ["first", "second", "third"])}</ul>'
 
-result = html(t"<ul><{Todos} /></ul>")
-assert str(result) == '<ul><li>first</li><li>second</li><li>third</li></ul>'
+result = html(t"<{Todos} />")
+assert result == '<ul><li>first</li><li>second</li><li>third</li></ul>'
 ```
 
 ## Nested Components
@@ -200,5 +195,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..9af7304 100644
--- a/docs/usage/looping.md
+++ b/docs/usage/looping.md
@@ -40,7 +40,7 @@ then use that `Node` 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..10aa8ce 100644
--- a/docs/usage/static_string.md
+++ b/docs/usage/static_string.md
@@ -13,14 +13,13 @@ from tdom import html, Element, Text
 
 ```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 Python `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
@@ -71,29 +47,6 @@ 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 4503582..4734801 100644
--- a/tdom/__init__.py
+++ b/tdom/__init__.py
@@ -1,7 +1,12 @@
 from markupsafe import Markup, escape
 
-from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
-from .processor import html
+from .nodes.nodes import Comment, DocumentType, Element, Fragment, Node, Text
+from .nodes.processor import to_node
+from .processor import to_html
+
+
+html = to_html
+
 
 # We consider `Markup` and `escape` to be part of this module's public API
 
@@ -12,6 +17,9 @@
     "escape",
     "Fragment",
     "html",
+    "to_node",
+    "to_html",
+    "html",
     "Markup",
     "Node",
     "Text",
diff --git a/tdom/escaping.py b/tdom/escaping.py
index 2caebba..726f00c 100644
--- a/tdom/escaping.py
+++ b/tdom/escaping.py
@@ -2,6 +2,9 @@
 
 from markupsafe import escape as markup_escape
 
+from .protocols import HasHTMLDunder
+
+
 escape_html_text = markup_escape  # unify api for test of project
 
 
@@ -9,10 +12,16 @@
 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
+    elif allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
+    elif not allow_markup and type(text) is not str:
+        # text manipulation triggers regular html escapes on Markup
+        text = str(text)
+
     # - text must not start with the string ">"
     if text[0] == ">":
         text = GT + text[1:]
@@ -39,8 +48,10 @@ def escape_html_comment(text: str) -> str:
 STYLE_RES = ((re.compile("</(?P<tagname>style)>", re.I | re.A), LT + r"/\g<tagname>>"),)
 
 
-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
@@ -62,7 +73,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.
 
@@ -75,6 +86,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/format.py b/tdom/format.py
index fba5539..6082481 100644
--- a/tdom/format.py
+++ b/tdom/format.py
@@ -29,7 +29,11 @@ def convert[T](value: T, conversion: t.Literal["a", "r", "s"] | None) -> T | str
 type FormatMatcher = t.Callable[[str], bool]
 """A predicate function that returns True if a given format specifier matches its criteria."""
 
-type CustomFormatter = t.Callable[[object, str], str]
+
+V = t.TypeVar("V", bound=object)
+
+
+type CustomFormatter[V] = t.Callable[[V, str], object]
 """A function that takes a value and a format specifier and returns a formatted string."""
 
 type MatcherAndFormatter = tuple[str | FormatMatcher, CustomFormatter]
diff --git a/tdom/htmlspec.py b/tdom/htmlspec.py
new file mode 100644
index 0000000..d1a6567
--- /dev/null
+++ b/tdom/htmlspec.py
@@ -0,0 +1,28 @@
+# See https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+VOID_ELEMENTS = frozenset(
+    [
+        "area",
+        "base",
+        "br",
+        "col",
+        "embed",
+        "hr",
+        "img",
+        "input",
+        "link",
+        "meta",
+        "param",
+        "source",
+        "track",
+        "wbr",
+    ]
+)
+
+
+CDATA_CONTENT_ELEMENTS = frozenset(["script", "style"])
+RCDATA_CONTENT_ELEMENTS = frozenset(["textarea", "title"])
+CONTENT_ELEMENTS = CDATA_CONTENT_ELEMENTS | RCDATA_CONTENT_ELEMENTS
+
+# Used for fragments that do no have a tag
+# to assume that text is inside this element.
+DEFAULT_NORMAL_TEXT_ELEMENT = "div"
diff --git a/tdom/nodes/__init__.py b/tdom/nodes/__init__.py
new file mode 100644
index 0000000..f3b0d32
--- /dev/null
+++ b/tdom/nodes/__init__.py
@@ -0,0 +1 @@
+""""""
diff --git a/tdom/nodes.py b/tdom/nodes/nodes.py
similarity index 78%
rename from tdom/nodes.py
rename to tdom/nodes/nodes.py
index 346f97f..4cad3d1 100644
--- a/tdom/nodes.py
+++ b/tdom/nodes/nodes.py
@@ -1,40 +1,12 @@
 from dataclasses import dataclass, field
 
-from .escaping import (
+from ..escaping import (
     escape_html_comment,
     escape_html_script,
     escape_html_style,
     escape_html_text,
 )
-
-# See https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-VOID_ELEMENTS = frozenset(
-    [
-        "area",
-        "base",
-        "br",
-        "col",
-        "embed",
-        "hr",
-        "img",
-        "input",
-        "link",
-        "meta",
-        "param",
-        "source",
-        "track",
-        "wbr",
-    ]
-)
-
-
-CDATA_CONTENT_ELEMENTS = frozenset(["script", "style"])
-RCDATA_CONTENT_ELEMENTS = frozenset(["textarea", "title"])
-CONTENT_ELEMENTS = CDATA_CONTENT_ELEMENTS | RCDATA_CONTENT_ELEMENTS
-
-
-# FUTURE: add a pretty-printer to nodes for debugging
-# FUTURE: make nodes frozen (and have the parser work with mutable builders)
+from ..htmlspec import VOID_ELEMENTS, CONTENT_ELEMENTS
 
 
 @dataclass(slots=True)
@@ -72,7 +44,7 @@ class Comment(Node):
     text: str
 
     def __str__(self) -> str:
-        return f"<!--{escape_html_comment(self.text)}-->"
+        return f"<!--{escape_html_comment(self.text, allow_markup=True)}-->"
 
 
 @dataclass(slots=True)
@@ -118,11 +90,16 @@ def _children_to_str(self):
                     raise ValueError(
                         "Cannot serialize non-text content inside a script tag."
                     )
-            raw_children_str = "".join(chunks)
+            if len(chunks) == 1:
+                raw_children_str = chunks[0]
+            else:
+                for chunk in chunks:
+                    assert type(chunk) is str, "Do not allow markup in mixed text."
+                raw_children_str = "".join(chunks)
             if self.tag == "script":
-                return escape_html_script(raw_children_str)
+                return escape_html_script(raw_children_str, allow_markup=True)
             elif self.tag == "style":
-                return escape_html_style(raw_children_str)
+                return escape_html_style(raw_children_str, allow_markup=True)
             else:
                 raise ValueError("Unsupported tag for single-level bulk escaping.")
         else:
@@ -141,3 +118,6 @@ def __str__(self) -> str:
             return f"<{self.tag}{attrs_str}></{self.tag}>"
         children_str = self._children_to_str()
         return f"<{self.tag}{attrs_str}>{children_str}</{self.tag}>"
+
+
+type NodeContainer = Element | Fragment
diff --git a/tdom/nodes_test.py b/tdom/nodes/nodes_test.py
similarity index 95%
rename from tdom/nodes_test.py
rename to tdom/nodes/nodes_test.py
index 184d387..70e20b8 100644
--- a/tdom/nodes_test.py
+++ b/tdom/nodes/nodes_test.py
@@ -4,21 +4,6 @@
 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>"
@@ -29,6 +14,11 @@ def test_doctype_custom():
     assert str(doctype) == "<!DOCTYPE xml>"
 
 
+def test_comment():
+    comment = Comment("Added for testing.")
+    assert str(comment) == "<!--Added for testing.-->"
+
+
 def test_text():
     text = Text("Hello, world!")
     assert str(text) == "Hello, world!"
diff --git a/tdom/nodes/processor.py b/tdom/nodes/processor.py
new file mode 100644
index 0000000..99034a7
--- /dev/null
+++ b/tdom/nodes/processor.py
@@ -0,0 +1,346 @@
+from dataclasses import dataclass
+from string.templatelib import Template
+from typing import cast
+from collections.abc import Iterable
+
+from markupsafe import Markup
+
+from ..protocols import HasHTMLDunder
+from ..processor import (
+    ProcessContext,
+    BaseProcessorService,
+    _resolve_t_attrs,
+    _resolve_html_attrs,
+    prep_component_kwargs,
+    resolve_text_without_recursion,
+    make_ctx,
+    extract_embedded_template,
+    ComponentObjectProto,
+    ComponentCallableProto,
+    format_interpolation,
+    WalkerProto,
+    NormalTextInterpolationValue,
+    CachedParserService,
+)
+from ..callables import get_callable_info
+from ..htmlspec import (
+    VOID_ELEMENTS,
+    RCDATA_CONTENT_ELEMENTS,
+    CDATA_CONTENT_ELEMENTS,
+    DEFAULT_NORMAL_TEXT_ELEMENT,
+)
+from .nodes import Fragment, Comment, DocumentType, Element, Text, Node, NodeContainer
+from ..parser import (
+    TAttribute,
+    TComment,
+    TComponent,
+    TDocumentType,
+    TElement,
+    TFragment,
+    TLiteralAttribute,
+    TNode,
+    TText,
+)
+from ..template_utils import TemplateRef
+
+
+@dataclass(frozen=True)
+class NodeProcessorService(BaseProcessorService):
+    """Iteratively process a tdom compatible Template into a `Node` tree."""
+
+    def process_template(
+        self, root_template: Template, assume_ctx: ProcessContext | None = None
+    ) -> Node:
+        root_tnode = self.parser_api.to_tnode(root_template)
+        if assume_ctx is None:
+            assume_ctx = make_ctx(parent_tag=DEFAULT_NORMAL_TEXT_ELEMENT, ns="html")
+        root_node = Fragment()
+        q: list[WalkerProto] = [
+            self.walk_from_tnode(root_node, root_template, assume_ctx, root_tnode)
+        ]
+        while q:
+            it = q.pop()
+            for new_it in it:
+                if new_it is not None:
+                    q.append(it)
+                    q.append(new_it)
+                    break
+        if len(root_node.children) == 1:
+            return root_node.children[0]
+        return root_node
+
+    def walk_from_tnode(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        assume_ctx: ProcessContext,
+        root: TNode,
+    ) -> Iterable[WalkerProto]:
+        q: list[tuple[ProcessContext, TNode, NodeContainer]] = [
+            (assume_ctx, root, parent_node)
+        ]
+        while q:
+            last_ctx, tnode, parent_node = q.pop()
+            match tnode:
+                case TDocumentType(text):
+                    if last_ctx.ns != "html":
+                        # Nit
+                        raise ValueError(
+                            "Cannot process document type in subtree of a foreign element."
+                        )
+                    parent_node.children.append(DocumentType(text))
+                case TComment(ref):
+                    self._process_comment(parent_node, template, last_ctx, ref)
+                case TFragment(children):
+                    q.extend(
+                        [
+                            (last_ctx, tchild, parent_node)
+                            for tchild in reversed(children)
+                        ]
+                    )
+                case TComponent(start_i_index, end_i_index, attrs, children):
+                    res = self._process_component(
+                        parent_node,
+                        template,
+                        last_ctx,
+                        attrs,
+                        start_i_index,
+                        end_i_index,
+                    )
+                    if res is not None:
+                        yield res
+                case TElement(tag, attrs, children):
+                    our_ctx = last_ctx.copy(parent_tag=tag)
+                    if attrs:
+                        resolved_attrs = _resolve_t_attrs(
+                            attrs, template.interpolations
+                        )
+                        el_attrs = _resolve_html_attrs(resolved_attrs)
+                    else:
+                        el_attrs = {}
+                    el = Element(tag, attrs=el_attrs, children=[])
+                    parent_node.children.append(el)
+                    if tag not in VOID_ELEMENTS:  # Or just check children?
+                        q.extend(
+                            [(our_ctx, tchild, el) for tchild in reversed(children)]
+                        )
+                case TText(ref):
+                    if last_ctx.parent_tag is None:
+                        raise NotImplementedError(
+                            "We cannot interpolate texts without knowing what tag they are contained in."
+                        )
+                    elif last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS:
+                        # Must be handled all at once.
+                        self._process_raw_texts(parent_node, 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.
+                        self._process_escapable_raw_texts(
+                            parent_node, template, last_ctx, ref
+                        )
+                    else:
+                        for part in ref:
+                            if isinstance(part, str):
+                                parent_node.children.append(Text(part))
+                            else:
+                                res = self._process_normal_text(
+                                    parent_node, template, last_ctx, part
+                                )
+                                if res is not None:
+                                    yield res
+                case _:
+                    raise ValueError(f"Unrecognized tnode: {tnode}")
+
+    def _process_comment(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        content = resolve_text_without_recursion(template, "<!--", content_ref)
+        if content is None or content == "":
+            content = ""
+        parent_node.children.append(Comment(content))
+
+    def _process_component(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        attrs: tuple[TAttribute, ...],
+        start_i_index: int,
+        end_i_index: int | None,
+    ) -> None | WalkerProto:
+        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 = cast(ComponentCallableProto, 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),
+            system_kwargs={"children": children_template},
+        )
+
+        result_t = component_callable(**kwargs)
+        if (
+            result_t is not None
+            and not isinstance(result_t, Template)
+            and callable(result_t)
+        ):
+            component_obj = cast(ComponentObjectProto, result_t)
+            result_t = component_obj()
+        else:
+            component_obj = None
+
+        if isinstance(result_t, Template):
+            if result_t.strings == ("",):
+                # DO NOTHING
+                return
+            result_root = self.parser_api.to_tnode(result_t)
+            return self.walk_from_tnode(parent_node, result_t, last_ctx, result_root)
+        else:
+            raise ValueError(f"Unknown component return value: {type(result_t)}")
+
+    def _process_raw_texts(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        assert last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        if content is None or content == "":
+            return
+        elif last_ctx.parent_tag == "script":
+            parent_node.children.append(
+                Text(
+                    Markup(
+                        self.escape_html_script(
+                            content,
+                            allow_markup=True,
+                        )
+                    )
+                )
+            )
+        elif last_ctx.parent_tag == "style":
+            parent_node.children.append(
+                Text(
+                    Markup(
+                        self.escape_html_style(
+                            content,
+                            allow_markup=True,
+                        )
+                    )
+                )
+            )
+        else:
+            raise NotImplementedError(
+                f"Parent tag {last_ctx.parent_tag} is not supported."
+            )
+
+    def _process_escapable_raw_texts(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        assert last_ctx.parent_tag in RCDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        if content is None or content == "":
+            return
+        else:
+            parent_node.children.append(Text(Markup(self.escape_html_text(content))))
+
+    def _process_normal_text(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        values_index: int,
+    ) -> WalkerProto | None:
+        value = format_interpolation(template.interpolations[values_index])
+        if isinstance(value, str):
+            parent_node.children.append(Text(value))
+        elif isinstance(value, Template):
+            value_root = self.parser_api.to_tnode(value)
+            return self.walk_from_tnode(parent_node, value, last_ctx, value_root)
+        elif isinstance(value, Iterable):
+            return iter(
+                self._process_normal_text_from_value(parent_node, template, last_ctx, v)
+                for v in value
+            )
+        elif value is None:
+            # @DESIGN: Ignore None.
+            return
+        else:
+            if isinstance(value, HasHTMLDunder):
+                text = Text(Markup(value.__html__()))
+            else:
+                # @DESIGN: Everything that isn't an object we recognize is
+                # coerced to a str() and emitted.
+                text = Text(str(value))
+            parent_node.children.append(text)
+
+    def _process_normal_text_from_value(
+        self,
+        parent_node: NodeContainer,
+        template: Template,
+        last_ctx: ProcessContext,
+        value: NormalTextInterpolationValue,
+    ) -> WalkerProto | None:
+        if isinstance(value, str):
+            parent_node.children.append(Text(value))
+        elif isinstance(value, Template):
+            value_root = self.parser_api.to_tnode(value)
+            return self.walk_from_tnode(parent_node, value, last_ctx, value_root)
+        elif isinstance(value, Iterable):
+            return iter(
+                self._process_normal_text_from_value(parent_node, template, last_ctx, v)
+                for v in value
+            )
+        elif value is None:
+            # @DESIGN: Ignore None.
+            return
+        else:
+            if isinstance(value, HasHTMLDunder):
+                text = Text(Markup(value.__html__()))
+            else:
+                # @DESIGN: Everything that isn't an object we recognize is
+                # coerced to a str() and emitted.
+                text = Text(str(value))
+            parent_node.children.append(text)
+
+
+_default_cached_node_processor_api = NodeProcessorService(
+    parser_api=CachedParserService()
+)
+
+
+def to_node(template: Template, assume_ctx: ProcessContext | None = None) -> Node:
+    return _default_cached_node_processor_api.process_template(
+        template, assume_ctx=assume_ctx
+    )
diff --git a/tdom/nodes/processor_test.py b/tdom/nodes/processor_test.py
new file mode 100644
index 0000000..6a2b569
--- /dev/null
+++ b/tdom/nodes/processor_test.py
@@ -0,0 +1,60 @@
+from string.templatelib import Template
+
+from .processor import to_node
+from .nodes import Element, Text, Fragment, DocumentType, Comment
+
+#
+# @NOTE: Most of the processor tests are in the main process_test.py file.
+#
+
+
+def test_to_node_integration():
+    """Test all the major elements with nodes."""
+    title = "Test Title"
+    url_path = "about"
+    content = "About"
+    extra_kwargs = {"id": "my-link"}
+
+    def simple_comp(label: str, children: Template) -> Template:
+        return t"<section>{label}: {children}</section><span>Tail</span>"
+
+    node = to_node(
+        (
+            t"<!doctype html>"
+            t"<!-- comment -->"
+            t"<script>var x = 1;</script>"
+            t"<div><br>&gt;</div>"
+            t"<div>{[0, 1]}</div>"
+            t'<a class="red" title={title} href="/{url_path}" {extra_kwargs}>{content}</a>'
+            t'<{simple_comp} label="The Children"><span>Child0</span><span>Child1</span></{simple_comp}>'
+        )
+    )
+    assert node == Fragment(
+        children=[
+            DocumentType("html"),
+            Comment(" comment "),
+            Element("script", children=[Text("var x = 1;")]),
+            Element("div", children=[Element("br"), Text(">")]),
+            Element("div", children=[Text("0"), Text("1")]),
+            Element(
+                "a",
+                attrs={
+                    "class": "red",
+                    "title": title,
+                    "href": f"/{url_path}",
+                    "id": "my-link",
+                },
+                children=[Text(content)],
+            ),
+            Element(
+                "section",
+                children=[
+                    Text("The Children"),
+                    Text(": "),
+                    Element("span", children=[Text("Child0")]),
+                    Element("span", children=[Text("Child1")]),
+                ],
+            ),
+            Element("span", children=[Text("Tail")]),
+        ]
+    )
diff --git a/tdom/parser.py b/tdom/parser.py
index 82de290..d8c529e 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 .nodes import VOID_ELEMENTS
+from .htmlspec import VOID_ELEMENTS
 from .placeholders import PlaceholderState
 from .tnodes import (
     TAttribute,
diff --git a/tdom/parser_test.py b/tdom/parser_test.py
index 298adc2..159e50c 100644
--- a/tdom/parser_test.py
+++ b/tdom/parser_test.py
@@ -1,7 +1,7 @@
 import pytest
 
 from .parser import TemplateParser
-from .placeholders import TemplateRef
+from .placeholders import TemplateRef, make_placeholder_config
 from .tnodes import (
     TComment,
     TComponent,
@@ -14,6 +14,7 @@
     TTemplatedAttribute,
     TText,
 )
+from string.templatelib import Template, Interpolation
 
 
 def test_parse_mixed_literal_content():
@@ -356,6 +357,26 @@ def test_adjacent_spread_attrs_error():
         _ = TemplateParser.parse(t"<div {attrs1}{attrs2} />")
 
 
+class TestPlaceholders:
+    """Test placeholder parsing."""
+
+    def test_placeholder_collision_avoidance(self):
+        config = make_placeholder_config()
+        # This test is to ensure that our placeholder detection avoids collisions
+        # even with content that might look like a placeholder.
+        tricky = "0"
+        template = Template(
+            f'<div data-tricky="{config.prefix}',
+            Interpolation(tricky, "tricky", None, ""),
+            f'{config.suffix}"></div>',
+        )
+        node = TemplateParser.parse(template)
+        value_ref = TemplateRef(strings=(config.prefix, config.suffix), i_indexes=(0,))
+        assert node == TElement(
+            "div", attrs=(TTemplatedAttribute("data-tricky", value_ref),)
+        )
+
+
 #
 # Comments
 #
diff --git a/tdom/processor.py b/tdom/processor.py
index 1e2528d..064bb34 100644
--- a/tdom/processor.py
+++ b/tdom/processor.py
@@ -1,16 +1,20 @@
-import sys
-import typing as t
-from collections.abc import Iterable, Sequence
+from typing import cast
+from collections.abc import Iterable, Sequence, Callable
 from functools import lru_cache
-from string.templatelib import Interpolation, Template
+from string.templatelib import Template, Interpolation
 from dataclasses import dataclass
 
 from markupsafe import Markup
 
-from .callables import get_callable_info
+from .callables import get_callable_info, CallableInfo
 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 (
+    DEFAULT_NORMAL_TEXT_ELEMENT,
+    VOID_ELEMENTS,
+    CDATA_CONTENT_ELEMENTS,
+    RCDATA_CONTENT_ELEMENTS,
+)
 from .parser import (
     HTMLAttribute,
     HTMLAttributesDict,
@@ -28,24 +32,16 @@
     TTemplatedAttribute,
     TText,
 )
-from .placeholders import TemplateRef
-from .template_utils import template_from_parts
 from .utils import CachableTemplate, LastUpdatedOrderedDict
-
-
-@t.runtime_checkable
-class HasHTMLDunder(t.Protocol):
-    def __html__(self) -> str: ...  # pragma: no cover
-
-
-# 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)
+from .escaping import (
+    escape_html_script as default_escape_html_script,
+    escape_html_style as default_escape_html_style,
+    escape_html_text as default_escape_html_text,
+    escape_html_comment as default_escape_html_comment,
+)
+from .protocols import HasHTMLDunder
+from .sentinel import NOT_SET, NotSet
+from .template_utils import TemplateRef
 
 
 type Attribute = tuple[str, object]
@@ -69,7 +65,17 @@ def _format_unsafe(value: object, format_spec: str) -> str:
     return str(value)
 
 
-CUSTOM_FORMATTERS = (("safe", _format_safe), ("unsafe", _format_unsafe))
+def _format_callback(value: Callable[..., object], format_spec: str) -> object:
+    """Execute a callback and return the value."""
+    assert format_spec == "callback"
+    return value()
+
+
+CUSTOM_FORMATTERS = (
+    ("safe", _format_safe),
+    ("unsafe", _format_unsafe),
+    ("callback", _format_callback),
+)
 
 
 def format_interpolation(interpolation: Interpolation) -> object:
@@ -84,7 +90,7 @@ def format_interpolation(interpolation: Interpolation) -> object:
 # --------------------------------------------------------------------------
 
 
-def _expand_aria_attr(value: object) -> t.Iterable[HTMLAttribute]:
+def _expand_aria_attr(value: object) -> Iterable[HTMLAttribute]:
     """Produce aria-* attributes based on the interpolated value for "aria"."""
     if value is None:
         return
@@ -104,7 +110,7 @@ def _expand_aria_attr(value: object) -> t.Iterable[HTMLAttribute]:
         )
 
 
-def _expand_data_attr(value: object) -> t.Iterable[Attribute]:
+def _expand_data_attr(value: object) -> Iterable[Attribute]:
     """Produce data-* attributes based on the interpolated value for "data"."""
     if value is None:
         return
@@ -120,7 +126,7 @@ def _expand_data_attr(value: object) -> t.Iterable[Attribute]:
         )
 
 
-def _substitute_spread_attrs(value: object) -> t.Iterable[Attribute]:
+def _substitute_spread_attrs(value: object) -> Iterable[Attribute]:
     """
     Substitute a spread attribute based on the interpolated value.
 
@@ -285,7 +291,7 @@ def to_value(self) -> str | None:
 
 
 def _resolve_t_attrs(
-    attrs: t.Sequence[TAttribute], interpolations: tuple[Interpolation, ...]
+    attrs: Sequence[TAttribute], interpolations: tuple[Interpolation, ...]
 ) -> AttributesDict:
     """
     Replace placeholder values in attributes with their interpolated values.
@@ -320,7 +326,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:
@@ -368,115 +374,16 @@ def _resolve_html_attrs(attrs: AttributesDict) -> HTMLAttributesDict:
     return html_attrs
 
 
-def _resolve_attrs(
-    attrs: t.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: t.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: t.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))
-
-
 def _kebab_to_snake(name: str) -> str:
     """Convert a kebab-case name to snake_case."""
     return name.replace("-", "_").lower()
 
 
-def _invoke_component(
+def prep_component_kwargs(
+    callable_info: CallableInfo,
     attrs: AttributesDict,
-    children: list[Node],  # TODO: why not TNode, though?
-    interpolation: Interpolation,
-) -> Node:
-    """
-    Invoke a component callable with the provided attributes and children.
-
-    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.
-
-    Component invocation rules:
-
-    1. All arguments are passed as keywords only. Components cannot require
-    positional arguments.
-
-    2. Children are passed via a "children" parameter when:
-
-    - 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.
-
-    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)
-
+    system_kwargs: AttributesDict,
+) -> AttributesDict:
     if callable_info.requires_positional:
         raise TypeError(
             "Component callables cannot have required positional arguments."
@@ -490,9 +397,9 @@ def _invoke_component(
         if snake_name in callable_info.named_params or callable_info.kwargs:
             kwargs[snake_name] = attr_value
 
-    # Add children if appropriate
-    if "children" in callable_info.named_params or callable_info.kwargs:
-        kwargs["children"] = tuple(children)
+    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
 
     # Check to make sure we've fully satisfied the callable's requirements
     missing = callable_info.required_named_params - kwargs.keys()
@@ -501,88 +408,518 @@ def _invoke_component(
             f"Missing required parameters for component: {', '.join(missing)}"
         )
 
-    result = value(**kwargs)
-    return _node_from_value(result)
+    return kwargs
 
 
-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
+class EndTag:
+    end_tag: str
+
+
+def serialize_html_attrs(
+    html_attrs: HTMLAttributesDict, 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.items()
+        )
+    )
+
+
+def make_ctx(parent_tag: str | None = None, ns: str | None = "html"):
+    return ProcessContext(parent_tag=parent_tag, ns=ns)
+
+
+@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
+
+    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,
+        )
+
+
+type FunctionComponentProto = Callable[..., Template]
+type FactoryComponentProto = Callable[..., ComponentObjectProto]
+type ComponentCallableProto = FunctionComponentProto | FactoryComponentProto
+type ComponentObjectProto = Callable[[], Template]
+
+
+type WalkerProto = Iterable[WalkerProto | None]
+
+
+type NormalTextInterpolationValue = (
+    None | str | Template | Iterable[NormalTextInterpolationValue] | object
+)
+# Applies to both escapable raw text and raw text.
+type RawTextExactInterpolationValue = None | str | HasHTMLDunder | object
+# Applies to both escapable raw text and raw text.
+type RawTextInexactInterpolationValue = None | str | object
+
+
+@dataclass(frozen=True)
+class ParserService:
+    def to_tnode(self, template: Template) -> TNode:
+        return TemplateParser.parse(template)
+
+
+@dataclass(frozen=True)
+class CachedParserService(ParserService):
+    @lru_cache(512)
+    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 BaseProcessorService:
+    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
+
+
+@dataclass(frozen=True)
+class ProcessorService(BaseProcessorService):
+    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:
+        return "".join(self.process_template_chunks(root_template, assume_ctx))
+
+    def process_template_chunks(
+        self, root_template: Template, assume_ctx: ProcessContext | None = None
+    ) -> Iterable[str]:
+        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)
+
+        bf: list[str] = []
+        q: list[WalkerProto] = [
+            self.walk_from_tnode(bf, root_template, assume_ctx, root)
+        ]
+        while q:
+            it = q.pop()
+            if bf:
+                yield "".join(bf)
+                bf.clear()
+            for new_it in it:
+                if new_it is not None:
+                    q.append(it)
+                    q.append(new_it)
+                    break
+        if bf:
+            yield "".join(bf)
+            bf.clear()  # Remove later maybe.
+
+    def walk_from_tnode(
+        self, bf: list[str], template: Template, assume_ctx: ProcessContext, root: TNode
+    ) -> Iterable[WalkerProto]:
+        """
+        Walk around tree and try not to get lost.
+        """
+
+        q: list[tuple[ProcessContext, TNode | EndTag]] = [(assume_ctx, root)]
+        while q:
+            last_ctx, tnode = q.pop()
+            match tnode:
+                case EndTag(end_tag):
+                    bf.append(end_tag)
+                case TDocumentType(text):
+                    if last_ctx.ns != "html":
+                        # Nit
+                        raise ValueError(
+                            "Cannot process document type in subtree of a foreign element."
+                        )
+                    if self.uppercase_doctype:
+                        bf.append(f"<!DOCTYPE {text}>")
+                    else:
+                        bf.append(f"<!doctype {text}>")
+                case TComment(ref):
+                    self._process_comment(bf, template, last_ctx, ref)
+                case TFragment(children):
+                    q.extend([(last_ctx, child) for child in reversed(children)])
+                case TComponent(start_i_index, end_i_index, attrs, children):
+                    res = self._process_component(
+                        bf, template, last_ctx, attrs, start_i_index, end_i_index
+                    )
+                    if res is not None:
+                        yield res
+                case TElement(tag, attrs, children):
+                    bf.append(f"<{tag}")
+                    our_ctx = last_ctx.copy(parent_tag=tag)
+                    if attrs:
+                        self._process_attrs(bf, 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:
+                        bf.append(" />")
+                    else:
+                        bf.append(">")
+                    if tag not in VOID_ELEMENTS:
+                        q.append((last_ctx, EndTag(f"</{tag}>")))
+                        q.extend([(our_ctx, child) for child in reversed(children)])
+                case TText(ref):
+                    if last_ctx.parent_tag is None:
+                        raise NotImplementedError(
+                            "We cannot interpolate texts without knowing what tag they are contained in."
+                        )
+                    elif last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS:
+                        # Must be handled all at once.
+                        self._process_raw_texts(bf, 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.
+                        self._process_escapable_raw_texts(bf, template, last_ctx, ref)
+                    else:
+                        for part in ref:
+                            if isinstance(part, str):
+                                bf.append(self.escape_html_text(part))
+                            else:
+                                res = self._process_normal_text(
+                                    bf, template, last_ctx, part
+                                )
+                                if res is not None:
+                                    yield res
+                case _:
+                    raise ValueError(f"Unrecognized tnode: {tnode}")
+
+    def _process_comment(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        content = resolve_text_without_recursion(template, "<!--", content_ref)
+        bf.append("<!--")
+        if content is None or content == "":
+            pass
+        else:
+            bf.append(
+                self.escape_html_comment(
+                    content,
+                    allow_markup=True,
+                )
             )
-            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
+        bf.append("-->")
+
+    def _process_attrs(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        attrs: tuple[TAttribute, ...],
+    ) -> None:
+        resolved_attrs = _resolve_t_attrs(attrs, template.interpolations)
+        attrs_str = serialize_html_attrs(_resolve_html_attrs(resolved_attrs))
+        if attrs_str:
+            bf.append(attrs_str)
+
+    def _process_component(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        attrs: tuple[TAttribute, ...],
+        start_i_index: int,
+        end_i_index: int | None,
+    ) -> None | WalkerProto:
+        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 = cast(ComponentCallableProto, 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
             )
-            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,
+            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),
+            system_kwargs={"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 = cast(ComponentObjectProto, result_t)
+            result_t = component_obj()
+        else:
+            component_obj = None
+
+        if isinstance(result_t, Template):
+            if result_t.strings == ("",):
+                # DO NOTHING
+                return
+            result_root = self.parser_api.to_tnode(result_t)
+            return self.walk_from_tnode(bf, result_t, last_ctx, result_root)
+        else:
+            raise ValueError(f"Unknown component return value: {type(result_t)}")
+
+    def _process_raw_texts(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        assert last_ctx.parent_tag in CDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        if content is None or content == "":
+            return
+        elif last_ctx.parent_tag == "script":
+            bf.append(
+                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":
+            bf.append(
+                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,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        content_ref: TemplateRef,
+    ) -> None:
+        assert last_ctx.parent_tag in RCDATA_CONTENT_ELEMENTS
+        content = resolve_text_without_recursion(
+            template, last_ctx.parent_tag, content_ref
+        )
+        if content is None or content == "":
+            return
+        else:
+            bf.append(
+                self.escape_html_text(
+                    content,
+                )
+            )
+
+    def _process_normal_text(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        values_index: int,
+    ) -> WalkerProto | None:
+        value = format_interpolation(template.interpolations[values_index])
+        if isinstance(value, str):
+            bf.append(self.escape_html_text(value))
+        elif isinstance(value, Template):
+            value_root = self.parser_api.to_tnode(value)
+            return self.walk_from_tnode(bf, value, last_ctx, value_root)
+        elif isinstance(value, Iterable):
+            return iter(
+                self._process_normal_text_from_value(bf, template, last_ctx, v)
+                for v in value
+            )
+        elif value is None:
+            # @DESIGN: Ignore None.
+            return
+        else:
+            # @DESIGN: Everything that isn't an object we recognize is
+            # coerced to a str() and emitted.
+            bf.append(self.escape_html_text(value))
+
+    def _process_normal_text_from_value(
+        self,
+        bf: list[str],
+        template: Template,
+        last_ctx: ProcessContext,
+        value: NormalTextInterpolationValue,
+    ) -> WalkerProto | None:
+        if isinstance(value, str):
+            bf.append(self.escape_html_text(value))
+        elif isinstance(value, Template):
+            value_root = self.parser_api.to_tnode(value)
+            return self.walk_from_tnode(bf, value, last_ctx, value_root)
+        elif isinstance(value, Iterable):
+            return iter(
+                self._process_normal_text_from_value(bf, template, last_ctx, v)
+                for v in value
+            )
+        elif value is None:
+            # @DESIGN: Ignore None.
+            return
+        else:
+            # @DESIGN: Everything that isn't an object we recognize is
+            # coerced to a str() and emitted.
+            bf.append(self.escape_html_text(value))
+
+
+def resolve_text_without_recursion(
+    template: Template, parent_tag: str, content_ref: TemplateRef
+) -> str | None:
+    """
+    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 = cast(RawTextExactInterpolationValue, value)
+        if value is None:
+            return None
+        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 = cast(RawTextInexactInterpolationValue, value)
+            if value is None:
+                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)
+        if text:
+            return "".join(text)
+        else:
+            return None
+
+
+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
+)
 
 
 # --------------------------------------------------------------------------
@@ -590,8 +927,6 @@ def _resolve_t_node(t_node: TNode, interpolations: tuple[Interpolation, ...]) ->
 # --------------------------------------------------------------------------
 
 
-def html(template: Template) -> Node:
-    """Parse an HTML t-string, substitue 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 to_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)
diff --git a/tdom/processor_test.py b/tdom/processor_test.py
index 11b1c4d..c6e5682 100644
--- a/tdom/processor_test.py
+++ b/tdom/processor_test.py
@@ -1,1446 +1,1595 @@
 import datetime
 import typing as t
-from dataclasses import dataclass, field
-from string.templatelib import Interpolation, Template
-from itertools import product
+from dataclasses import dataclass
+from string.templatelib import Template
+from itertools import product, chain
+from collections.abc import Callable
 
 import pytest
-from markupsafe import Markup
+from markupsafe import Markup, escape as markupsafe_escape
 
-from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
-from .placeholders import make_placeholder_config
-from .processor import html
+from .processor import (
+    to_html as to_html_str,
+    prep_component_kwargs,
+    processor_service_factory,
+    cached_processor_service_factory,
+    make_ctx,
+    CachedParserService,
+)
+from .callables import get_callable_info
+from .escaping import escape_html_text
 
-# --------------------------------------------------------------------------
-# Basic HTML parsing tests
-# --------------------------------------------------------------------------
 
+from .nodes.processor import to_node
 
-#
-# Text
-#
-def test_empty():
-    node = html(t"")
-    assert node == Fragment(children=[])
-    assert str(node) == ""
 
+def to_node_str(*args, **kwargs):
+    """Proxy to to_node but then strify the result to match non-node processor."""
+    return str(to_node(*args, **kwargs))
 
-def test_text_literal():
-    node = html(t"Hello, world!")
-    assert node == Text("Hello, world!")
-    assert str(node) == "Hello, world!"
 
+processor_api = processor_service_factory(slash_void=True, uppercase_doctype=True)
 
-def test_text_singleton():
-    greeting = "Hello, Alice!"
-    node = html(t"{greeting}")
-    assert node == Text("Hello, Alice!")
-    assert str(node) == "Hello, Alice!"
 
+def to_html_str_no_cache(*args, **kwargs):
+    return processor_api.process_template(*args, **kwargs)
 
-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!"
 
+PROCESSORS = [
+    to_html_str,  # by default this is cached
+    to_node_str,  # by default this is cached
+    to_html_str_no_cache,  # we only test one without a cache for test run speed
+]
+" List of processor functions to test against. "
 
-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!"
+# --------------------------------------------------------------------------
+# Basic HTML parsing tests
+# --------------------------------------------------------------------------
 
 
 #
-# Comments.
+# Text
 #
-def test_comment():
-    node = html(t"<!--This is a comment-->")
-    assert node == Comment("This is a comment")
-    assert str(node) == "<!--This is a comment-->"
-
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestBareTemplate:
+    def test_empty(self, to_html):
+        assert to_html(t"") == ""
+
+    def test_text_literal(self, to_html):
+        assert to_html(t"Hello, world!") == "Hello, world!"
+
+    def test_text_singleton(self, to_html):
+        greeting = "Hello, Alice!"
+        assert to_html(t"{greeting}", make_ctx(parent_tag="div")) == "Hello, Alice!"
+        assert to_html(t"{greeting}", make_ctx(parent_tag="script")) == "Hello, Alice!"
+        assert to_html(t"{greeting}", make_ctx(parent_tag="style")) == "Hello, Alice!"
+        assert (
+            to_html(t"{greeting}", make_ctx(parent_tag="textarea")) == "Hello, Alice!"
+        )
+        assert to_html(t"{greeting}", make_ctx(parent_tag="title")) == "Hello, Alice!"
+
+    def test_text_singleton_without_parent(self, to_html):
+        greeting = "</script>"
+        with pytest.raises(NotImplementedError):
+            # Explicitly set the parent tag as None.
+            ctx = make_ctx(parent_tag=None, ns="html")
+            _ = to_html(t"{greeting}", assume_ctx=ctx)
+
+    def test_text_singleton_explicit_parent_script(self, to_html):
+        greeting = "</script>"
+        res = to_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, to_html):
+        greeting = "</div>"
+        res = to_html(t"{greeting}", assume_ctx=make_ctx(parent_tag="div"))
+        assert res == "&lt;/div&gt;"
+        assert res != "</div>"
+
+    def test_text_template(self, to_html):
+        name = "Alice"
+        assert (
+            to_html(t"Hello, {name}!", assume_ctx=make_ctx(parent_tag="div"))
+            == "Hello, Alice!"
+        )
 
-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 test_text_template_escaping(self, to_html):
+        name = "Alice & Bob"
+        assert (
+            to_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, to_html):
+        res = to_html(t"&lt;/p&gt;")
+        assert res == "&lt;/p&gt;", "Default to standard escaping."
 
-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-->"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class LiteralHTML:
+    """Text is returned as is by __html__."""
 
-#
-# Document types.
-#
-def test_parse_document_type():
-    node = html(t"<!doctype html>")
-    assert node == DocumentType("html")
-    assert str(node) == "<!DOCTYPE html>"
+    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
 
-#
-# 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 />'
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestComment:
+    def test_literal(self, to_html):
+        assert to_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, to_html):
+        text = "This is a comment"
+        assert to_html(t"<!--{text}-->") == "<!--This is a comment-->"
 
+    def test_singleton_object(self, to_html):
+        assert to_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, to_html):
+        assert to_html(t"<!--{None}-->") == "<!---->"
 
-def test_parse_entities_are_escaped():
-    node = html(t"<p>&lt;/p&gt;</p>")
-    assert node == Element(
-        "p",
-        children=[Text("</p>")],
-    )
-    assert str(node) == "<p>&lt;/p&gt;</p>"
+    def test_singleton_has_dunder_html(self, to_html):
+        content = LiteralHTML("-->")
+        assert to_html(t"<!--{content}-->") == "<!---->-->", (
+            "DO NOT DO THIS! This is just an advanced escape hatch."
+        )
 
+    def test_singleton_escaping(self, to_html):
+        text = "-->comment"
+        assert to_html(t"<!--{text}-->") == "<!----&gt;comment-->"
+
+    #
+    # Templated -- literal text mixed with interpolation(s)
+    #
+    def test_templated_str(self, to_html):
+        text = "comment"
+        assert to_html(t"<!--This is a {text}-->") == "<!--This is a comment-->"
+
+    def test_templated_object(self, to_html):
+        assert to_html(t"<!--This is a {0}-->") == "<!--This is a 0-->"
+
+    def test_templated_none(self, to_html):
+        assert to_html(t"<!--This is a {None}-->") == "<!--This is a -->"
+
+    def test_templated_has_dunder_html_error(self, to_html):
+        """Objects with __html__ are not processed with literal text or other interpolations."""
+        text = LiteralHTML("in a comment")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<!--This is a {text}-->")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<!--{None}{text}-->")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<!--This is a {Markup('Also check specialized cls.')}-->")
+
+    def test_templated_multiple_interpolations(self, to_html):
+        text = "comment"
+        assert (
+            to_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, to_html):
+        # @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 to_html(t"<!--This is a {text}-->") == "<!--This is a --&gt;comment-->"
 
+    def test_not_supported__recursive_template_error(self, to_html):
+        text_t = t"comment"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_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, to_html):
+        texts = ["This", "is", "a", "comment"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_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>"
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestDocumentType:
+    def test_literal(self, to_html):
+        assert to_html(t"<!doctype html>") == "<!DOCTYPE html>"
 
 
-class Convertible:
-    def __str__(self):
-        return "string"
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestVoidElementLiteral:
+    def test_void(self, to_html):
+        assert to_html(t"<br>") == "<br />"
 
-    def __repr__(self):
-        return "repr"
+    def test_void_self_closed(self, to_html):
+        assert to_html(t"<br />") == "<br />"
 
+    def test_void_mixed_closing(self, to_html):
+        assert to_html(t"<br>Is this content?<br />") == "<br />Is this content?<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_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, to_html):
+        # Make sure our handling of CPython issue #69445 is reasonable.
+        assert (
+            to_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(ValueError):
-        node = html(t"<script>{nested_template}</script>")
-        _ = str(node)
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestNormalTextElementLiteral:
+    def test_empty(self, to_html):
+        assert to_html(t"<div></div>") == "<div></div>"
 
-# --------------------------------------------------------------------------
-# Interpolated non-text content
-# --------------------------------------------------------------------------
+    def test_with_text(self, to_html):
+        assert to_html(t"<p>Hello, world!</p>") == "<p>Hello, world!</p>"
 
+    def test_nested_elements(self, to_html):
+        assert (
+            to_html(t"<div><p>Hello</p><p>World</p></div>")
+            == "<div><p>Hello</p><p>World</p></div>"
+        )
 
-def test_interpolated_false_content():
-    node = html(t"<div>{False}</div>")
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
-
+    def test_entities_are_escaped(self, to_html):
+        """Literal entities interpreted by parser but escaped in output."""
+        res = to_html(t"<p>&lt;/p&gt;</p>")
+        assert res == "<p>&lt;/p&gt;</p>", res
 
-def test_interpolated_none_content():
-    node = html(t"<div>{None}</div>")
-    assert node == Element("div", children=[])
-    assert str(node) == "<div></div>"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestNormalTextElementDynamic:
+    def test_singleton_None(self, to_html):
+        assert to_html(t"<p>{None}</p>") == "<p></p>"
 
-def test_interpolated_zero_arg_function():
-    def get_value():
-        return "dynamic"
+    def test_singleton_str(self, to_html):
+        name = "Alice"
+        assert to_html(t"<p>{name}</p>") == "<p>Alice</p>"
 
-    node = html(t"<p>The value is {get_value}.</p>")
-    assert node == Element(
-        "p", children=[Text("The value is "), Text("dynamic"), Text(".")]
-    )
+    def test_singleton_object(self, to_html):
+        assert to_html(t"<p>{0}</p>") == "<p>0</p>"
 
+    def test_singleton_has_dunder_html(self, to_html):
+        content = LiteralHTML("<em>Alright!</em>")
+        assert to_html(t"<p>{content}</p>") == "<p><em>Alright!</em></p>"
 
-def test_interpolated_multi_arg_function_fails():
-    def add(a, b):  # pragma: no cover
-        return a + b
+    def test_singleton_simple_template(self, to_html):
+        name = "Alice"
+        text_t = t"Hi {name}"
+        assert to_html(t"<p>{text_t}</p>") == "<p>Hi Alice</p>"
 
-    with pytest.raises(TypeError):
-        _ = html(t"<p>The sum is {add}.</p>")
+    def test_singleton_simple_iterable(self, to_html):
+        strs = ["Strings", "...", "Yeah!", "Rock", "...", "Yeah!"]
+        assert to_html(t"<p>{strs}</p>") == "<p>Strings...Yeah!Rock...Yeah!</p>"
 
+    def test_singleton_escaping(self, to_html):
+        text = '''<>&'"'''
+        assert to_html(t"<p>{text}</p>") == "<p>&lt;&gt;&amp;&#39;&#34;</p>"
 
-# --------------------------------------------------------------------------
-# Raw HTML injection tests
-# --------------------------------------------------------------------------
+    def test_templated_None(self, to_html):
+        assert to_html(t"<p>Response: {None}.</p>") == "<p>Response: .</p>"
 
+    def test_templated_str(self, to_html):
+        name = "Alice"
+        assert to_html(t"<p>Response: {name}.</p>") == "<p>Response: Alice.</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_templated_object(self, to_html):
+        assert to_html(t"<p>Response: {0}.</p>") == "<p>Response: 0.</p>"
 
+    def test_templated_has_dunder_html(self, to_html):
+        text = LiteralHTML("<em>Alright!</em>")
+        assert (
+            to_html(t"<p>Response: {text}.</p>")
+            == "<p>Response: <em>Alright!</em>.</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>"
-
+    def test_templated_simple_template(self, to_html):
+        name = "Alice"
+        text_t = t"Hi {name}"
+        assert to_html(t"<p>Response: {text_t}.</p>") == "<p>Response: Hi Alice.</p>"
 
-# --------------------------------------------------------------------------
-# Conditional rendering and control flow
-# --------------------------------------------------------------------------
+    def test_templated_simple_iterable(self, to_html):
+        strs = ["Strings", "...", "Yeah!", "Rock", "...", "Yeah!"]
+        assert (
+            to_html(t"<p>Response: {strs}.</p>")
+            == "<p>Response: Strings...Yeah!Rock...Yeah!.</p>"
+        )
 
+    def test_templated_escaping(self, to_html):
+        text = '''<>&'"'''
+        assert (
+            to_html(t"<p>Response: {text}.</p>")
+            == "<p>Response: &lt;&gt;&amp;&#39;&#34;.</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_escaping_in_literals(self, to_html):
+        text = "This text is fine"
+        assert (
+            to_html(t"<p>The literal has &lt; in it: {text}.</p>")
+            == "<p>The literal has &lt; in it: This text is fine.</p>"
+        )
 
-    assert node == Element(
-        "div", children=[Element("span", children=[Text("Welcome, User!")])]
-    )
-    assert str(node) == "<div><span>Welcome, User!</span></div>"
+    def test_iterable_of_templates(self, to_html):
+        items = ["Apple", "Banana", "Cherry"]
+        assert (
+            to_html(t"<ul>{[t'<li>{item}</li>' for item in items]}</ul>")
+            == "<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>"
+        )
 
-    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_iterable_of_templates_of_iterable_of_templates(self, to_html):
+        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 (
+            to_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_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>")
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestRawTextElementLiteral:
+    def test_script_empty(self, to_html):
+        assert to_html(t"<script></script>") == "<script></script>"
 
-    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_style_empty(self, to_html):
+        assert to_html(t"<style></style>") == "<style></style>"
 
-    show_warning = False
-    node = html(t"<main>{show_warning and warning_message}</main>")
-    # Assuming False renders nothing
-    assert str(node) == "<main></main>"
+    def test_script_with_content(self, to_html):
+        assert to_html(t"<script>var x = 1;</script>") == "<script>var x = 1;</script>"
 
+    def test_style_with_content(self, to_html):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            to_html(t"<style>.red {{ color: red; }}</style>")
+            == "<style>.red { color: red; }</style>"
+        )
 
-# --------------------------------------------------------------------------
-# Interpolated nesting of templates and elements
-# --------------------------------------------------------------------------
+    def test_script_with_content_escaped_in_normal_text(self, to_html):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            to_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, to_html):
+        # @NOTE: Double {{ and }} to avoid t-string interpolation.
+        assert (
+            to_html(t"<style>section > h4 {{ background-color: red; }}</style>")
+            == "<style>section > h4 { background-color: red; }</style>"
+        ), "The > should not be escaped."
 
-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_not_supported_recursive_template_error(self, to_html):
+        text_t = t"comment"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<!--{text_t}-->")
 
+    def test_not_supported_recursive_iterable_error(self, to_html):
+        texts = ["This", "is", "a", "comment"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<!--{texts}-->")
 
-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>"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestEscapableRawTextElementLiteral:
+    def test_title_empty(self, to_html):
+        assert to_html(t"<title></title>") == "<title></title>"
 
-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_textarea_empty(self, to_html):
+        assert to_html(t"<textarea></textarea>") == "<textarea></textarea>"
 
+    def test_title_with_content(self, to_html):
+        assert to_html(t"<title>Content</title>") == "<title>Content</title>"
 
-# --------------------------------------------------------------------------
-# Attributes
-# --------------------------------------------------------------------------
+    def test_textarea_with_content(self, to_html):
+        assert (
+            to_html(t"<textarea>Content</textarea>") == "<textarea>Content</textarea>"
+        )
 
+    def test_title_with_escapable_content(self, to_html):
+        assert (
+            to_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, to_html):
+        assert (
+            to_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."
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestRawTextScriptDynamic:
+    def test_singleton_none(self, to_html):
+        assert to_html(t"<script>{None}</script>") == "<script></script>"
+
+    def test_singleton_str(self, to_html):
+        content = "var x = 1;"
+        assert to_html(t"<script>{content}</script>") == "<script>var x = 1;</script>"
+
+    def test_singleton_object(self, to_html):
+        content = 0
+        assert to_html(t"<script>{content}</script>") == "<script>0</script>"
+
+    def test_singleton_has_dunder_html_pitfall(self, to_html):
+        # @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 = LiteralHTML("</script>")
+        assert to_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_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>"
+    def test_singleton_escaping(self, to_html):
+        content = "</script>"
+        script_t = t"<script>{content}</script>"
+        bad_output = script_t.strings[0] + content + script_t.strings[1]
+        assert to_html(script_t) == "<script>\\x3c/script></script>"
+        assert to_html(script_t) != bad_output, "Sanity check."
+
+    def test_templated_none(self, to_html):
+        assert (
+            to_html(t"<script>var x = 1;{None};</script>")
+            == "<script>var x = 1;;</script>"
         )
-    )
-    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, to_html):
+        content = "var x = 1"
+        assert (
+            to_html(t"<script>var x = 0;{content};</script>")
+            == "<script>var x = 0;var x = 1;</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, to_html):
+        content = 0
+        assert (
+            to_html(t"<script>var x = {content};</script>")
+            == "<script>var x = 0;</script>"
+        )
 
+    def test_templated_has_dunder_html(self, to_html):
+        content = LiteralHTML("anything")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<script>var x = 1;{content}</script>")
+
+    def test_templated_escaping(self, to_html):
+        content = "</script>"
+        script_t = t"<script>var x = '{content}';</script>"
+        bad_output = script_t.strings[0] + content + script_t.strings[1]
+        assert to_html(script_t) == "<script>var x = '\\x3c/script>';</script>"
+        assert to_html(script_t) != bad_output, "Sanity check."
+
+    def test_templated_multiple_interpolations(self, to_html):
+        assert (
+            to_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, to_html):
+        text_t = t"script"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<script>{text_t}</script>")
 
+    def test_not_supported_recursive_iterable_error(self, to_html):
+        texts = ["This", "is", "a", "script"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_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>'
-    )
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestRawTextStyleDynamic:
+    def test_singleton_none(self, to_html):
+        assert to_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, to_html):
+        content = "div { background-color: red; }"
+        assert (
+            to_html(t"<style>{content}</style>")
+            == "<style>div { background-color: red; }</style>"
+        )
 
+    def test_singleton_object(self, to_html):
+        content = 0
+        assert to_html(t"<style>{content}</style>") == "<style>0</style>"
+
+    def test_singleton_has_dunder_html_pitfall(self, to_html):
+        # @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 = LiteralHTML("</style>")
+        assert to_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, to_html):
+        content = "</style>"
+        style_t = t"<style>{content}</style>"
+        bad_output = style_t.strings[0] + content + style_t.strings[1]
+        assert to_html(style_t) == "<style>&lt;/style></style>"
+        assert to_html(style_t) != bad_output, "Sanity check."
+
+    def test_templated_none(self, to_html):
+        assert (
+            to_html(t"<style>h1 {{ background-color: red; }}{None}</style>")
+            == "<style>h1 { background-color: red; }</style>"
+        )
 
+    def test_templated_str(self, to_html):
+        content = " h2 { background-color: blue; }"
+        assert (
+            to_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>"
+    def test_templated_object(self, to_html):
+        padding_right = 0
+        assert (
+            to_html(t"<style>h1 {{ padding-right: {padding_right}px; }}</style>")
+            == "<style>h1 { padding-right: 0px; }</style>"
+        )
 
+    def test_templated_has_dunder_html(self, to_html):
+        content = LiteralHTML("anything")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<style>h1 {{ color: red; }};{content}</style>")
+
+    def test_templated_escaping(self, to_html):
+        content = "</style>"
+        style_t = t"<style>div {{ background-color: red; }} {content}</style>"
+        bad_output = style_t.strings[0] + content + style_t.strings[1]
+        assert (
+            to_html(style_t)
+            == "<style>div { background-color: red; } &lt;/style></style>"
+        )
+        assert to_html(style_t) != bad_output, "Sanity check."
 
-def test_interpolated_attr_none():
-    disabled = None
-    node = html(t"<button disabled={disabled}></button>")
-    assert node == Element("button")
-    assert str(node) == "<button></button>"
+    def test_templated_multiple_interpolations(self, to_html):
+        assert (
+            to_html(
+                t"<style>h1 {{ background-color: {'red'}; }} h2 {{ background-color: {'blue'}; }}</style>"
+            )
+            == "<style>h1 { background-color: red; } h2 { background-color: blue; }</style>"
+        )
 
+    def test_not_supported_recursive_template_error(self, to_html):
+        text_t = t"style"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<style>{text_t}</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_iterable_error(self, to_html):
+        texts = ["This", "is", "a", "style"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<style>{texts}</style>")
 
 
-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>'
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestEscapableRawTextTitleDynamic:
+    def test_singleton_none(self, to_html):
+        assert to_html(t"<title>{None}</title>") == "<title></title>"
 
+    def test_singleton_str(self, to_html):
+        content = "Welcome To TDOM"
+        assert to_html(t"<title>{content}</title>") == "<title>Welcome To TDOM</title>"
 
-def test_spread_attr_none():
-    attrs = None
-    node = html(t"<a {attrs}></a>")
-    assert node == Element("a")
-    assert str(node) == "<a></a>"
+    def test_singleton_object(self, to_html):
+        content = 0
+        assert to_html(t"<title>{content}</title>") == "<title>0</title>"
 
+    def test_singleton_has_dunder_html_pitfall(self, to_html):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        content = LiteralHTML("</title>")
+        assert to_html(t"<title>{content}</title>") == "<title></title></title>", (
+            "DO NOT DO THIS! This is just an advanced escape hatch!"
+        )
 
-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>'
+    def test_singleton_escaping(self, to_html):
+        content = "</title>"
+        assert to_html(t"<title>{content}</title>") == "<title>&lt;/title&gt;</title>"
 
+    def test_templated_none(self, to_html):
+        assert (
+            to_html(t"<title>A great story about: {None}</title>")
+            == "<title>A great story about: </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_templated_str(self, to_html):
+        content = "TDOM"
+        assert (
+            to_html(t"<title>A great story about: {content}</title>")
+            == "<title>A great story about: TDOM</title>"
+        )
 
+    def test_templated_object(self, to_html):
+        content = 0
+        assert (
+            to_html(t"<title>A great number: {content}</title>")
+            == "<title>A great number: 0</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>'
+    def test_templated_has_dunder_html(self, to_html):
+        content = LiteralHTML("No")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<title>Literal html?: {content}</title>")
 
+    def test_templated_escaping(self, to_html):
+        content = "</title>"
+        assert (
+            to_html(t"<title>The end tag: {content}.</title>")
+            == "<title>The end tag: &lt;/title&gt;.</title>"
+        )
 
-def test_attr_merge_replace_literal_attr_str_str():
-    node = html(t'<div title="default" {dict(title="fresh")}></div>')
-    assert node == Element("div", {"title": "fresh"})
-    assert str(node) == '<div title="fresh"></div>'
+    def test_templated_multiple_interpolations(self, to_html):
+        assert (
+            to_html(t"<title>The number {0} is less than {1}.</title>")
+            == "<title>The number 0 is less than 1.</title>"
+        )
 
+    def test_not_supported_recursive_template_error(self, to_html):
+        text_t = t"title"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<title>{text_t}</title>")
 
-def test_attr_merge_replace_literal_attr_str_true():
-    node = html(t'<div title="default" {dict(title=True)}></div>')
-    assert node == Element("div", {"title": None})
-    assert str(node) == "<div title></div>"
+    def test_not_supported_recursive_iterable_error(self, to_html):
+        texts = ["This", "is", "a", "title"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<title>{texts}</title>")
 
 
-def test_attr_merge_replace_literal_attr_true_str():
-    node = html(t"<div title {dict(title='fresh')}></div>")
-    assert node == Element("div", {"title": "fresh"})
-    assert str(node) == '<div title="fresh"></div>'
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestEscapableRawTextTextareaDynamic:
+    def test_singleton_none(self, to_html):
+        assert to_html(t"<textarea>{None}</textarea>") == "<textarea></textarea>"
 
+    def test_singleton_str(self, to_html):
+        content = "Welcome To TDOM"
+        assert (
+            to_html(t"<textarea>{content}</textarea>")
+            == "<textarea>Welcome To TDOM</textarea>"
+        )
 
-def test_attr_merge_remove_literal_attr_str_none():
-    node = html(t'<div title="default" {dict(title=None)}></div>')
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
+    def test_singleton_object(self, to_html):
+        content = 0
+        assert to_html(t"<textarea>{content}</textarea>") == "<textarea>0</textarea>"
+
+    def test_singleton_has_dunder_html_pitfall(self, to_html):
+        # @TODO: We should probably put some double override to prevent this by accident.
+        content = LiteralHTML("</textarea>")
+        assert (
+            to_html(t"<textarea>{content}</textarea>")
+            == "<textarea></textarea></textarea>"
+        ), "DO NOT DO THIS! This is just an advanced escape hatch!"
+
+    def test_singleton_escaping(self, to_html):
+        content = "</textarea>"
+        assert (
+            to_html(t"<textarea>{content}</textarea>")
+            == "<textarea>&lt;/textarea&gt;</textarea>"
+        )
 
+    def test_templated_none(self, to_html):
+        assert (
+            to_html(t"<textarea>A great story about: {None}</textarea>")
+            == "<textarea>A great story about: </textarea>"
+        )
 
-def test_attr_merge_remove_literal_attr_true_none():
-    node = html(t"<div title {dict(title=None)}></div>")
-    assert node == Element("div")
-    assert str(node) == "<div></div>"
+    def test_templated_str(self, to_html):
+        content = "TDOM"
+        assert (
+            to_html(t"<textarea>A great story about: {content}</textarea>")
+            == "<textarea>A great story about: TDOM</textarea>"
+        )
 
+    def test_templated_object(self, to_html):
+        content = 0
+        assert (
+            to_html(t"<textarea>A great number: {content}</textarea>")
+            == "<textarea>A great number: 0</textarea>"
+        )
 
-def test_attr_merge_other_literal_attr_intact():
-    node = html(t'<img title="default" {dict(alt="fresh")}>')
-    assert node == Element("img", {"title": "default", "alt": "fresh"})
-    assert str(node) == '<img title="default" alt="fresh" />'
+    def test_templated_has_dunder_html(self, to_html):
+        content = LiteralHTML("No")
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<textarea>Literal html?: {content}</textarea>")
 
+    def test_templated_multiple_interpolations(self, to_html):
+        assert (
+            to_html(t"<textarea>The number {0} is less than {1}.</textarea>")
+            == "<textarea>The number 0 is less than 1.</textarea>"
+        )
 
-def test_placeholder_collision_avoidance():
-    config = make_placeholder_config()
-    # This test is to ensure that our placeholder detection avoids collisions
-    # even with content that might look like a placeholder.
-    tricky = "0"
-    template = Template(
-        f'<div data-tricky="{config.prefix}',
-        Interpolation(tricky, "tricky", None, ""),
-        f'{config.suffix}"></div>',
-    )
-    node = html(template)
-    assert node == Element(
-        "div",
-        attrs={"data-tricky": config.prefix + tricky + config.suffix},
-        children=[],
-    )
-    assert (
-        str(node) == f'<div data-tricky="{config.prefix}{tricky}{config.suffix}"></div>'
-    )
+    def test_templated_escaping(self, to_html):
+        content = "</textarea>"
+        assert (
+            to_html(t"<textarea>The end tag: {content}.</textarea>")
+            == "<textarea>The end tag: &lt;/textarea&gt;.</textarea>"
+        )
 
+    def test_not_supported_recursive_template_error(self, to_html):
+        text_t = t"textarea"
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<textarea>{text_t}</textarea>")
 
-#
-# 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 test_not_supported_recursive_iterable_error(self, to_html):
+        texts = ["This", "is", "a", "textarea"]
+        with pytest.raises(ValueError, match="not supported"):
+            _ = to_html(t"<textarea>{texts}</textarea>")
 
 
-def test_data_attr_toggle_to_str():
-    for node in [
-        html(t"<div data-selected data={dict(selected='yes')}></div>"),
-        html(t'<div data-selected="no" data={dict(selected="yes")}></div>'),
-    ]:
-        assert node == Element("div", {"data-selected": "yes"})
-        assert str(node) == '<div data-selected="yes"></div>'
+class Convertible:
+    def __str__(self):
+        return "string"
 
+    def __repr__(self):
+        return "repr"
 
-def test_data_attr_toggle_to_true():
-    node = html(t'<div data-selected="yes" data={dict(selected=True)}></div>')
-    assert node == Element("div", {"data-selected": None})
-    assert str(node) == "<div data-selected></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_unrelated_unaffected():
-    node = html(t"<div data-selected data={dict(active=True)}></div>")
-    assert node == Element("div", {"data-selected": None, "data-active": None})
-    assert str(node) == "<div data-selected data-active></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_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))
 
+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_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>"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestInterpolationConversion:
+    def test_str(self, to_html):
+        c = Convertible()
+        for tag in ("p", "script", "title"):
+            assert to_html(wrap_template_in_tags(tag, t"{c!s}")) == wrap_text_in_tags(
+                tag, "string"
+            )
 
-def test_data_attr_errors():
-    for v in [False, [], (), 0, "data?"]:
-        with pytest.raises(TypeError):
-            _ = html(t"<button data={v}>X</button>")
+    def test_repr(self, to_html):
+        c = Convertible()
+        for tag in ("p", "script", "title"):
+            assert to_html(wrap_template_in_tags(tag, t"{c!r}")) == wrap_text_in_tags(
+                tag, "repr"
+            )
 
+    def test_ascii_raw_text(self, to_html):
+        # single quotes are not escaped in raw text
+        assert to_html(
+            wrap_template_in_tags("script", t"{'😊'!a}")
+        ) == wrap_text_in_tags("script", ascii("😊"))
+
+    def test_ascii_escapable_normal_and_raw(self, to_html):
+        # single quotes are escaped
+        for tag in ("p", "title"):
+            assert to_html(
+                wrap_template_in_tags(tag, t"{'😊'!a}")
+            ) == wrap_text_in_tags(tag, escape_html_text(ascii("😊")))
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestInterpolationFormatSpec:
+    def test_normal_text_safe(self, to_html):
+        raw_content = "<u>underlined</u>"
+        assert (
+            to_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, to_html):
+        # @TODO: What should even happen here?
+        raw_content = "</script>"
+        assert (
+            to_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, to_html):
+        raw_content = "<u>underlined</u>"
+        assert (
+            to_html(t"<textarea>{raw_content:safe}</textarea>")
+            == "<textarea><u>underlined</u></textarea>"
+        )
 
+    def test_normal_text_unsafe(self, to_html):
+        supposedly_safe = Markup("<i>italic</i>")
+        assert (
+            to_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, to_html):
+        # @TODO: What should even happen here?
+        supposedly_safe = "</script>"
+        assert (
+            to_html(t"<script>{supposedly_safe:unsafe}</script>")
+            == "<script>\\x3c/script></script>"
+        )
+        assert (
+            to_html(t"<script>{supposedly_safe:unsafe}</script>")
+            != "<script></script></script>"
+        )  # Sanity check
+
+    def test_escapable_raw_text_unsafe(self, to_html):
+        supposedly_safe = Markup("<i>italic</i>")
+        assert (
+            to_html(t"<textarea>{supposedly_safe:unsafe}</textarea>")
+            == "<textarea>&lt;i&gt;italic&lt;/i&gt;</textarea>"
+        )
 
+    def test_all_text_callback(self, to_html):
+        def get_value():
+            return "dynamic"
+
+        for tag in ("p", "script", "style"):
+            assert (
+                to_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, to_html):
+        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."
+            for tag in ("p", "script", "style"):
+                _ = to_html(
+                    Template(f"<{tag}>")
+                    + t"The sum is {add:callback}."
+                    + Template(f"</{tag}>")
+                )
 
 
-#
-# 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 and "disabled", 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."
-
-
-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"})
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestUsagePatterns:
+    def test_conditional_rendering_with_if_else(self, to_html):
+        is_logged_in = True
+        user_profile = t"<span>Welcome, User!</span>"
+        login_prompt = t"<a href='/login'>Please log in</a>"
+        assert (
+            to_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 (
+            to_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
+# --------------------------------------------------------------------------
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestLiteralAttribute:
+    """Test literal (non-dynamic) attributes."""
+
+    def test_literal_attrs(self, to_html):
+        assert (
+            to_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, to_html):
+        assert (
+            to_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>'
-    )
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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, to_html):
+        url = "https://example.com/"
+        assert to_html(t'<a href="{url}"></a>') == '<a href="https://example.com/"></a>'
 
+    def test_interpolated_attr_escaped(self, to_html):
+        url = 'https://example.com/?q="test"&lang=en'
+        assert (
+            to_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, to_html):
+        id = "roquefort"
+        assert to_html(t"<div id={id}></div>") == '<div id="roquefort"></div>'
 
+    def test_interpolated_attr_true(self, to_html):
+        disabled = True
+        assert (
+            to_html(t"<button disabled={disabled}></button>")
+            == "<button disabled></button>"
+        )
 
-def test_style_merged_from_all_attrs():
-    attrs = dict(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, to_html):
+        disabled = False
+        assert to_html(t"<button disabled={disabled}></button>") == "<button></button>"
 
+    def test_interpolated_attr_none(self, to_html):
+        disabled = None
+        assert to_html(t"<button disabled={disabled}></button>") == "<button></button>"
 
-def test_style_override_left_to_right():
-    suffix = t"></p>"
-    parts = [
-        (t'<p style="color: red"', "color: red"),
-        (t" style={dict(color='blue')}", "color: blue"),
-        (t''' style="color: {"green"}"''', "color: green"),
-        (t""" {dict(style=dict(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
-        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, to_html):
+        assert to_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>'
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestSpreadAttribute:
+    """Test spread attributes."""
 
+    def test_spread_attr(self, to_html):
+        attrs = {"href": "https://example.com/", "target": "_blank"}
+        assert (
+            to_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, to_html):
+        attrs = None
+        assert to_html(t"<a {attrs}></a>") == "<a></a>"
+
+    def test_spread_attr_type_errors(self, to_html):
+        for attrs in (0, [], (), False, True):
+            with pytest.raises(TypeError):
+                _ = to_html(t"<a {attrs}></a>")
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestTemplatedAttribute:
+    def test_templated_attr_mixed_interpolations_start_end_and_nest(self, to_html):
+        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 to_html(test_t) == '<div data-range="1-3-5"></div>'
+
+    def test_templated_attr_no_quotes(self, to_html):
+        start = 1
+        end = 5
+        assert (
+            to_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>")
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestAttributeMerging:
+    def test_attr_merge_disjoint_interpolated_attr_spread_attr(self, to_html):
+        attrs = {"href": "https://example.com/", "id": "link1"}
+        target = "_blank"
+        assert (
+            to_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, to_html):
+        attrs1 = {"href": "https://example.com/", "id": "overwrtten"}
+        attrs2 = {"target": "_blank", "id": "link1"}
+        assert (
+            to_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, to_html):
+        assert (
+            to_html(t'<div title="default" {dict(title="fresh")}></div>')
+            == '<div title="fresh"></div>'
+        )
 
+    def test_attr_merge_replace_literal_attr_str_true(self, to_html):
+        assert (
+            to_html(t'<div title="default" {dict(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, to_html):
+        assert (
+            to_html(t"<div title {dict(title='fresh')}></div>")
+            == '<div title="fresh"></div>'
+        )
 
+    def test_attr_merge_remove_literal_attr_str_none(self, to_html):
+        assert (
+            to_html(t'<div title="default" {dict(title=None)}></div>') == "<div></div>"
+        )
 
-# --------------------------------------------------------------------------
-# Function component interpolation tests
-# --------------------------------------------------------------------------
+    def test_attr_merge_remove_literal_attr_true_none(self, to_html):
+        assert to_html(t"<div title {dict(title=None)}></div>") == "<div></div>"
 
+    def test_attr_merge_other_literal_attr_intact(self, to_html):
+        assert (
+            to_html(t'<img title="default" {dict(alt="fresh")}>')
+            == '<img title="default" alt="fresh" />'
+        )
 
-def FunctionComponent(
-    children: t.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>"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestSpecialDataAttribute:
+    """Special data attribute handling."""
+
+    def test_interpolated_data_attributes(self, to_html):
+        data = {
+            "user-id": 123,
+            "role": "admin",
+            "wild": True,
+            "false": False,
+            "none": None,
+        }
+        assert (
+            to_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, to_html):
+        for res in [
+            to_html(t"<div data-selected data={dict(selected='yes')}></div>"),
+            to_html(t'<div data-selected="no" data={dict(selected="yes")}></div>'),
+        ]:
+            assert res == '<div data-selected="yes"></div>'
 
+    def test_data_attr_toggle_to_true(self, to_html):
+        res = to_html(t'<div data-selected="yes" data={dict(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, to_html):
+        res = to_html(t"<div data-selected data={dict(active=True)}></div>")
+        assert res == "<div data-selected data-active></div>"
 
+    def test_data_attr_templated_error(self, to_html):
+        data1 = {"user-id": "user-123"}
+        data2 = {"role": "admin"}
+        with pytest.raises(TypeError):
+            _ = to_html(t'<div data="{data1} {data2}"></div>')
+
+    def test_data_attr_none(self, to_html):
+        button_data = None
+        res = to_html(t"<button data={button_data}>X</button>")
+        assert res == "<button>X</button>"
+
+    def test_data_attr_errors(self, to_html):
+        for v in [False, [], (), 0, "data?"]:
+            with pytest.raises(TypeError):
+                _ = to_html(t"<button data={v}>X</button>")
+
+    def test_data_literal_attr_bypass(self, to_html):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = to_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}>")
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestSpecialAriaAttribute:
+    """Special aria attribute handling."""
 
-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_templated_attr_error(self, to_html):
+        aria1 = {"label": "close"}
+        aria2 = {"hidden": "true"}
+        with pytest.raises(TypeError):
+            _ = to_html(t'<div aria="{aria1} {aria2}"></div>')
+
+    def test_aria_interpolated_attr_dict(self, to_html):
+        aria = {"label": "Close", "hidden": True, "another": False, "more": None}
+        res = to_html(t"<button aria={aria}>X</button>")
+        assert (
+            res
+            == '<button aria-label="Close" aria-hidden="true" aria-another="false">X</button>'
+        )
 
+    def test_aria_interpolate_attr_none(self, to_html):
+        button_aria = None
+        res = to_html(t"<button aria={button_aria}>X</button>")
+        assert res == "<button>X</button>"
+
+    def test_aria_attr_errors(self, to_html):
+        for v in [False, [], (), 0, "aria?"]:
+            with pytest.raises(TypeError):
+                _ = to_html(t"<button aria={v}>X</button>")
+
+    def test_aria_literal_attr_bypass(self, to_html):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = to_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>'
-    )
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestSpecialClassAttribute:
+    """Special class attribute handling."""
+
+    def test_interpolated_class_attribute(self, to_html):
+        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 = to_html(button_t)
+        assert (
+            res
+            == '<button class="red btn btn-primary one two active blue green yellow">Click me</button>'
+        )
 
-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_class_attribute_with_multiple_placeholders(self, to_html):
+        classes1 = ["btn", "btn-primary"]
+        classes2 = [False and "disabled", None, {"active": True}]
+        res = to_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 test_interpolated_attribute_spread_with_class_attribute(self, to_html):
+        attrs = {"id": "button1", "class": ["btn", "btn-primary"]}
+        res = to_html(t"<button {attrs}>Click me</button>")
+        assert res == '<button id="button1" class="btn btn-primary">Click me</button>'
 
-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_literal_attr_bypass(self, to_html):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = to_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_class_none_ignored(self, to_html):
+        class_item = None
+        res = to_html(t"<p class={class_item}></p>")
+        assert res == "<p></p>"
+        # Also ignored inside a sequence.
+        res = to_html(t"<p class={[class_item]}></p>")
+        assert res == "<p></p>"
+
+    def test_class_type_errors(self, to_html):
+        for class_item in (False, True, 0):
+            with pytest.raises(TypeError):
+                _ = to_html(t"<p class={class_item}></p>")
+            with pytest.raises(TypeError):
+                _ = to_html(t"<p class={[class_item]}></p>")
+
+    def test_class_merge_literals(self, to_html):
+        res = to_html(t'<p class="red" class="blue"></p>')
+        assert res == '<p class="red blue"></p>'
+
+    def test_class_merge_literal_then_interpolation(self, to_html):
+        class_item = "blue"
+        res = to_html(t'<p class="red" class="{[class_item]}"></p>')
+        assert res == '<p class="red blue"></p>'
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestSpecialStyleAttribute:
+    """Special style attribute handling."""
+
+    def test_style_literal_attr_passthru(self, to_html):
+        p_id = "para1"  # non-literal attribute to cause attr resolution
+        res = to_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, to_html):
+        styles = {"color": "red", "font-weight": "bold", "font-size": "16px"}
+        res = to_html(t"<p style={styles}>Warning!</p>")
+        assert (
+            res
+            == '<p style="color: red; font-weight: bold; font-size: 16px">Warning!</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_in_templated_attr(self, to_html):
+        color = "red"
+        res = to_html(t'<p style="color: {color}">Warning!</p>')
+        assert res == '<p style="color: red">Warning!</p>'
+
+    def test_style_in_spread_attr(self, to_html):
+        attrs = {"style": {"color": "red"}}
+        res = to_html(t"<p {attrs}>Warning!</p>")
+        assert res == '<p style="color: red">Warning!</p>'
+
+    def test_style_merged_from_all_attrs(self, to_html):
+        attrs = dict(style="font-size: 15px")
+        style = {"font-weight": "bold"}
+        color = "red"
+        res = to_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_style_override_left_to_right(self, to_html):
+        suffix = t"></p>"
+        parts = [
+            (t'<p style="color: red"', "color: red"),
+            (t" style={dict(color='blue')}", "color: blue"),
+            (t' style="color: {"green"}"', "color: green"),
+            (t""" {dict(style=dict(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 = to_html(t)
+            assert res == f'<p style="{expected_style}"></p>'
+
+    def test_interpolated_style_attribute_multiple_placeholders(self, to_html):
+        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):
+            _ = to_html(t"<p style='{styles1} {styles2}'>Warning!</p>")
+
+    def test_interpolated_style_attribute_merged(self, to_html):
+        styles1 = {"color": "red"}
+        styles2 = {"font-weight": "bold"}
+        res = to_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, to_html):
+        styles1 = {"color": "red", "font-weight": "normal"}
+        styles2 = {"font-weight": "bold"}
+        res = to_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, to_html):
+        styles = "color: red; font-weight: bold;"
+        res = to_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, to_html):
+        with pytest.raises(TypeError):
+            styles = [1, 2]
+            _ = to_html(t"<p style={styles}>Warning!</p>")
+
+    def test_style_literal_attr_bypass(self, to_html):
+        # Trigger overall attribute resolution with an unrelated interpolated attr.
+        res = to_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 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_style_none(self, to_html):
+        styles = None
+        res = to_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}, system_kwargs={}) == {
+            "size": 20
+        }
+        assert prep_component_kwargs(
+            callable_info, {"type": "email"}, system_kwargs={}
+        ) == {"type": "email"}
+        assert prep_component_kwargs(callable_info, {}, system_kwargs={}) == {}
+
+    @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}, system_kwargs={})
+                == {}
+            )
 
 
-def test_component_passed_as_attr_value():
-    def Wrapper(
-        children: t.Iterable[Node], sub_component: t.Callable, **attrs: t.Any
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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() -> t.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, to_html):
+        res = to_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_component_returning_fragment():
-    def Items() -> Node:
-        return html(t"<li>Item {1}</li><li>Item {2}</li><li>Item {3}</li>")
+    def test_with_no_children(self, to_html):
+        """Same test, but the caller didn't provide any children."""
+        res = to_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>'
+        )
 
-    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>"
+    def test_missing_props_error(self, to_html):
+        with pytest.raises(TypeError):
+            _ = to_html(
+                t"<{self.FunctionComponent}>Missing props</{self.FunctionComponent}>"
+            )
 
 
-@dataclass
-class ClassComponent:
-    """Example class-based component."""
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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, to_html):
+        res = to_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>'
+        )
 
-    user_name: str
-    image_url: str
-    homepage: str = "#"
-    children: t.Iterable[Node] = field(default_factory=list)
 
-    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>",
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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 test_children_always_passed_via_kwargs(self, to_html):
+        res = to_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, to_html):
+        res = to_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>'
-    )
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestComponentSpecialUsage:
+    @staticmethod
+    def ColumnsComponent() -> Template:
+        return t"""<td>Column 1</td><td>Column 2</td>"""
 
-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>'
-    )
+    def test_fragment_from_component(self, to_html):
+        # This test assumes that if a component returns a template that parses
+        # into multiple root elements, they are treated as a fragment.
+        res = to_html(t"<table><tr><{self.ColumnsComponent} /></tr></table>")
+        assert res == "<table><tr><td>Column 1</td><td>Column 2</td></tr></table>"
 
+    def test_component_passed_as_attr_value(self, to_html):
+        def Wrapper(
+            children: Template, sub_component: t.Callable, **attrs: t.Any
+        ) -> Template:
+            return t"<{sub_component} {attrs}>{children}</{sub_component}>"
 
-@dataclass
-class ClassComponentNoChildren:
-    """Example class-based component that does not ask for children."""
+        res = to_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>'
+        )
 
-    user_name: str
-    image_url: str
-    homepage: str = "#"
+    def test_nested_component_gh23(self, to_html):
+        # @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 = to_html(t"<{Header} />", assume_ctx=make_ctx(parent_tag="div"))
+        assert res == "Hello World"
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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 __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>",
+    def test_class_component_implicit_invocation_with_children(self, to_html):
+        res = to_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, to_html):
+        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 = to_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 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>'
-    )
+    @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>"
+            )
 
+    def test_implicit_invocation_ignore_children(self, to_html):
+        res = to_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 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!"
 
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_attribute_type_component(to_html):
+    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!"
 
-def test_attribute_type_component():
     an_int: int = 42
     a_true: bool = True
     a_false: bool = False
@@ -1457,31 +1606,426 @@ def test_attribute_type_component():
         "spread_dict": dict(),
         "spread_list": ["eggs", "milk"],
     }
-    node = html(
+    res = to_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!"
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+class TestComponentErrors:
+    def test_component_non_callable_fails(self, to_html):
+        with pytest.raises(TypeError):
+            _ = to_html(t"<{'not a function'} />")
+
+    def test_component_requiring_positional_arg_fails(self, to_html):
+        def RequiresPositional(whoops: int, /) -> Template:  # pragma: no cover
+            return t"<p>Positional arg: {whoops}</p>"
+
+        with pytest.raises(TypeError):
+            _ = to_html(t"<{RequiresPositional} />")
+
+    def test_mismatched_component_closing_tag_fails(self, to_html):
+        def OpenTag(children: Template) -> Template:
+            return t"<div>open</div>"
+
+        def CloseTag(children: Template) -> Template:
+            return t"<div>close</div>"
+
+        with pytest.raises(TypeError):
+            _ = to_html(t"<{OpenTag}>Hello</{CloseTag}>")
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_integration_basic(to_html):
+    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 to_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
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_repeat_calls(to_html):
+    """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 (
+            to_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("to_html", PROCESSORS)
+@pytest.mark.parametrize(
+    "provider",
+    (
+        get_select_t_with_list,
+        get_select_t_with_generator,
+        get_select_t_with_concat,
+    ),
+)
+def test_process_template_iterables(to_html, provider):
+    def get_color_select_t(selected_values: set, provider: t.Callable) -> Template:
+        PRIMARY_COLORS = [("R", "Red"), ("Y", "Yellow"), ("B", "Blue")]
+        assert set(selected_values).issubset(set([opt[0] for opt in PRIMARY_COLORS]))
+        return provider(PRIMARY_COLORS, selected_values)
+
+    no_selection_t = get_color_select_t(set(), provider)
+    assert (
+        to_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 (
+        to_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'} />")
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_component_integration(to_html):
+    """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 = to_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>
+"""
+    )
+
+
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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, to_html):
+        """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>'
+            _ = to_html(t"<script>{content_t}</script>")
+
+    def test_dynamic_escapable_raw_text(self, to_html):
+        """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"
+        ):
+            _ = to_html(t"<textarea>{content_t}</textarea>")
+
+    def test_dynamic_normal_text(self, to_html):
+        """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 (
+            to_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}>"
+@pytest.mark.parametrize("to_html", PROCESSORS)
+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, to_html):
+        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 = to_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>'
+        )
+
+
+@pytest.mark.skip(
+    "SVG+MATHML: This needs ns context for case correcting tags and attributes."
+)
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_mathml(to_html):
+    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 = to_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>"""
+    )
+
+
+@pytest.mark.skip(
+    "SVG+MATHML: This needs ns context for case correcting tags and attributes."
+)
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_svg(to_html):
+    cx, cy, r, fill = 150, 100, 80, "green"
+    svg_t = t"""<svg version="1.1" width="300" height="200" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="red" />
+  <circle cx={cx} cy={cy} r={r} fill={fill} />
+  <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>
+</svg>"""
+    res = to_html(svg_t)
+    assert (
+        res
+        == """<svg version="1.1" width="300" height="200" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="red"></rect>
+  <circle cx="150" cy="100" r="80" fill="green"></circle>
+  <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>
+</svg>"""
+    )
+
+
+@pytest.mark.skip("SVG+MATHML: This needs ns context for closing empty tags.")
+@pytest.mark.parametrize("to_html", PROCESSORS)
+def test_svg_self_closing_empty_elements(to_html):
+    cx, cy, r, fill = 150, 100, 80, "green"
+    svg_t = t"""<svg width="300" height="200">
+  <rect width="100%" height="100%" fill="red" />
+  <circle cx={cx} cy={cy} r={r} fill={fill} />
+  <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>
+</svg>"""
+    res = to_html(svg_t)
+    assert (
+        res
+        == """<svg width="300" height="200">
+  <rect width="100%" height="100%" fill="red" />
+  <circle cx="150" cy="100" r="80" fill="green" />
+  <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>
+</svg>"""
+    )
diff --git a/tdom/protocols.py b/tdom/protocols.py
new file mode 100644
index 0000000..bcb8147
--- /dev/null
+++ b/tdom/protocols.py
@@ -0,0 +1,6 @@
+import typing as t
+
+
+@t.runtime_checkable
+class HasHTMLDunder(t.Protocol):
+    def __html__(self) -> str: ...  # pragma: no cover
diff --git a/tdom/protocols_test.py b/tdom/protocols_test.py
new file mode 100644
index 0000000..9f7b663
--- /dev/null
+++ b/tdom/protocols_test.py
@@ -0,0 +1,24 @@
+from markupsafe import Markup, escape
+
+
+from .protocols import HasHTMLDunder
+
+
+class LTEntity:
+    def __html__(self):
+        return "&lt;"
+
+
+def test_custom_html_dunder_isinstance_has_html_dunder():
+    lt = LTEntity()
+    assert isinstance(lt, HasHTMLDunder)
+
+
+def test_markup_isinstance_has_html_dunder():
+    wrapped_html = Markup(escape("<div>"))
+    assert isinstance(wrapped_html, HasHTMLDunder)
+
+
+def test_str_not_isinstance_has_html_dunder():
+    html_str = "<div>"
+    assert not isinstance(html_str, HasHTMLDunder)
diff --git a/tdom/sentinel.py b/tdom/sentinel.py
new file mode 100644
index 0000000..a292332
--- /dev/null
+++ b/tdom/sentinel.py
@@ -0,0 +1,10 @@
+"""
+Simple sentinel, ie. NOT_SET / NOT_GIVEN for use in project.
+"""
+
+
+class NotSet:
+    pass
+
+
+NOT_SET = NotSet()
diff --git a/tdom/template_utils.py b/tdom/template_utils.py
index 39dc8b3..c6e39e1 100644
--- a/tdom/template_utils.py
+++ b/tdom/template_utils.py
@@ -74,3 +74,19 @@ def __post_init__(self):
             raise ValueError(
                 "TemplateRef must have one more string than interpolation indexes."
             )
+
+    def __iter__(self):
+        index = 0
+        last_s_index = len(self.strings) - 1
+        while index <= last_s_index:
+            s = self.strings[index]
+            if s:
+                yield s
+            if index < last_s_index:
+                yield self.i_indexes[index]
+            index += 1
+
+    def resolve(self, interpolations: tuple[Interpolation, ...]) -> Template:
+        """Use the given interpolations to resolve this reference template into a Template."""
+        resolved = [interpolations[i_index] for i_index in self.i_indexes]
+        return template_from_parts(self.strings, resolved)
diff --git a/tdom/template_utils_test.py b/tdom/template_utils_test.py
index 971b1ee..1602487 100644
--- a/tdom/template_utils_test.py
+++ b/tdom/template_utils_test.py
@@ -55,3 +55,49 @@ def test_combine_template_refs():
     assert combine_template_refs(*template_refs) == TemplateRef.from_naive_template(
         t"abc{0}def{1}{2}ghi"
     )
+
+
+def test_template_ref_iter_singleton():
+    assert list(TemplateRef.from_naive_template(t"{1}")) == [1]
+
+
+def test_template_ref_iter_empty():
+    assert list(TemplateRef.from_naive_template(t"")) == []
+
+
+def test_template_ref_iter_empty_prefix():
+    assert list(TemplateRef.from_naive_template(t"{1}def")) == [1, "def"]
+
+
+def test_template_ref_iter_empty_suffix():
+    assert list(TemplateRef.from_naive_template(t"abc{1}")) == ["abc", 1]
+
+
+def test_template_ref_iter_literal():
+    assert list(TemplateRef.from_naive_template(t"abc")) == ["abc"]
+
+
+def test_template_ref_iter_only_interpolations():
+    assert list(TemplateRef.from_naive_template(t"{1}{3}{5}")) == [1, 3, 5]
+
+
+def test_template_ref_iter_complete():
+    assert list(TemplateRef.from_naive_template(t"abc{1}def{3}ghi{5}jkl")) == [
+        "abc",
+        1,
+        "def",
+        3,
+        "ghi",
+        5,
+        "jkl",
+    ]
+
+
+def test_template_ref_resolve():
+    src_t = t"{'a'}b{'c'}d{'e'}f"
+    src_ref = TemplateRef(
+        strings=src_t.strings, i_indexes=tuple(range(len(src_t.interpolations)))
+    )
+    resolved_t = src_ref.resolve(src_t.interpolations)
+    assert resolved_t.values == ("a", "c", "e")
+    assert resolved_t.strings == ("", "b", "d", "f")