diff --git a/changelog.txt b/changelog.txt
--- a/changelog.txt
+++ b/changelog.txt
@@ -21,3 +21,13 @@
 
 v0.2.1.0 - Add:
     MetaItem, MetaValue, metaMap, metaList
+
+v0.3.0.0
+    - Removes the 'Tagged' data family.
+        - Tagged PlainBlock -> TaggedPlainBlock
+        - Tagged Lines -> TaggedLines
+        - Tagged Blocks -> TaggedBlocks
+    - "ProAbstract.Types" no longer re-exports:
+            Map, Seq, Set, and Text
+      Import them directly from the 'containers'
+      and 'text' packages instead.
diff --git a/library/pro-abstract/ProAbstract.hs b/library/pro-abstract/ProAbstract.hs
--- a/library/pro-abstract/ProAbstract.hs
+++ b/library/pro-abstract/ProAbstract.hs
@@ -13,24 +13,20 @@
 
 === Tagged nodes
 
-/Tagged/ nodes are branch points within a document.
-
 - 'Tag' = ('name' : 'Text') × ('metadata' : 'Metadata') × ('annotation' : 'Annotation')
 
-- 'Tagged' x = ('tag' : 'Tag') × ('content' : x)
-
-'Tagged' is a data family, where the type parameter corresponds to the type of content under the tag. There are three instances of this family:
+/Tagged/ nodes are branch points within a document.
 
-- 'Tagged' 'Blocks'
-- 'Tagged' 'PlainBlock'
-- 'Tagged' 'Lines'
+- 'TaggedBlocks'     = ('tag' : 'Tag') × ('content' : 'Blocks')
+- 'TaggedPlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')
+- 'TaggedLines'      = ('tag' : 'Tag') × ('content' : 'Lines')
 
 Optics:
 
 - 'tag' targets the tag at a node; it is either a lens or an affine traversal, depending on the node type.
 - The 'allTags' traversal targets every tag at and below a node.
 - The 'allBlockTags' and 'allInlineTags' also target tags at or below a node, but are limited to tags at the block or inline level, respectively.
-- Since a tag has metadata, all of the optics for targeting parts of metadata (e.g. 'atSetting' and 'hasProperty') are also available on 'Tag' and on 'Tagged' nodes.
+- Since a tag has metadata, all of the optics for targeting parts of metadata (e.g. 'atSetting' and 'hasProperty') are also available on 'Tag' and on @Tagged...@ nodes.
 
 Operations for altering tags and/or removing tagged nodes in bulk:
 
@@ -44,17 +40,17 @@
 
 /Block-level/ content is everything that appears below the document level and above the paragraph level.
 
-- 'Block' = ('fork' : 'Tagged' 'Blocks') ∪ ('plain' : 'Tagged' 'PlainBlock') ∪ ('bare' : 'Paragraph')
+- 'Block' = ('fork' : 'TaggedBlocks') ∪ ('plain' : 'TaggedPlainBlock') ∪ ('bare' : 'Paragraph')
 
 There are three kinds of block:
 
 - /Fork/ blocks contain more blocks.
 
-    * 'Tagged' 'Blocks' = ('tag' : 'Tag') × ('contents' : 'Block')
+    * 'TaggedBlocks' = ('tag' : 'Tag') × ('contents' : 'Block')
 
 - /Plain/ blocks contain text.
 
-    * 'Tagged' 'PlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')
+    * 'TaggedPlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')
     * 'PlainBlock' = ('contents' : 'Fragment') × ('annotation' : 'Annotation')
 
 - /Bare/ blocks (paragraphs) contain inline content.
@@ -68,7 +64,7 @@
 
 A /BlockTag/ is a non-paragraph Block.
 
-- 'BlockTag' = ('fork' : 'Tagged' 'Blocks') ∪ ('plain' : 'Tagged' 'PlainBlock')
+- 'BlockTag' = ('fork' : 'TaggedBlocks') ∪ ('plain' : 'TaggedPlainBlock')
 
 The Block type can be described in terms of BlockTag as:
 
