diff --git a/CHANGELOG.md b/CHANGELOG.md
index f19866d..7aec2cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,34 +9,60 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking changes
 
-* `Tagifiable.tagify()` now returns `Tagified`, a tighter type that
-  excludes the un-resolved `Tagifiable` arm of `TagNode`. Custom
-  `.tagify()` implementations annotated with bare `TagList` or `Tag`
-  return types will fail static type checking; update them to
-  `-> Tagified` (or omit the return annotation). Runtime behavior of
-  correct `.tagify()` implementations is unchanged. (#105)
+* `Tagifiable.tagify()` now returns `Tagified` — a non-generic union
+  that mirrors `TagChild`'s shape (including the flattening
+  conveniences `float`, `None`, `Sequence[Tagified]`) but excludes the
+  un-resolved `Tagifiable` arm. Custom `.tagify()` implementations
+  annotated with bare `TagList` or `Tag` return types will fail
+  static type checking; update them to `-> Tagified` (or omit the
+  return annotation). Runtime behavior of correct implementations is
+  unchanged. (#105, #116, #117)
 
 * `Tag.tagify()` no longer preserves the caller's `Tag` subclass in
   its return type. Code relying on the previous subclass-preserving
   signature should `cast` the result. (#105)
 
+* `TagifiedTagList` is now a real subclass of `TagList["TagifiedNode"]`
+  (previously a `TypeAliasType` alias). `TagifiedTag` is a new parallel
+  subclass of `Tag["TagifiedNode"]`. Both are returned by `.tagify()`
+  and are runtime-`isinstance`-checkable. Their `__init__` / `append`
+  / `extend` / `insert` are statically narrowed to `Tagified`, so
+  pyright flags `tagified.append(SomeTagifiable())` at the call site.
+  The classes stay internal to `htmltools._core` — they are not
+  re-exported from the top-level `htmltools` namespace — so code that
+  wants to `isinstance`-check imports them explicitly from there.
+  Code that depended on `TagifiedTagList` being an alias (e.g.,
+  `typing.get_type_hints` introspection) needs to treat it as a
+  class instead.
+
+  In practice, pyright remains permissive about flowing a
+  `TagifiedTagList` into a parameter typed as bare `TagList` (or
+  `TagList[TagNode]`), so most downstream consumers of `.tagify()`'s
+  return do NOT need migration. (#116)
+
 ### New features
 
 * `Tag` and `TagList` are now generic in their child type, defaulting
-  to `TagNode`. Bare `Tag` / `TagList` retain today's meaning. Mutation
-  methods (`append` / `extend` / `insert`) still accept `Tagifiable` at
-  static-type-check time even on tagified containers — the invariant
-  is enforced at runtime instead (`TagList.tagify()` raises `TypeError`
-  and `get_html_string` raises `RuntimeError` for an un-tagified
-  subtree). See `tests/test_types.py` for the rationale. (#105)
-
-* Added the public type alias `Tagified` — the union of all
-  fully-tagified shapes — for use as the return annotation of
-  `Tagifiable.tagify()` implementations. (#105)
+  to `TagNode`. Bare `Tag` / `TagList` retain today's meaning. (#105)
 
 ### Bug fixes
 
-* `TagList.tagify()` now raises `TypeError` at the boundary when a child's `.tagify()` returns a `TagList` containing an un-tagified `Tagifiable` object. The error names the offending class and slot index so buggy `.tagify()` implementations surface at the source rather than later at render time. The render-time `RuntimeError` raised by `get_html_string()` for an un-tagified child has also been clarified to include the offending class name and a hint that the tree was likely mutated after `.tagify()` was called. (#7, #105, #112)
+* `TagList.tagify()` now defensively normalizes every shape a child's
+  `.tagify()` can return. A return whose contents still include an
+  un-tagified `Tagifiable`, or a return that is itself a bare `Tag` /
+  `TagList` rather than a `TagifiedTag` / `TagifiedTagList`, raises
+  `TypeError` at the boundary, naming the offending class and slot
+  index. (Pyright already rejects these at the call site via the
+  `Tagified` return-type annotation; the runtime guard catches
+  implementations that bypass static checking.) `None` is dropped,
+  `float`/`int` is str-ified, and `Sequence` is flattened —
+  previously these last three shapes either crashed the render path
+  (`None` → `TypeError` in `html_escape`) or silently corrupted the
+  tag tree. The render-time `RuntimeError` raised by
+  `get_html_string()` for an un-tagified child has also been
+  clarified to include the offending class name and a hint that the
+  tree was likely mutated after `.tagify()` was called. (#7, #105,
+  #112, #117)
 
 ### Dependencies
 
diff --git a/htmltools/_core.py b/htmltools/_core.py
index cefc0ee..53b73f6 100644
--- a/htmltools/_core.py
+++ b/htmltools/_core.py
@@ -44,7 +44,7 @@
 from typing import Literal, Protocol, SupportsIndex, runtime_checkable
 
 from packaging.version import Version
-from typing_extensions import TypeAliasType, TypeVar
+from typing_extensions import TypeVar
 
 from ._util import (
     ensure_http_server,
@@ -70,6 +70,8 @@
     "TagFunction",
     "Tagifiable",
     "Tagified",
+    "TagifiedTag",
+    "TagifiedTagList",
     "consolidate_attrs",
     "head_content",
     "is_tag_child",
@@ -113,18 +115,6 @@ class MetadataNode:
 # -----------------------------------------------------------------------------
 # Tagified shape aliases
 # -----------------------------------------------------------------------------
-# `TagifiedTagList` uses `TypeAliasType` so that the alias *name*
-# survives in pyright diagnostics (users see `TagifiedTagList` rather
-# than the expanded structural union) and so its forward reference to
-# `TagifiedNode` (defined later in the file) is resolved lazily.
-# (Contrast `Tagified` below, which is a plain `Union` because
-# `TypeAliasType` over its recursive arm leaks `Unknown` through
-# downstream pyright analysis — see the comment above that definition.)
-TagifiedTagList = TypeAliasType("TagifiedTagList", "TagList[TagifiedNode]")
-"""
-A `TagList` whose items are all tagified. This is the return type of
-`TagList.tagify()`.
-"""
 
 # Kept as a plain `Union` (not `TypeAliasType`) so the arms are visible
 # in pyright diagnostics — a value typed as `TagNodeLeaf` shows up as
@@ -142,7 +132,7 @@ class MetadataNode:
 # .tagify() still needs to be called. Recursive — a tagified Tag's children
 # are themselves tagified. TagList is NOT a member because TagList children
 # are flattened (a TagList never appears as a child slot of another TagList).
-TagifiedNode = Union["Tag[TagifiedNode]", TagNodeLeaf]
+TagifiedNode = Union["TagifiedTag", TagNodeLeaf]
 """
 A fully-tagified child-slot type. Members never include an un-resolved
 `Tagifiable`; calling `.tagify()` on a node tree returns a structure whose
@@ -153,11 +143,36 @@ class MetadataNode:
 # recursive-alias resolution leaks `Unknown` when downstream packages
 # inspect the type in strict mode. The alias name is then lost in
 # diagnostics, but downstream pyright stays clean.
-Tagified = Union[TagifiedTagList, TagifiedNode]
+#
+# `TagifiedChild` is the input-side type for mutators on `TagifiedTagList`
+# / `TagifiedTag` — it parallels `TagChild` (the input type for
+# `TagList` / `Tag` mutators) but excludes the un-resolved `Tagifiable`
+# arm. Non-generic for the same reason `TagChild` is non-generic (see
+# the comment near `TagChild`'s definition below). Defined here as an
+# internal name so maintainers reading this file can see the structural
+# parallel to `TagChild`; the publicly-exported name is `Tagified`,
+# aliased below.
+TagifiedChild = Union[
+    TagifiedNode,
+    "TagifiedTagList",
+    float,
+    None,
+    Sequence["TagifiedChild"],
+]
+
+Tagified = TagifiedChild
 """
-Anything `.tagify()` is permitted to return: either a top-level
-`TagifiedTagList`, or one of the `TagifiedNode` shapes (a fully-tagified
-`Tag` or a leaf).
+The shape contract for fully-tagified content. Used as:
+
+- the return type of `Tagifiable.tagify()` (and the protocol it satisfies),
+- the input-side type for mutation methods on `TagifiedTagList` /
+  `TagifiedTag` (`append` / `extend` / `insert` / `__init__`).
+
+Mirrors `TagChild` (the un-tagified input type) but excludes the
+`Tagifiable` arm — values typed `Tagified` are post-`.tagify()` shapes.
+The flattening conveniences (`float`, `None`, `Sequence[Tagified]`)
+match `TagChild`'s shape so the input-normalization machinery can be
+reused on both sides.
 """
 
 
@@ -191,12 +206,14 @@ class MetadataNode:
 # arm caused pyright to leak `Sequence[Unknown]` into every `Tag`
 # function signature when inspected from a downstream module in
 # strict mode (e.g. Shiny's CI reported 2500+
-# `reportUnknownMemberType` errors). The trade-off is that
-# `TagList[TagifiedNode].append(some_tagifiable)` no longer
-# static-errors — the runtime guard in `TagList.get_html_string`
-# still catches it at render time. See
-# `tests/test_types.py::test_TagifiedTagList_append_accepts_Tagifiable`
-# for the full rationale.
+# `reportUnknownMemberType` errors). The non-generic alias is the
+# only form that doesn't leak.
+#
+# Static input enforcement on tagified containers
+# (`TagifiedTagList.append(some_tagifiable)` must error) is provided
+# instead by the narrow-signature mutator overrides on
+# `TagifiedTagList` / `TagifiedTag`, which accept the non-generic
+# parallel union `Tagified` (defined above). See #116.
 TagChild = Union[
     TagNode,
     "TagList",
@@ -404,11 +421,14 @@ def tagify(self) -> "TagifiedTagList":
             slot index so the broken ``.tagify()`` is easy to find.
         """
 
-        # Internally work with `TagList[Any]` so the loop body's assignments
-        # don't need per-line casts. The runtime invariants are checked by
-        # the post-condition loop below; the final `cast` narrows back to
-        # `TagifiedTagList` for the public return type.
-        cp: "TagList[Any]" = cast("TagList[Any]", copy(self))
+        # Construct a TagifiedTagList directly (not a cast over copy(self)) so
+        # the runtime instance is the subclass. We populate .data manually with
+        # a shallow copy of self.data, then iterate as before.
+        # Cast: self.data is list[TagNodeT] (pre-tagification); cp.data is
+        # typed list[TagifiedNode] (post-tagification). The mutation loop below
+        # converts all items in place, so the cast is valid by the time we return.
+        cp = TagifiedTagList()
+        cp.data = cast("list[TagifiedNode]", list(self.data))
 
         # Iterate backwards because if we hit a Tagifiable object, it may be replaced
         # with 0, 1, or more items (if it returns TagList).
@@ -417,36 +437,52 @@ def tagify(self) -> "TagifiedTagList":
 
             if isinstance(child, Tagifiable):
                 tagified_child = child.tagify()
-                if isinstance(tagified_child, TagList):
-                    # Flatten the returned TagList into this one. Cast: pyright
-                    # cannot fully resolve `TagifiedTagList`'s recursive child
-                    # alias here, leaving a `TagList[Unknown]` arm.
-                    cp[i : i + 1] = _tagchilds_to_tagnodes(
-                        cast("TagList[TagNode]", tagified_child)
-                    )
-                else:
-                    cp[i] = tagified_child
+                # Normalize the return through `_tagchilds_to_tagnodes`, which
+                # uniformly handles every shape `Tagified` permits:
+                #   - `TagList`              -> flattened into this slot
+                #   - `Sequence[Tagified]`   -> flattened
+                #   - `None`                 -> dropped
+                #   - `float` / `int`        -> str-ified
+                #   - tagified leaf or Tag   -> passthrough
+                # The cast widens the input to the helper (which expects
+                # `Iterable[TagChild]`); the helper's runtime branches accept
+                # the wider `Tagified` shape because `Tagified` is a subset.
+                cp[i : i + 1] = cast(
+                    "list[TagifiedNode]",
+                    _tagchilds_to_tagnodes(
+                        cast("Iterable[TagChild]", [tagified_child])
+                    ),
+                )
 
             elif isinstance(child, MetadataNode):
                 cp[i] = copy(child)
 
-        # Boundary check: after the recursion above, every child should be
-        # a fully-tagified shape (Tag, TagList, MetadataNode, ReprHtml, str,
-        # or HTML). A bare Tagifiable still present here means some child's
-        # `.tagify()` returned a TagList containing un-tagified objects —
-        # which violates the Tagifiable protocol. Surface that here, where
-        # the offending class and index are still in scope, instead of
-        # waiting for the render-time guard in `get_html_string` to raise
-        # a less-actionable error. Tag and TagList are themselves
-        # Tagifiable but are valid tagified shapes, so they are excluded.
-        for i, child in enumerate(cp):
-            if isinstance(child, Tagifiable) and not isinstance(child, (Tag, TagList)):
+        # Boundary check: every item in `cp` should now be a fully-tagified
+        # shape — `TagifiedTag` (NOT bare `Tag`), `TagifiedTagList` (NOT
+        # bare `TagList`), or a `TagNodeLeaf` (`MetadataNode`, `ReprHtml`,
+        # `str`, `HTML`). Anything `Tagifiable` that isn't one of the
+        # tagified subclasses means a child's `.tagify()` returned content
+        # that violates the `Tagified` contract — either a bare `Tag` /
+        # `TagList` (rather than `.tagify()`'d), or a `TagList` whose
+        # contents include un-tagified objects (e.g. a stray custom
+        # `Tagifiable`). Surface that here, where the offending class and
+        # index are still in scope, instead of waiting for the render-time
+        # guard in `get_html_string` to raise a less-actionable error.
+        # Cast `cp` to the wider parent type so pyright keeps the
+        # isinstance guard reachable; statically, `cp`'s items are
+        # `TagifiedNode` and pyright would flag the check as
+        # `reportUnnecessaryIsInstance`. The guard exists to catch runtime
+        # protocol violations — a misbehaving `.tagify()` can still place
+        # an un-tagified value in the list.
+        for i, child in enumerate(cast("TagList[TagNode]", cp)):
+            if isinstance(child, Tagifiable) and not isinstance(
+                child, (TagifiedTag, TagifiedTagList)
+            ):
                 raise TypeError(
                     "Expected a fully tagified value, but a child .tagify() "
-                    "returned a TagList containing an un-tagified "
-                    f"{type(child).__name__} at index {i}. "
-                    "A .tagify() implementation must recursively tagify its "
-                    "return value (consider returning `something.tagify()` "
+                    f"returned an un-tagified {type(child).__name__} at index "
+                    f"{i}. A .tagify() implementation must return a fully-"
+                    "tagified value (consider returning `something.tagify()` "
                     "instead of `something`)."
                 )
 
@@ -618,6 +654,71 @@ def _repr_html_(self) -> str:
         return str(self)
 
 
+# =============================================================================
+# TagifiedTagList class
+# =============================================================================
+class TagifiedTagList(TagList["TagifiedNode"]):
+    """
+    A `TagList` whose items are all fully tagified.
+
+    Returned by `TagList.tagify()` and by `.tagify()` implementations that
+    produce a list of tagified nodes. Mutators are narrowed to `Tagified`
+    so pyright rejects un-tagified inputs at the call site.
+
+    To append a non-tagified child to a `TagifiedTagList`, call `.tagify()`
+    on it first: ``tl.append(div("x").tagify())``.
+    """
+
+    # Why these overrides exist, and why they're suppressed:
+    #
+    # The parent `TagList.append/extend/insert` accept any `TagChild` —
+    # including un-tagified `Tagifiable` objects. We narrow the subclass
+    # versions to `TagifiedChild`, which excludes the un-tagified arm.
+    # That's the whole point: pyright now flags
+    # `tagified.append(SomeTagifiable())` at the call site.
+    #
+    # Narrowing what a method accepts in a subclass is technically a
+    # Liskov violation — a caller holding a `TagList` reference could
+    # legally pass an argument the subclass refuses. Pyright reports
+    # this as `reportIncompatibleMethodOverride`. We suppress because
+    # the violating scenario doesn't happen here: `TagifiedTagList`
+    # only ever comes out of `.tagify()`, not from upcasting an
+    # existing `TagList`.
+    #
+    # The Liskov-clean alternative would be to parameterize the parent's
+    # signatures: `TagList.append(item: TagChild[TagNodeT])` so a
+    # `TagList[TagifiedNode]` instance automatically narrows by type
+    # substitution — no subclass overrides needed. That was tried in #105
+    # (see the `TagChild` rationale comment) and abandoned because pyright
+    # leaks `Sequence[Unknown]` through recursive generic aliases in
+    # downstream strict mode. If that pyright limitation is ever fixed,
+    # this whole override block can come out and the LSP violation
+    # disappears.
+
+    def __init__(self, *args: TagifiedChild) -> None:
+        # cast: pass through to parent; the parent constructor accepts the
+        # wider TagChild union, of which TagifiedChild is a subset.
+        super().__init__(*cast("tuple[TagChild, ...]", args))
+
+    def append(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, item: TagifiedChild, *args: TagifiedChild
+    ) -> None:
+        super().append(
+            cast("TagChild", item),
+            *cast("tuple[TagChild, ...]", args),
+        )
+
+    def extend(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, other: Iterable[TagifiedChild]
+    ) -> None:
+        super().extend(cast("Iterable[TagChild]", other))
+
+    def insert(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, i: SupportsIndex, item: TagifiedChild
+    ) -> None:
+        super().insert(i, cast("TagChild", item))
+
+
 # =============================================================================
 # TagAttrDict class
 # =============================================================================
@@ -951,14 +1052,19 @@ def add_style(self: TagT, style: str | HTML, *, prepend: bool = False) -> TagT:
             self.attrs.update({"style": self.attrs.get("style")}, {"style": style})
         return self
 
-    def tagify(self) -> "Tag[TagifiedNode]":
+    def tagify(self) -> "TagifiedTag":
         """
         Convert any tagifiable children to Tag/TagList objects.
         """
 
-        cp = copy(self)
-        cp.children = cast("TagList[TagNodeT]", cp.children.tagify())
-        return cast("Tag[TagifiedNode]", cp)
+        # Construct a TagifiedTag directly (not a cast over copy(self)) so the
+        # runtime instance is the subclass. Mirror Tag.__copy__'s shallow-copy
+        # behavior, then overwrite .children with the tagified result.
+        cp = TagifiedTag.__new__(TagifiedTag)
+        new_dict = {key: copy(value) for key, value in self.__dict__.items()}
+        cp.__dict__.update(new_dict)
+        cp.children = self.children.tagify()
+        return cp
 
     def get_html_string(self, indent: int = 0, eol: str = "\n") -> str:
         """
@@ -1079,6 +1185,74 @@ def _repr_html_(self) -> str:
         return str(self)
 
 
+# =============================================================================
+# TagifiedTag class
+# =============================================================================
+class TagifiedTag(Tag["TagifiedNode"]):
+    """
+    A `Tag` whose children are all fully tagified.
+
+    Returned by `Tag.tagify()`. Mutators are narrowed to `Tagified` so
+    pyright rejects un-tagified inputs at the call site. To append a
+    non-tagified child, call `.tagify()` on it first.
+    """
+
+    # Why these overrides exist, and why they're suppressed:
+    #
+    # The parent `Tag.append/extend/insert` accept any `TagChild` —
+    # including un-tagified `Tagifiable` objects. We narrow the subclass
+    # versions to `TagifiedChild`, which excludes the un-tagified arm.
+    # That's the whole point: pyright now flags
+    # `tagified.append(SomeTagifiable())` at the call site.
+    #
+    # Narrowing what a method accepts in a subclass is technically a
+    # Liskov violation — a caller holding a `Tag` reference could
+    # legally pass an argument the subclass refuses. Pyright reports
+    # this as `reportIncompatibleMethodOverride`. We suppress because
+    # the violating scenario doesn't happen here: `TagifiedTag` only
+    # ever comes out of `.tagify()`, not from upcasting an existing
+    # `Tag`.
+    #
+    # The Liskov-clean alternative would be to parameterize the parent's
+    # signatures: `Tag.append(item: TagChild[TagNodeT])` so a
+    # `Tag[TagifiedNode]` instance automatically narrows by type
+    # substitution — no subclass overrides needed. That was tried in #105
+    # (see the `TagChild` rationale comment) and abandoned because pyright
+    # leaks `Sequence[Unknown]` through recursive generic aliases in
+    # downstream strict mode. If that pyright limitation is ever fixed,
+    # this whole override block can come out and the LSP violation
+    # disappears.
+
+    def __init__(
+        self,
+        _name: str,
+        *args: TagifiedChild | TagAttrs,
+        _add_ws: TagAttrValue = True,
+        **kwargs: TagAttrValue,
+    ) -> None:
+        super().__init__(
+            _name,
+            *cast("tuple[TagChild | TagAttrs, ...]", args),
+            _add_ws=_add_ws,
+            **kwargs,
+        )
+
+    def append(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, *args: TagifiedChild
+    ) -> None:
+        super().append(*cast("tuple[TagChild, ...]", args))
+
+    def extend(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, x: Iterable[TagifiedChild]
+    ) -> None:
+        super().extend(cast("Iterable[TagChild]", x))
+
+    def insert(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, index: SupportsIndex, x: TagifiedChild
+    ) -> None:
+        super().insert(index, cast("TagChild", x))
+
+
 # Tags that have the form <tagname />
 _VOID_TAG_NAMES = {
     "area",
@@ -2102,7 +2276,12 @@ def _normalize_text(txt: str | HTML) -> str:
 
 
 def _equals_impl(x: Any, y: Any) -> bool:
-    if not isinstance(y, type(x)):
+    # Symmetric class check: accept if either argument is an instance of
+    # the other's class. This handles the TagifiedTag / Tag (and
+    # TagifiedTagList / TagList) cases introduced by #116 — the subclass
+    # adds no instance attributes, so a tagified value with matching
+    # __dict__ is structurally equal to its un-tagified counterpart.
+    if not (isinstance(y, type(x)) or isinstance(x, type(y))):
         return False
     for key in x.__dict__.keys():
         if getattr(x, key, None) != getattr(y, key, None):
diff --git a/htmltools/_jsx.py b/htmltools/_jsx.py
index 9365070..5b09404 100644
--- a/htmltools/_jsx.py
+++ b/htmltools/_jsx.py
@@ -19,7 +19,7 @@
     Tag,
     TagAttrValue,
     Tagifiable,
-    TagifiedNode,
+    TagifiedTag,
     TagList,
     TagNode,
 )
@@ -111,7 +111,7 @@ def extend(self, x: Iterable[TagNode]) -> None:
     def append(self, *args: TagNode) -> None:
         self.children.append(*args)
 
-    def tagify(self) -> "Tag[TagifiedNode]":
+    def tagify(self) -> "TagifiedTag":
         metadata_nodes: list[MetadataNode] = []
 
         # This function is recursively applied to the attributes and children. It does
@@ -164,21 +164,19 @@ def tagify_tagifiable_and_get_metadata(x: Any) -> Any:
             ]
         )
 
-        return cast(
-            "Tag[TagifiedNode]",
-            Tag(
-                "script",
-                {
-                    "type": "text/javascript",
-                    "data_needs_render": True,
-                },
-                HTML("\n" + js + "\n"),
-                _lib_dependency("react", script={"src": "react.production.min.js"}),
-                _lib_dependency(
-                    "react-dom", script={"src": "react-dom.production.min.js"}
-                ),
-                *metadata_nodes,
-            ),
+        # The children passed in (HTML, script-attr dict, lib-dependency
+        # metadata nodes) are all already TagifiedNode-shaped, so the
+        # constructor produces a legitimate tagified tag.
+        return TagifiedTag(
+            "script",
+            {
+                "type": "text/javascript",
+                "data_needs_render": True,
+            },
+            HTML("\n" + js + "\n"),
+            _lib_dependency("react", script={"src": "react.production.min.js"}),
+            _lib_dependency("react-dom", script={"src": "react-dom.production.min.js"}),
+            *metadata_nodes,
         )
 
     def __str__(self) -> str:
diff --git a/tests/test_html_document.py b/tests/test_html_document.py
index 4c3da57..a45896f 100644
--- a/tests/test_html_document.py
+++ b/tests/test_html_document.py
@@ -192,7 +192,10 @@ class DelayedDep:
         )
 
         def tagify(self):
-            return div("delayed dependency", self.dep)
+            # Must return a fully-tagified value (TagifiedTag), not a bare
+            # Tag. Calling `.tagify()` on `div(...)` produces the required
+            # subclass — see #116's tightened post-tagify boundary check.
+            return div("delayed dependency", self.dep).tagify()
 
     x = TagList(div("Hello", DelayedDep()), "world")
 
diff --git a/tests/test_tagified_subclasses.py b/tests/test_tagified_subclasses.py
new file mode 100644
index 0000000..466d3c6
--- /dev/null
+++ b/tests/test_tagified_subclasses.py
@@ -0,0 +1,47 @@
+"""Runtime isinstance tests for the TagifiedTagList / TagifiedTag subclasses."""
+
+from htmltools import Tag, TagList, div
+from htmltools._core import TagifiedTag, TagifiedTagList
+
+
+def test_TagifiedTagList_is_a_class() -> None:
+    # Was a TypeAliasType before #116; isinstance would raise TypeError.
+    # After: a real class.
+    assert isinstance(TagifiedTagList(), TagifiedTagList)
+    assert isinstance(TagifiedTagList(), TagList)
+
+
+def test_TagifiedTag_is_a_class() -> None:
+    assert isinstance(TagifiedTag("div"), TagifiedTag)
+    assert isinstance(TagifiedTag("div"), Tag)
+
+
+def test_TagList_tagify_returns_TagifiedTagList_instance() -> None:
+    result = TagList("hi", div()).tagify()
+    assert isinstance(result, TagifiedTagList)
+    # Verify it's the actual class, not the base TagList
+    assert type(result) is TagifiedTagList
+
+
+def test_Tag_tagify_returns_TagifiedTag_instance() -> None:
+    result = div("hi").tagify()
+    assert isinstance(result, TagifiedTag)
+    assert type(result) is TagifiedTag
+
+
+def test_TagifiedTagList_children_are_TagifiedTag() -> None:
+    # Recursive guarantee: nested children inside a tagified result are also
+    # TagifiedTag instances, not bare Tag.
+    result = TagList(div(div("inner"))).tagify()
+    inner = result[0]
+    assert isinstance(inner, TagifiedTag)
+    assert isinstance(inner.children[0], TagifiedTag)
+
+
+def test_JSXTag_tagify_returns_TagifiedTag() -> None:
+    # Import locally because JSXTag is not in the top-level htmltools namespace.
+    from htmltools._jsx import JSXTag
+
+    jsx = JSXTag("MyComponent")
+    result = jsx.tagify()
+    assert isinstance(result, TagifiedTag)
diff --git a/tests/test_tagify.py b/tests/test_tagify.py
index eb9e637..14b4595 100644
--- a/tests/test_tagify.py
+++ b/tests/test_tagify.py
@@ -1,6 +1,6 @@
 import pytest
 
-from htmltools import TagList, div, span
+from htmltools import Tagified, TagList, div, span
 
 
 class _ReturnsTagifiable:
@@ -46,3 +46,108 @@ def test_render_guard_catches_mutation_after_tagify() -> None:
     tagified.children.append(_NestedTagifiable())
     with pytest.raises(RuntimeError, match="_NestedTagifiable"):
         tagified.get_html_string()
+
+
+# -----------------------------------------------------------------------------
+# Boundary normalization of child.tagify() returns (closes #117)
+# -----------------------------------------------------------------------------
+# The `Tagified` union now permits `None`, `float`, and `Sequence[Tagified]`
+# returns from `.tagify()` (parallel to `TagChild` on the input side). The
+# `TagList.tagify()` boundary routes every return through
+# `_tagchilds_to_tagnodes`, which normalizes those shapes uniformly: drop
+# `None`, str-ify `float`/`int`, flatten `Sequence`.
+
+
+class _ReturnsNone:
+    def tagify(self) -> Tagified:
+        return None
+
+
+class _ReturnsFloat:
+    def tagify(self) -> Tagified:
+        return 3.14
+
+
+class _ReturnsList:
+    def tagify(self) -> Tagified:
+        return ["a", "b"]
+
+
+def test_tagify_returning_None_drops_the_slot() -> None:
+    tl = TagList(_ReturnsNone(), "after").tagify()
+    assert list(tl) == ["after"]
+    # Render must not crash.
+    assert tl.get_html_string() == "after"
+
+
+def test_tagify_returning_float_is_strified() -> None:
+    tl = TagList(_ReturnsFloat(), "after").tagify()
+    assert list(tl) == ["3.14", "after"]
+    assert "3.14" in tl.get_html_string()
+
+
+def test_tagify_returning_Sequence_flattens() -> None:
+    tl = TagList(_ReturnsList(), "after").tagify()
+    assert list(tl) == ["a", "b", "after"]
+    # Render: sibling text nodes concatenate without separators.
+    assert tl.get_html_string() == "abafter"
+
+
+# -----------------------------------------------------------------------------
+# Strict post-tagify boundary: bare `Tag` / `TagList` returns are rejected.
+# -----------------------------------------------------------------------------
+# `Tagified` permits `TagifiedTag` (not bare `Tag`) and `TagifiedTagList`
+# (not bare `TagList`). A `.tagify()` that returns `div(some_tagifiable)`
+# without calling `.tagify()` on the result will leave un-tagified content
+# in the tree — the bare-Tag shape passes runtime `isinstance(_, Tag)`
+# checks but fails the `Tagified` contract. The boundary catches this
+# before render time, where the error message would otherwise be the
+# misleading "tree was mutated to add a Tagifiable object after
+# .tagify() was called."
+
+
+class _ReturnsBareTagWithTagifiableChild:
+    """Wraps a Tagifiable in a bare div() — does NOT call .tagify() on result."""
+
+    def tagify(
+        self,
+    ):  # intentionally unannotated; pyright would catch the contract violation
+        return div(_NestedTagifiable())
+
+
+class _ReturnsBareTagWithLeafChild:
+    """Even a bare Tag whose contents are leaves violates the contract."""
+
+    def tagify(self):
+        return div("leaf")
+
+
+def test_taglist_tagify_raises_on_bare_Tag_return_with_tagifiable_child() -> None:
+    # Direct reproducer of the bug Copilot flagged on PR #118: a bare Tag
+    # carrying an un-tagified child slipped past the boundary and only
+    # failed at render time with a misleading "tree was mutated" error.
+    tl = TagList(_ReturnsBareTagWithTagifiableChild())
+    with pytest.raises(TypeError, match=r"Tag at index"):
+        tl.tagify()
+
+
+def test_taglist_tagify_raises_on_bare_Tag_return_with_leaf_child() -> None:
+    # Even when the bare Tag's children are leaves, the strict boundary
+    # raises — matching the static `Tagified` contract (which excludes bare
+    # `Tag`). Easy fix at the call site: append `.tagify()` to the return.
+    tl = TagList(_ReturnsBareTagWithLeafChild())
+    with pytest.raises(TypeError, match=r"Tag at index"):
+        tl.tagify()
+
+
+def test_taglist_tagify_accepts_self_tagified_Tag_return() -> None:
+    # The recommended fix: call `.tagify()` on the wrapping Tag before returning.
+    class _ReturnsTagifiedTag:
+        def tagify(self):
+            return div(_NestedTagifiable()).tagify()
+
+    tl = TagList(_ReturnsTagifiedTag()).tagify()
+    html = tl.get_html_string()
+    assert "<div>" in html
+    assert "bar" in html
+    assert "</div>" in html
diff --git a/tests/test_types.py b/tests/test_types.py
index b13e82e..82d120e 100644
--- a/tests/test_types.py
+++ b/tests/test_types.py
@@ -1,3 +1,4 @@
+# pyright: reportUnnecessaryTypeIgnoreComment=error, reportIncompatibleMethodOverride=error
 """
 Static-type assertions for the tagified type contract.
 
@@ -6,11 +7,17 @@
 but produce type errors if the inferred types are wrong.
 
 Lines marked `# pyright: ignore[<rule>]` are *intentional* — they assert that
-pyright would refuse the indicated assignment.
+pyright would refuse the indicated assignment. The file-level
+`reportUnnecessaryTypeIgnoreComment=error` setting above makes the assertions
+self-checking: if pyright ever stops flagging a rule we expect, the now-
+unused `# pyright: ignore` fails CI, signaling the typing landscape has
+shifted and the suppression in `htmltools._core` may be removable.
 """
 
 from __future__ import annotations
 
+from collections.abc import Iterable
+
 from typing_extensions import assert_type
 
 from htmltools import (
@@ -18,19 +25,59 @@
     Tagifiable,
     Tagified,
     TagList,
+    TagNode,
     div,
 )
-from htmltools._core import TagifiedNode, TagifiedTagList
+from htmltools._core import (
+    TagChild,
+    TagifiedChild,
+    TagifiedNode,  # noqa: F401 — used in `class _LSPNarrowingCanary(TagList["TagifiedNode"])`'s string-quoted base
+    TagifiedTag,
+    TagifiedTagList,
+)
 
 
-def test_tag_tagify_returns_Tag_TagifiedNode() -> None:
-    assert_type(div("hi").tagify(), Tag[TagifiedNode])
+def test_tag_tagify_returns_TagifiedTag() -> None:
+    assert_type(div("hi").tagify(), TagifiedTag)
 
 
 def test_taglist_tagify_returns_TagifiedTagList() -> None:
     assert_type(TagList("hi").tagify(), TagifiedTagList)
 
 
+def test_TagifiedTagList_append_rejects_Tagifiable_statically() -> None:
+    """Mutators on TagifiedTagList narrow input to Tagified; appending
+    a Tagifiable must be a pyright error."""
+
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tl: TagifiedTagList = TagList("hi").tagify()
+    # Acceptable: a tagified node
+    tl.append("ok")
+    # Static error: bare Tagifiable is not in Tagified.
+    tl.append(_SomeTagifiable())  # pyright: ignore[reportArgumentType]
+
+
+def test_TagifiedTagList_extend_rejects_Tagifiable_statically() -> None:
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tl: TagifiedTagList = TagList("hi").tagify()
+    tl.extend([_SomeTagifiable()])  # pyright: ignore[reportArgumentType]
+
+
+def test_TagifiedTagList_insert_rejects_Tagifiable_statically() -> None:
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tl: TagifiedTagList = TagList("hi").tagify()
+    tl.insert(0, _SomeTagifiable())  # pyright: ignore[reportArgumentType]
+
+
 def test_bare_TagList_is_not_assignable_to_TagifiedTagList() -> None:
     tl: TagList = TagList("hi")
     # A bare TagList means TagList[TagNode], which may still contain Tagifiables.
@@ -38,51 +85,21 @@ def test_bare_TagList_is_not_assignable_to_TagifiedTagList() -> None:
     _: TagifiedTagList = tl  # pyright: ignore[reportAssignmentType]
 
 
-def test_TagifiedTagList_append_accepts_Tagifiable() -> None:
+def test_TagifiedTagList_append_rejects_Tagifiable() -> None:
     """
-    Documents a deliberate static-typing gap: appending a ``Tagifiable``
-    to a ``TagList[TagifiedNode]`` is **not** a static error today, even
-    though ``TagifiedNode`` does not include the ``Tagifiable`` arm of
-    ``TagNode``. The runtime catches it instead.
-
-    Why we can't enforce it statically
-    ----------------------------------
-    The natural enforcement would parameterize ``TagChild`` itself —
-    ``TagChild[TagNodeT] = TagNodeT | TagList[TagNodeT] | float | None |
-    Sequence[TagChild[TagNodeT]]`` — and use it in mutation signatures so
-    that ``TagList[TagifiedNode].append`` only accepts ``TagifiedNode``
-    -shaped values. We tried that. Pyright (tested through 1.1.409)
-    does not fully re-bind ``TagNodeT`` through the recursive
-    ``Sequence["TagChild[TagNodeT]"]`` arm when a *downstream* module
-    imports the symbols in strict mode. Every ``Tag``-function signature
-    then leaks a ``Sequence[Unknown]`` arm, which surfaced as thousands
-    of ``reportUnknownMemberType`` errors in Shiny's CI — far more noise
-    than the win was worth.
-
-    What we do instead
-    ------------------
-    - ``TagChild`` is a plain non-generic ``Union`` (including the
-      recursive ``Sequence["TagChild"]`` arm for nested-list flattening).
-    - Mutation methods on ``TagList[TagNodeT]`` and ``Tag[TagNodeT]`` accept
-      bare ``TagChild`` (wide). This preserves the nested-list
-      ergonomics like ``tl.append([a, b, [c, d]])``.
-    - The "no un-tagified children in a tagified tree" invariant is
-      enforced at runtime:
-        * ``TagList.tagify()`` raises ``TypeError`` at the boundary
-          when a child's ``.tagify()`` returns a ``TagList`` containing
-          a ``Tagifiable``, naming the offending class and slot index.
-        * ``TagList.get_html_string`` raises ``RuntimeError`` at render
-          time if a ``Tagifiable`` is still in the tree (covers
-          mutation-after-tagify; see
-          ``test_tagify.py::test_render_guard_catches_mutation_after_tagify``).
-
-    When to revisit
-    ---------------
-    If a future pyright/typing release handles recursive generic
-    ``TypeAliasType`` cleanly across module boundaries, flip this test
-    to a *negative* form (``# pyright: ignore[reportArgumentType]`` on
-    the ``tl.append(...)`` call) and reinstate ``TagChild[TagNodeT]`` on
-    ``TagList`` / ``Tag`` mutation-method signatures.
+    Appending a ``Tagifiable`` to a ``TagifiedTagList`` is a *static* error.
+
+    Enforced by ``TagifiedTagList.append``'s narrow signature, which accepts
+    only ``Tagified`` (a non-generic union that excludes the
+    ``Tagifiable`` arm of ``TagNode``). The previous design — a recursive
+    generic ``TagChild[TagNodeT]`` — was abandoned in #105 because it
+    leaked ``Sequence[Unknown]`` through downstream pyright in strict mode;
+    the subclass-with-narrow-overrides approach (#116) closes the gap
+    without parameterizing ``TagChild``.
+
+    The runtime guards in ``TagList.tagify`` (boundary ``TypeError``) and
+    ``get_html_string`` (render-time ``RuntimeError``) remain the safety
+    net for code that uses ``# pyright: ignore`` to bypass the static check.
     """
 
     class _SomeTagifiable:
@@ -90,9 +107,35 @@ def tagify(self) -> Tagified:
             return "x"
 
     tl: TagifiedTagList = TagList("hi").tagify()
-    # This currently type-checks. In an ideal world it would static-error;
-    # see the docstring for why we accept the gap.
-    tl.append(_SomeTagifiable())
+    tl.append(_SomeTagifiable())  # pyright: ignore[reportArgumentType]
+
+
+def test_TagifiedTag_append_rejects_Tagifiable_statically() -> None:
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tag: TagifiedTag = div("hi").tagify()
+    tag.append("ok")
+    tag.append(_SomeTagifiable())  # pyright: ignore[reportArgumentType]
+
+
+def test_TagifiedTag_extend_rejects_Tagifiable_statically() -> None:
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tag: TagifiedTag = div("hi").tagify()
+    tag.extend([_SomeTagifiable()])  # pyright: ignore[reportArgumentType]
+
+
+def test_TagifiedTag_insert_rejects_Tagifiable_statically() -> None:
+    class _SomeTagifiable:
+        def tagify(self) -> Tagified:
+            return "x"
+
+    tag: TagifiedTag = div("hi").tagify()
+    tag.insert(0, _SomeTagifiable())  # pyright: ignore[reportArgumentType]
 
 
 def test_bare_TagList_append_accepts_Tagifiable() -> None:
@@ -106,15 +149,22 @@ def tagify(self) -> Tagified:
     tl.append(_OkTagifiable())
 
 
-def test_user_tagify_returning_bare_TagList_violates_Tagifiable() -> None:
+def test_user_tagify_returning_bare_TagList_is_structurally_Tagifiable() -> None:
+    # Returning a bare `TagList` (instead of `TagifiedTagList`) from
+    # `.tagify()` is a contract violation — `Tagified` excludes bare
+    # `TagList` and `TagList` may carry un-tagified content. The
+    # runtime boundary in `TagList.tagify()` raises a clear `TypeError`
+    # when this happens. **Pyright does not currently catch the
+    # violation at the protocol assignment site** — `TagList` is a
+    # `Sequence`-like, and `Tagified`'s widened shape (which now
+    # includes `Sequence[Tagified]`) makes pyright accept the
+    # structural match. Documenting the observed leniency here; the
+    # runtime guard is the load-bearing check.
     class _Bad:
-        # Bare TagList annotation means TagList[TagNode], which is wider than
-        # TagifiedTagList. So this class is NOT structurally a Tagifiable
-        # under the new (tightened) protocol.
         def tagify(self) -> TagList:
             return TagList("x")
 
-    _: Tagifiable = _Bad()  # pyright: ignore[reportAssignmentType]
+    _: Tagifiable = _Bad()
 
 
 def test_user_tagify_returning_TagifiedTagList_is_Tagifiable() -> None:
@@ -123,3 +173,106 @@ def tagify(self) -> TagifiedTagList:
             return TagList("x").tagify()
 
     _: Tagifiable = _Good()
+
+
+def test_TagifiedTagList_to_bare_TagList_is_accepted() -> None:
+    """Documents pyright's observed permissive behavior on TagifiedTagList flows.
+
+    ``TagList`` is invariant in ``TagNodeT`` per its ``TypeVar`` declaration,
+    so ``TagList[TagifiedNode]`` is *technically* not assignable to
+    ``TagList[TagNode]``. In practice, pyright (verified through 1.1.409)
+    treats a nominal subclass ``TagifiedTagList(TagList["TagifiedNode"])`` as
+    assignable to bare ``TagList`` and to explicit ``TagList[TagNode]``,
+    likely because the ``TagNodeT`` default and the class-hierarchy lookup
+    take precedence over the parameterized-instance invariance check.
+
+    This is the answer to the "open question" in #116 — the previous
+    TypeAliasType alias appeared to "silently relax" variance, but the
+    subclass form has the same practical behavior. Downstream consumers
+    using ``def f(t: TagList): ...`` (or even ``TagList[TagNode]``) do NOT
+    need migration to accept tagified inputs.
+
+    If pyright ever starts flagging these flows, this fixture will fail —
+    that's the signal to add a real migration note and update downstream
+    packages.
+    """
+
+    def f_bare_taglist(t: TagList) -> str:
+        return t.get_html_string()
+
+    def f_explicit_taglist(t: TagList[TagNode]) -> str:
+        return t.get_html_string()
+
+    tagified: TagifiedTagList = TagList("hi").tagify()
+    # All three of these are accepted by pyright. No `# pyright: ignore`
+    # is needed (and adding one would be flagged as unnecessary if
+    # `reportUnnecessaryTypeIgnoreComment` is enabled).
+    f_bare_taglist(tagified)
+    f_explicit_taglist(tagified)
+    _: TagList[TagNode] = tagified
+
+
+def test_TagifiedTag_to_bare_Tag_is_accepted() -> None:
+    """Symmetric to ``test_TagifiedTagList_to_bare_TagList_is_accepted``."""
+
+    def f_bare_tag(t: Tag) -> str:
+        return t.get_html_string()
+
+    def f_explicit_tag(t: Tag[TagNode]) -> str:
+        return t.get_html_string()
+
+    tagified: TagifiedTag = div("hi").tagify()
+    f_bare_tag(tagified)
+    f_explicit_tag(tagified)
+    _: Tag[TagNode] = tagified
+
+
+## ----------------------------------------------------------------------------
+## Canary for the Liskov-violation suppression in `htmltools._core`.
+## ----------------------------------------------------------------------------
+## `TagifiedTagList` / `TagifiedTag` narrow their mutators' input from `TagChild`
+## to `TagifiedChild` — pyright flags each override with
+## `reportIncompatibleMethodOverride` because narrowing input is contravariantly
+## LSP-unsafe. We suppress those in `_core.py` because the violating scenario
+## doesn't occur in this codebase.
+##
+## The class below replicates the override pattern at module scope (pyright
+## checks `reportIncompatibleMethodOverride` differently for nested classes —
+## verified empirically) and carries the same suppression. The file-level
+## `reportUnnecessaryTypeIgnoreComment=error` setting means: if pyright ever
+## stops flagging input-narrowing this way (because the typing community
+## settles on a different rule, or pyright's handling of recursive generics
+## improves enough that the `TagChild[TagNodeT]` parameterized-parent approach
+## from #105 becomes viable), the `# pyright: ignore` lines below become
+## unnecessary and CI fails. That's the signal to revisit the suppression in
+## `_core.py` and the rationale comments next to it.
+class _LSPNarrowingCanary(TagList["TagifiedNode"]):
+    def append(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, item: TagifiedChild, *args: TagifiedChild
+    ) -> None:
+        from typing import cast
+
+        super().append(
+            cast("TagChild", item),
+            *cast("tuple[TagChild, ...]", args),
+        )
+
+    def extend(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, other: Iterable[TagifiedChild]
+    ) -> None:
+        from typing import cast
+
+        super().extend(cast("Iterable[TagChild]", other))
+
+
+def test_LSP_narrowing_override_canary_exists() -> None:
+    """Runtime smoke that the canary class is importable / instantiable.
+
+    The static-type assertion is the file-level
+    `reportUnnecessaryTypeIgnoreComment=error` plus the `# pyright: ignore`
+    lines on `_LSPNarrowingCanary` above — this runtime body just exists so
+    pytest exercises the class.
+    """
+    canary = _LSPNarrowingCanary()
+    canary.append("ok")
+    assert list(canary) == ["ok"]