@@ -88,13 +84,13 @@
 
 Inline content is grouped into lines; we specify no particular semantics of line breaks but suggest that a typical consumer of 'Lines' will fold them together with a single space character interspersed between the lines.
 
-- 'Inline' = ('fork' or 'tagged' : 'Tagged' 'Lines') ∪ ('plain' or 'bare' : 'Fragment')
+- 'Inline' = ('fork' or 'tagged' : 'TaggedLines') ∪ ('plain' or 'bare' : 'Fragment')
 
 There are two kinds of inline:
 
 - /Fork/ or /tag/ inlines contain more inlines.
 
-    * 'Tagged' 'Lines' = ('tag' : 'Tag') × ('content' : 'Lines')
+    * 'TaggedLines' = ('tag' : 'Tag') × ('content' : 'Lines')
     * 'Lines' = ('contents' : 'Line')
     * 'Line' = ('content' : 'Seq' 'Inline') × ('annotation' : 'Annotation')
 
@@ -142,20 +138,24 @@
 +-----------------------+-----------------------+-----------------------+
 | 'Document'            | 'Blocks'              | 'Block'               |
 +-----------------------+-----------------------+-----------------------+
+| 'TaggedBlocks'        | 'Blocks'              | 'Block'               |
++-----------------------+-----------------------+-----------------------+
 | 'Blocks'              | —                     | 'Block'               |
 +-----------------------+-----------------------+-----------------------+
 | 'BlockTag'            | 'BlockTagContent'     | —                     |
 +-----------------------+-----------------------+-----------------------+
+| 'TaggedPlainBlock'    | 'PlainBlock'          | 'Fragment'            |
++-----------------------+-----------------------+-----------------------+
+| 'PlainBlock'          | —                     | 'Fragment'            |
++-----------------------+-----------------------+-----------------------+
 | 'Paragraph'           | 'Lines'               | 'Line'                |
 +-----------------------+-----------------------+-----------------------+
+| 'TaggedLines'         | 'Lines'               | 'Line'                |
++-----------------------+-----------------------+-----------------------+
 | 'Lines'               | —                     | 'Line'                |
 +-----------------------+-----------------------+-----------------------+
 | 'Line'                | —                     | 'Inline'              |
 +-----------------------+-----------------------+-----------------------+
-| 'PlainBlock'          | —                     | 'Fragment'            |
-+-----------------------+-----------------------+-----------------------+
-| 'Tagged' y            | y                     | 'Contents' y          |
-+-----------------------+-----------------------+-----------------------+
 | 'Fragment'            | 'Text'                | —                     |
 +-----------------------+-----------------------+-----------------------+
 
@@ -175,7 +175,7 @@
 +-----------------------+-----------------------+-----------------------+
 | 'Block'               | 'BlockTag'            | 'Paragraph'           |
 +-----------------------+-----------------------+-----------------------+
-| 'Inline'              | 'Tagged' 'Lines'      | 'Fragment'            |
+| 'Inline'              | 'TaggedLines'         | 'Fragment'            |
 +-----------------------+-----------------------+-----------------------+
 
 
@@ -189,13 +189,17 @@
 
 List of nodes and their fork/plain types:
 
-+-----------------------+-----------------------+-----------------------+
-| __x__                 | __Fork x__            | __Plain x__           |
-+-----------------------+-----------------------+-----------------------+
-| 'Block'               | 'Tagged' 'Blocks'     | 'Tagged' 'PlainBlock' |
-+-----------------------+-----------------------+-----------------------+
-| 'Inline'              | 'Tagged' 'Lines'      | 'Fragment'            |
-+-----------------------+-----------------------+-----------------------+
++-----------------------+--------------------+-----------------------+
+| __x__                 | __Fork x__         | __Plain x__           |
++-----------------------+--------------------+-----------------------+
+| 'Block'               | 'TaggedBlocks'     | 'TaggedPlainBlock'    |
++-----------------------+--------------------+-----------------------+
+| 'BlockTag'            | 'TaggedBlocks'     | 'TaggedPlainBlock'    |
++-----------------------+--------------------+-----------------------+
+| 'BlockTagContent'     | 'Blocks'           | 'PlainBlock'          |
++-----------------------+--------------------+-----------------------+
+| 'Inline'              | 'TaggedLines'      | 'Fragment'            |
++-----------------------+--------------------+-----------------------+
 
 ('Block' also has a third prism, 'bare', which is neither fork nor plain.)
 
@@ -236,15 +240,15 @@
     (
     {- * Document -} Document (..),
 
-    {- * Blocks -} Block (..), Blocks (..),
+    {- * Blocks -} Block (..), Blocks (..), TaggedBlocks (..),
     {- ** Paragraphs -} Paragraph (..), HasManyParagraphs (..),
     {- ** Tag blocks -} BlockTag (..), BlockTagContent (..),
 
-    {- * Lines -} Inline (..), Line (..), Lines (..),
-    {- ** Plain text -} Fragment (..), PlainBlock (..),
+    {- * Lines -} Inline (..), Line (..), Lines (..), TaggedLines (..),
+    {- ** Plain text -} Fragment (..), PlainBlock (..), TaggedPlainBlock (..),
             HasManyPlainInlines (..), HasManyPlainBlocks (..),
 
-    {- * Tags -} Tag (..), Tagged (..), name, HasTag (..),
+    {- * Tags -} Tag (..), name, HasTag (..),
     {- ** Traversal -} HasManyTags (..), HasManyBlockTags (..),
     {- ** Withering -} HasWitherableTags (..),
             HasWitherableInlineTags (..), HasWitherableBlockTags (..),
diff --git a/library/pro-abstract/ProAbstract/Datatypes.hs b/library/pro-abstract/ProAbstract/Datatypes.hs
--- a/library/pro-abstract/ProAbstract/Datatypes.hs
+++ b/library/pro-abstract/ProAbstract/Datatypes.hs
@@ -10,7 +10,8 @@
     , Inline (..), Line (..), Lines (..)
 
     -- * Tags and tagged things
-    , Tag (..), Tagged (..), BlockTag (..), TaggedOrBare (..)
+    , Tag (..), BlockTag (..), TaggedBlocks (..)
+    , TaggedPlainBlock (..), TaggedLines (..), TaggedOrBare (..)
 
     -- * Paragraph
     , Paragraph (..)
diff --git a/library/pro-abstract/ProAbstract/Families.hs b/library/pro-abstract/ProAbstract/Families.hs
--- a/library/pro-abstract/ProAbstract/Families.hs
+++ b/library/pro-abstract/ProAbstract/Families.hs
@@ -3,9 +3,6 @@
     -- * Annotation
       Annotation
 
-    -- * Content plus a tag
-    , Tagged
-
     -- ** Content
     , Content, Contents
 
diff --git a/library/pro-abstract/ProAbstract/Structure.hs b/library/pro-abstract/ProAbstract/Structure.hs
--- a/library/pro-abstract/ProAbstract/Structure.hs
+++ b/library/pro-abstract/ProAbstract/Structure.hs
@@ -4,16 +4,15 @@
       Document (..)
 
     -- * Blocks
-    , Block (..), Blocks (..), BlockTag (..), BlockTagContent (..)
+    , Block (..), Blocks (..), BlockTag (..)
+    , TaggedBlocks (..), BlockTagContent (..)
+    , TaggedPlainBlock (..)
 
     -- * Paragraph
     , Paragraph (..)
 
     -- * Inlines
-    , Inline (..), Line (..), Lines (..)
-
-    -- * Tagged
-    , Tagged (..)
+    , Inline (..), Line (..), Lines (..), TaggedLines (..)
 
     -- * Text
     , PlainBlock (..), Fragment (..)
diff --git a/library/pro-abstract/ProAbstract/Structure/Block.hs b/library/pro-abstract/ProAbstract/Structure/Block.hs
--- a/library/pro-abstract/ProAbstract/Structure/Block.hs
+++ b/library/pro-abstract/ProAbstract/Structure/Block.hs
@@ -1,5 +1,5 @@
 module ProAbstract.Structure.Block
-    ( Block (..), paragraph, Blocks (..), Tagged (..)
+    ( Block (..), paragraph, Blocks (..), TaggedBlocks (..)
     ) where
 
 import ProAbstract.Annotation
@@ -20,17 +20,17 @@
 -- ⭐ Block
 
 data Block ann =
-    BlockPlain     (Tagged (PlainBlock ann)) -- ^ 'ProAbstract.plain'
-  | BlockParagraph (Paragraph ann)           -- ^ 'ProAbstract.bare'
-  | BlockFork      (Tagged (Blocks ann))     -- ^ 'ProAbstract.fork'
+    BlockPlain     (TaggedPlainBlock ann)  -- ^ 'ProAbstract.plain'
+  | BlockParagraph (Paragraph ann)         -- ^ 'ProAbstract.bare'
+  | BlockFork      (TaggedBlocks ann)      -- ^ 'ProAbstract.fork'
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
 type instance Annotation (Block ann) = ann
 
-type instance Plain (Block ann) = Tagged (PlainBlock ann)
+type instance Plain (Block ann) = TaggedPlainBlock ann
 
-type instance Fork (Block ann) = Tagged (Blocks ann)
+type instance Fork (Block ann) = TaggedBlocks ann
 
 instance HasMetadata (Block ann) where
     type MetadataOpticKind (Block ann) = An_AffineTraversal
@@ -177,9 +177,9 @@
     witherInlineTags f = traverseOf (contents % traversed) (witherInlineTags f)
 
 
--- ⭐ Tagged Blocks
+-- ⭐ TaggedBlocks
 
-data instance Tagged (Blocks ann) =
+data TaggedBlocks ann =
   TaggedBlocks
     { blocksTag :: Tag ann -- ^ 'ProAbstract.tag'
     , taggedBlocks :: Blocks ann -- ^ 'ProAbstract.content'
@@ -187,51 +187,51 @@
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
-type instance Annotation (Tagged (Blocks ann)) = ann
+type instance Annotation (TaggedBlocks ann) = ann
 
-instance HasTag (Tagged (Blocks ann)) where
-    type TagOpticKind (Tagged (Blocks ann)) = A_Lens
+instance HasTag (TaggedBlocks ann) where
+    type TagOpticKind (TaggedBlocks ann) = A_Lens
     tag = lens blocksTag \x a -> x{ blocksTag = a }
 
-type instance Content (Tagged (Blocks ann)) = Blocks ann
+type instance Content (TaggedBlocks ann) = Blocks ann
 
-type instance Contents (Tagged (Blocks ann)) = Block ann
+type instance Contents (TaggedBlocks ann) = Block ann
 
-instance HasManyAnnotations (Tagged (Blocks ann)) (Tagged (Blocks ann')) where
+instance HasManyAnnotations (TaggedBlocks ann) (TaggedBlocks ann') where
     allAnnotations = traversalVL \f (TaggedBlocks t b) -> TaggedBlocks
         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b
 
-instance HasAnnotation (Tagged (Blocks ann)) (Tagged (Blocks ann)) where
+instance HasAnnotation (TaggedBlocks ann) (TaggedBlocks ann) where
      annotation = tag % annotation
 
-instance HasContent (Tagged (Blocks ann)) (Tagged (Blocks ann)) where
+instance HasContent (TaggedBlocks ann) (TaggedBlocks ann) where
     content = lens taggedBlocks \x c -> x{ taggedBlocks = c }
 
-instance HasContents (Tagged (Blocks ann)) (Tagged (Blocks ann)) where
+instance HasContents (TaggedBlocks ann) (TaggedBlocks ann) where
     contents = content % contents
 
-instance HasMetadata (Tagged (Blocks ann)) where
-    type MetadataOpticKind (Tagged (Blocks ann)) = A_Lens
+instance HasMetadata (TaggedBlocks ann) where
+    type MetadataOpticKind (TaggedBlocks ann) = A_Lens
     metadata = tag % metadata
 
-instance HasManyPlainInlines (Tagged (Blocks ann)) where
+instance HasManyPlainInlines (TaggedBlocks ann) where
     allPlainInlines = content % allPlainInlines
 
-instance HasManyTags (Tagged (Blocks ann)) where
+instance HasManyTags (TaggedBlocks ann) where
     allTags = tag `adjoin` (content % allTags)
     allInlineTags = allParagraphs % allInlineTags
 
-instance HasManyBlockTags (Tagged (Blocks ann)) where
+instance HasManyBlockTags (TaggedBlocks ann) where
     allBlockTags = tag `adjoin` (content % allBlockTags)
 
-instance HasWitherableInlineTags (Tagged (Blocks ann)) where
+instance HasWitherableInlineTags (TaggedBlocks ann) where
     witherInlineTags f = traverseOf allParagraphs (witherInlineTags f)
 
-instance HasManyMetadata (Tagged (Blocks ann)) where
+instance HasManyMetadata (TaggedBlocks ann) where
     allMetadata = allTags % metadata
 
-instance HasManyParagraphs (Tagged (Blocks ann)) where
+instance HasManyParagraphs (TaggedBlocks ann) where
     allParagraphs = content % allParagraphs
 
-instance HasManyPlainBlocks (Tagged (Blocks ann)) where
+instance HasManyPlainBlocks (TaggedBlocks ann) where
     allPlainBlocks = content % allPlainBlocks
diff --git a/library/pro-abstract/ProAbstract/Structure/BlockTag.hs b/library/pro-abstract/ProAbstract/Structure/BlockTag.hs
--- a/library/pro-abstract/ProAbstract/Structure/BlockTag.hs
+++ b/library/pro-abstract/ProAbstract/Structure/BlockTag.hs
@@ -18,8 +18,8 @@
 import ProAbstract.Tag
 
 data BlockTag ann =
-    BlockTagFork  (Tagged (Blocks ann))     -- ^ 'ProAbstract.fork'
-  | BlockTagPlain (Tagged (PlainBlock ann)) -- ^ 'ProAbstract.plain'
+    BlockTagFork  (TaggedBlocks ann)     -- ^ 'ProAbstract.fork'
+  | BlockTagPlain (TaggedPlainBlock ann) -- ^ 'ProAbstract.plain'
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
@@ -27,9 +27,9 @@
 
 type instance Annotation (BlockTag ann) = ann
 
-type instance Plain (BlockTag ann) = Tagged (PlainBlock ann)
+type instance Plain (BlockTag ann) = TaggedPlainBlock ann
 
-type instance Fork (BlockTag ann) = Tagged (Blocks ann)
+type instance Fork (BlockTag ann) = TaggedBlocks ann
 
 instance HasContent (BlockTag ann) (BlockTag ann) where
     content = lens f g
diff --git a/library/pro-abstract/ProAbstract/Structure/HasManyPlainBlocks.hs b/library/pro-abstract/ProAbstract/Structure/HasManyPlainBlocks.hs
--- a/library/pro-abstract/ProAbstract/Structure/HasManyPlainBlocks.hs
+++ b/library/pro-abstract/ProAbstract/Structure/HasManyPlainBlocks.hs
@@ -6,4 +6,4 @@
 import ProAbstract.Structure.PlainBlock
 
 class HasManyPlainBlocks x where
-    allPlainBlocks :: Traversal' x (Tagged (PlainBlock (Annotation x)))
+    allPlainBlocks :: Traversal' x (TaggedPlainBlock (Annotation x))
diff --git a/library/pro-abstract/ProAbstract/Structure/Inline.hs b/library/pro-abstract/ProAbstract/Structure/Inline.hs
--- a/library/pro-abstract/ProAbstract/Structure/Inline.hs
+++ b/library/pro-abstract/ProAbstract/Structure/Inline.hs
@@ -1,5 +1,5 @@
 module ProAbstract.Structure.Inline
-    ( Inline (..), Line (..), Lines (..), Tagged (..)
+    ( Inline (..), Line (..), Lines (..), TaggedLines (..)
     ) where
 
 import ProAbstract.Annotation
@@ -17,14 +17,14 @@
 -- ⭐ Inline
 
 data Inline ann =
-    InlineFork (Tagged (Lines ann)) -- ^ 'ProAbstract.fork'
+    InlineFork (TaggedLines ann) -- ^ 'ProAbstract.fork'
   | InlinePlain (Fragment ann) -- ^ 'ProAbstract.plain'
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
 type instance Annotation (Inline ann) = ann
 
-type instance Fork (Inline ann) = Tagged (Lines ann)
+type instance Fork (Inline ann) = TaggedLines ann
 
 type instance Plain (Inline ann) = Fragment ann
 
@@ -166,9 +166,9 @@
     witherTags f = traverseOf (contents % traversed) (witherTags f)
 
 
--- ⭐ Tagged Lines
+-- ⭐ TaggedLines
 
-data instance Tagged (Lines ann) =
+data TaggedLines ann =
   TaggedLines
     { linesTag :: Tag ann -- ^ 'ProAbstract.tag'
     , taggedLines :: Lines ann -- ^ 'ProAbstract.content'
@@ -176,42 +176,42 @@
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
-type instance Annotation (Tagged (Lines ann)) = ann
+type instance Annotation (TaggedLines ann) = ann
 
-instance HasTag (Tagged (Lines ann)) where
-    type TagOpticKind (Tagged (Lines ann)) = A_Lens
+instance HasTag (TaggedLines ann) where
+    type TagOpticKind (TaggedLines ann) = A_Lens
     tag = lens linesTag \x a -> x{ linesTag = a }
 
-type instance Content (Tagged (Lines ann)) = Lines ann
+type instance Content (TaggedLines ann) = Lines ann
 
-type instance Contents (Tagged (Lines ann)) = Line ann
+type instance Contents (TaggedLines ann) = Line ann
 
-instance HasManyAnnotations (Tagged (Lines ann)) (Tagged (Lines ann')) where
+instance HasManyAnnotations (TaggedLines ann) (TaggedLines ann') where
     allAnnotations = traversalVL \f (TaggedLines t b) -> TaggedLines
         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b
 
-instance HasAnnotation (Tagged (Lines ann)) (Tagged (Lines ann)) where
+instance HasAnnotation (TaggedLines ann) (TaggedLines ann) where
      annotation = tag % annotation
 
-instance HasContent (Tagged (Lines ann)) (Tagged (Lines ann)) where
+instance HasContent (TaggedLines ann) (TaggedLines ann) where
     content = lens taggedLines \x c -> x{ taggedLines = c }
 
-instance HasContents (Tagged (Lines ann)) (Tagged (Lines ann)) where
+instance HasContents (TaggedLines ann) (TaggedLines ann) where
     contents = content % contents
 
-instance HasMetadata (Tagged (Lines ann)) where
-    type MetadataOpticKind (Tagged (Lines ann)) = A_Lens
+instance HasMetadata (TaggedLines ann) where
+    type MetadataOpticKind (TaggedLines ann) = A_Lens
     metadata = tag % metadata
 
-instance HasManyPlainInlines (Tagged (Lines ann)) where
+instance HasManyPlainInlines (TaggedLines ann) where
     allPlainInlines = content % allPlainInlines
 
-instance HasManyTags (Tagged (Lines ann)) where
+instance HasManyTags (TaggedLines ann) where
     allTags = tag `adjoin` (content % allTags)
     allInlineTags = allTags
 
-instance HasWitherableInlineTags (Tagged (Lines ann)) where
+instance HasWitherableInlineTags (TaggedLines ann) where
     witherInlineTags f = traverseOf content (witherInlineTags f)
 
-instance HasManyMetadata (Tagged (Lines ann)) where
+instance HasManyMetadata (TaggedLines ann) where
    allMetadata = allTags % metadata
diff --git a/library/pro-abstract/ProAbstract/Structure/IsTaggedOrBare.hs b/library/pro-abstract/ProAbstract/Structure/IsTaggedOrBare.hs
--- a/library/pro-abstract/ProAbstract/Structure/IsTaggedOrBare.hs
+++ b/library/pro-abstract/ProAbstract/Structure/IsTaggedOrBare.hs
@@ -49,7 +49,7 @@
 
 instance IsTaggedOrBare (Inline ann) where
 
-    type TaggedType (Inline ann) = Tagged (Lines ann)
+    type TaggedType (Inline ann) = TaggedLines ann
     type BareType (Inline ann) = Fragment ann
 
     taggedOrBare = iso f g
diff --git a/library/pro-abstract/ProAbstract/Structure/PlainBlock.hs b/library/pro-abstract/ProAbstract/Structure/PlainBlock.hs
--- a/library/pro-abstract/ProAbstract/Structure/PlainBlock.hs
+++ b/library/pro-abstract/ProAbstract/Structure/PlainBlock.hs
@@ -1,5 +1,5 @@
 module ProAbstract.Structure.PlainBlock
-    ( PlainBlock (..), Tagged (..)
+    ( PlainBlock (..), TaggedPlainBlock (..)
     ) where
 
 import ProAbstract.Annotation
@@ -33,9 +33,9 @@
         PlainBlock <$> traverseOf (traversed % annotation) f t <*> f a
 
 
--- ⭐ Tagged PlainBlock
+-- ⭐ TaggedPlainBlock
 
-data instance Tagged (PlainBlock ann) =
+data TaggedPlainBlock ann =
   TaggedPlainBlock
     { plaintextTag :: Tag ann -- ^ 'ProAbstract.Tag'
     , taggedPlaintext :: PlainBlock ann -- ^ 'ProAbstract.content'
@@ -43,29 +43,29 @@
   deriving stock (Eq, Show, Generic)
   deriving anyclass (Hashable, NFData)
 
-type instance Annotation (Tagged (PlainBlock ann)) = ann
+type instance Annotation (TaggedPlainBlock ann) = ann
 
-instance HasTag (Tagged (PlainBlock ann)) where
-    type TagOpticKind (Tagged (PlainBlock ann)) = A_Lens
+instance HasTag (TaggedPlainBlock ann) where
+    type TagOpticKind (TaggedPlainBlock ann) = A_Lens
     tag = lens plaintextTag \x a -> x{ plaintextTag = a }
 
-type instance Content (Tagged (PlainBlock ann)) = PlainBlock ann
+type instance Content (TaggedPlainBlock ann) = PlainBlock ann
 
-type instance Contents (Tagged (PlainBlock ann)) = Fragment ann
+type instance Contents (TaggedPlainBlock ann) = Fragment ann
 
-instance HasContents (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where
+instance HasContents (TaggedPlainBlock ann) (TaggedPlainBlock ann) where
     contents = content % contents
 
-instance HasManyAnnotations (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann')) where
+instance HasManyAnnotations (TaggedPlainBlock ann) (TaggedPlainBlock ann') where
     allAnnotations = traversalVL \f (TaggedPlainBlock t b) -> TaggedPlainBlock
         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b
 
-instance HasAnnotation (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where
+instance HasAnnotation (TaggedPlainBlock ann) (TaggedPlainBlock ann) where
      annotation = tag % annotation
 
-instance HasContent (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where
+instance HasContent (TaggedPlainBlock ann) (TaggedPlainBlock ann) where
     content = lens taggedPlaintext \x c -> x{ taggedPlaintext = c }
 
-instance HasMetadata (Tagged (PlainBlock ann)) where
-    type MetadataOpticKind (Tagged (PlainBlock ann)) = A_Lens
+instance HasMetadata (TaggedPlainBlock ann) where
+    type MetadataOpticKind (TaggedPlainBlock ann) = A_Lens
     metadata = tag % metadata
diff --git a/library/pro-abstract/ProAbstract/Tag.hs b/library/pro-abstract/ProAbstract/Tag.hs
--- a/library/pro-abstract/ProAbstract/Tag.hs
+++ b/library/pro-abstract/ProAbstract/Tag.hs
@@ -1,6 +1,5 @@
 module ProAbstract.Tag
     ( Tag (..), name
-    , Tagged
     , HasTag (..)
     , HasManyTags (..), HasWitherableTags (..)
     , HasManyBlockTags (..), HasWitherableBlockTags (..)
@@ -11,4 +10,3 @@
 import ProAbstract.Tag.HasTag
 import ProAbstract.Tag.HasTagOptics
 import ProAbstract.Tag.TagType
-import ProAbstract.Tag.TaggedFamily
diff --git a/library/pro-abstract/ProAbstract/Tag/TaggedFamily.hs b/library/pro-abstract/ProAbstract/Tag/TaggedFamily.hs
deleted file mode 100644
--- a/library/pro-abstract/ProAbstract/Tag/TaggedFamily.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module ProAbstract.Tag.TaggedFamily
-    ( Tagged
-    ) where
-
-data family Tagged con
diff --git a/library/pro-abstract/ProAbstract/Tagless/CanHaveTaglessContent.hs b/library/pro-abstract/ProAbstract/Tagless/CanHaveTaglessContent.hs
--- a/library/pro-abstract/ProAbstract/Tagless/CanHaveTaglessContent.hs
+++ b/library/pro-abstract/ProAbstract/Tagless/CanHaveTaglessContent.hs
@@ -17,8 +17,8 @@
 
 instance CanHaveTaglessContent (BlockTag ann) where
     taglessContent s =
-        (plain % taglessContent @(Tagged (PlainBlock ann)) s) `afailing`
-        (fork % taglessContent @(Tagged (Blocks ann)) s)
+        (plain % taglessContent @(TaggedPlainBlock ann) s) `afailing`
+        (fork % taglessContent @(TaggedBlocks ann) s)
 
 instance CanHaveTaglessContent (BlockTagContent ann) where
     taglessContent = tagless
@@ -40,13 +40,13 @@
 instance CanHaveTaglessContent (Fragment ann) where
     taglessContent = tagless
 
-instance CanHaveTaglessContent (Tagged (Blocks ann)) where
+instance CanHaveTaglessContent (TaggedBlocks ann) where
     taglessContent s = content % tagless s
 
-instance CanHaveTaglessContent (Tagged (PlainBlock ann)) where
+instance CanHaveTaglessContent (TaggedPlainBlock ann) where
     taglessContent s = content % tagless s
 
-instance CanHaveTaglessContent (Tagged (Lines ann)) where
+instance CanHaveTaglessContent (TaggedLines ann) where
     taglessContent s = content % tagless s
 
 instance CanHaveTaglessContent (Document ann) where
diff --git a/library/pro-abstract/ProAbstract/Types.hs b/library/pro-abstract/ProAbstract/Types.hs
--- a/library/pro-abstract/ProAbstract/Types.hs
+++ b/library/pro-abstract/ProAbstract/Types.hs
@@ -12,19 +12,17 @@
     , Inline
     , Line
     , Lines
-    , Map
     , MetaItem
     , MetaValue
     , Metadata
     , Paragraph
     , Plain
     , PlainBlock
-    , Seq
-    , Set
     , Tag
-    , Tagged
+    , TaggedBlocks
+    , TaggedLines
+    , TaggedPlainBlock
     , TaggedOrBare
-    , Text
     ) where
 
 import ProAbstract.Datatypes
diff --git a/pro-abstract.cabal b/pro-abstract.cabal
--- a/pro-abstract.cabal
+++ b/pro-abstract.cabal
@@ -1,7 +1,7 @@
 cabal-version: 3.0
 
 name: pro-abstract
-version: 0.2.1.0
+version: 0.3.0.0
 
 category: Language
 synopsis: Abstract syntax for writing documents
@@ -110,7 +110,6 @@
       , ProAbstract.Tag.HasManyTags
       , ProAbstract.Tag.HasTag
       , ProAbstract.Tag.HasTagOptics
-      , ProAbstract.Tag.TaggedFamily
       , ProAbstract.Tag.TagOptics
       , ProAbstract.Tag.TagType
       , ProAbstract.Tagless.CanBeTagless