diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -6,6 +6,31 @@
 - (post 0.3) "enc-B64" will be moved to a different package (more distant goal)
 - Improved constrains in `Data.TypedEncoding.Conv` modules
 
+##
+
+- Breaking 
+  - IsSupersetOpen type family type arguments have changed
+
+- Potentially Breaking  
+  (These changes should be backward compatible in almost all cases):
+  - Stronger (more precise) constraints on all functions `Data.TypedEncoding.Conv`
+  - Compilation errors emitted from `IsSuperset` are different
+  - "r-ban" now only allows ASCII chars in annotation name, errors-out otherwise
+   
+- New
+  - `"r-CHAR8"` phantom restriction and `Superset` modified for "r-CHAR8"
+  - `"r-UNICODE.D76"` /text/ character set restriction and `Superset` modifications
+  - `Superset` constraint added back (different than in 0.2)
+  - properties for `Superset` testing
+  - `"r-ByteRep"` annotation used as a marker of low level use of `Char` instead of `Word8` for `ByteString` work.
+
+- Improved:
+  - `Data.TypedEncoding.Conv` `Text`, `String` and `ByteString` conversions are now more type safe and less error prone.
+    Conversion functions are reversible, A to B to C diagrams commute.
+
+- Fixes:
+  - `Data.TypedEncoding.Instances.Restriction.BoundedAlphaNums` `"r-ban"` now verifies `Superset "r-ASCII"`
+  
 ## 0.3.0.2
 
 - Added documentation to `Data.TypedEncoding.Conv` outlining current limitations, challenges of conversions.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -72,7 +72,6 @@
 
 Please see `Examples.TypedEncoding` it the module list.
 
-
 ## Other encoding packages
 
 My approach will be to write specific encodings (e.g. _HTTP_) or wrap encodings from other packages using separate "bridge" projects.
diff --git a/src/Data/TypedEncoding/Common/Class/Superset.hs b/src/Data/TypedEncoding/Common/Class/Superset.hs
--- a/src/Data/TypedEncoding/Common/Class/Superset.hs
+++ b/src/Data/TypedEncoding/Common/Class/Superset.hs
@@ -8,18 +8,26 @@
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
--- {-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE ConstraintKinds #-}
 
 module Data.TypedEncoding.Common.Class.Superset where
 
 import           Data.TypedEncoding.Common.Util.TypeLits
 
-import           Data.TypedEncoding.Common.Types (Enc(..) )
+import           Data.TypedEncoding.Common.Types (Enc(..)
+                                                  , EncodeEx(..)
+                                                  , Encoding
+                                                  , getPayload 
+                                                  , runEncoding'
+                                                  , toEncoding
+                                                  , AlgNm)
 import           Data.TypedEncoding.Combinators.Unsafe (withUnsafeCoerce)
 import           GHC.TypeLits
 import           Data.Symbol.Ascii
+import           Data.Either (isLeft)
 
 
 -- $setup
@@ -45,17 +53,31 @@
 --
 -- @IsSuperset bigger smaller@ reads as @bigger@ is a superset of @smaller@
 --
+-- Note, no IsSuperset "r-UNICODE.D76" "r-CHAR8" even though the numeric range of D76 includes all CHAR8 bytes.
+-- This is more 'nominal' decision that prevents certain unwanted conversions from being possible.
+--
 -- @since 0.2.2.0
 type family IsSuperset (y :: Symbol) (x :: Symbol) :: Bool where
     IsSuperset "r-ASCII" "r-ASCII" = 'True
     IsSuperset "r-UTF8"  "r-ASCII" = 'True
     IsSuperset "r-UTF8"  "r-UTF8" = 'True
-    IsSuperset y x = IsSupersetOpen y (TakeUntil x ":") (ToList x)
+    IsSuperset "r-CHAR8" "r-ASCII" = 'True  -- "r-CHAR8" is phantom, no explicit instances so it does not need reflexive case
+    IsSuperset "r-CHAR8" "r-ByteRep" = 'True
+    IsSuperset "r-CHAR8" x = Or (IsSuperset "r-ASCII" x) (IsSupersetOpen "r-CHAR8" x (TakeUntil x ":") (ToList x))
+    IsSuperset "r-UNICODE.D76" "r-UNICODE.D76" = 'True 
+    IsSuperset "r-UNICODE.D76" "r-ASCII" = 'True 
+    IsSuperset "r-UNICODE.D76" x = Or (IsSuperset "r-CHAR8" x) (IsSupersetOpen "r-UNICODE.D76" x (TakeUntil x ":") (ToList x))
+    IsSuperset y x = IsSupersetOpen y x (TakeUntil x ":") (ToList x)
 
+-- backward compatible r-CHAR8
+-- IsSuperset "r-CHAR8" x = Or (IsSuperset "r-ASCII" x) (IsSupersetOpen "r-CHAR8" (TakeUntil x ":") (ToList x))
+
 -- |
 -- @since 0.2.2.0
-type family IsSupersetOpen (y :: Symbol) (x :: Symbol) (xs :: [Symbol]) :: Bool
+type family IsSupersetOpen (big :: Symbol) (nm :: Symbol) (alg :: Symbol) (nmltrs :: [Symbol]) :: Bool
 
+type Superset big small = (IsSuperset big small ~ 'True)
+
 -- |
 -- >>> let Right tstAscii = encodeFAll . toEncoding () $ "Hello World" :: Either EncodeEx (Enc '["r-ASCII"] () T.Text)
 -- >>> displ (injectInto @ "r-UTF8" tstAscii)
@@ -68,7 +90,33 @@
 -- TODO consider expanding to 
 -- _injectInto ::forall y x xs c str . (IsSuperset y x ~ 'True) =>  Enc (x ': xs) c str ->  Enc (Replace x y xs) c str
 
+
 -- |
+-- Test for Supersets defined in this module
+--
+-- Actual tests in the project /test/ suite.
+propSuperset' :: forall algb algs b s str . (Superset b s, Eq str) 
+                 => 
+                 Encoding (Either EncodeEx) b algb () str 
+                 -> Encoding (Either EncodeEx) s algs () str 
+                 -> str 
+                 -> Bool
+propSuperset' encb encs str = 
+    case (isLeft rb, isLeft rs) of 
+        (True, False) -> False
+        (False, False) -> pb == ps
+        _ -> True
+
+    where 
+        rb = runEncoding' @algb encb . toEncoding () $ str 
+        rs = runEncoding' @algs encs . toEncoding () $ str 
+        pb = either (const str) id $ getPayload <$> rb
+        ps = either (const str) id $ getPayload <$> rs
+        
+propSuperset_ :: forall b s str algb algs. (Superset b s, Eq str, AlgNm b ~ algb, AlgNm s ~ algs) => Encoding (Either EncodeEx) b algb () str -> Encoding (Either EncodeEx) s algs () str -> str -> Bool
+propSuperset_ = propSuperset' @algb @algs
+
+-- |
 -- IsSuperset is not intended for @"enc-"@ encodings. This class is.
 -- 
 -- It allows to specify constraints that say, for example, that /Base 64/ encodes into 
@@ -86,6 +134,56 @@
 _encodesInto :: forall y enc xs c str r . (IsSuperset y r ~ 'True, EncodingSuperset enc, r ~ EncSuperset enc) => Enc (enc ': xs) c str -> Enc (y ': enc ': xs) c str
 _encodesInto = injectInto . implEncInto
 
--- prop_Superset :: forall y x xs c str . (Superset y x, Eq str) => Enc (x ': xs) c str -> Bool
--- prop_Superset x = getPayload x == (getPayload . inject @y @x $ x)
+-- |
+-- validates superset restriction
+-- 
+-- Actual tests in the project /test/ suite.
+propEncodesInto' :: forall algb algr b r str . (EncodingSuperset b, r ~ EncSuperset b, Eq str) => Encoding (Either EncodeEx) b algb () str -> Encoding (Either EncodeEx) r algr () str -> str -> Bool
+propEncodesInto' encb encr str = 
+    case rb of
+        Left _ -> True
+        Right enc -> case runEncoding' @algr encr . toEncoding () $ getPayload enc of
+            Right _ -> True
+            Left _ -> False  
+    where
+        rb = runEncoding' @algb encb . toEncoding () $ str 
 
+propEncodesInto_ :: forall b r str algb algr. (
+    EncodingSuperset b
+    , r ~ EncSuperset b
+    , Eq str
+    , AlgNm b ~ algb
+    , AlgNm r ~ algr
+    ) => Encoding (Either EncodeEx) b algb () str 
+       -> Encoding (Either EncodeEx) r algr () str 
+       -> str 
+       -> Bool
+propEncodesInto_ = propEncodesInto' @algb @algr
+
+-- | 
+-- Aggregate version of 'EncodingSuperset' 
+--
+-- This is not ideal but easy to implement.
+-- The issue is that this assumes restricted co-domain which is what often happens
+-- but often does not,  e.g. it will not work well with id transformation.
+--
+-- @since 0.4.0.0
+class AllEncodeInto (superset :: Symbol) (encnms :: [Symbol]) where
+     
+instance {-# OVERLAPPING #-}  AllEncodeInto "r-CHAR8" '[] 
+instance (AllEncodeInto "r-CHAR8" xs, IsSuperset "r-CHAR8" r ~ 'True, EncodingSuperset enc, r ~ EncSuperset enc) => AllEncodeInto "r-CHAR8" (enc ': xs)
+
+instance {-# OVERLAPPING #-}  AllEncodeInto "r-UNICODE.D76" '[] 
+instance (AllEncodeInto "r-UNICODE.D76" xs, IsSuperset "r-UNICODE.D76" r ~ 'True, EncodingSuperset enc, r ~ EncSuperset enc) => AllEncodeInto "r-UNICODE.D76" (enc ': xs)
+
+instance {-# OVERLAPPING #-}  AllEncodeInto "r-UTF8" '[] 
+instance (AllEncodeInto "r-UTF8" xs, IsSuperset "r-UTF8" r ~ 'True, EncodingSuperset enc, r ~ EncSuperset enc) => AllEncodeInto "r-UTF8" (enc ': xs)
+
+tstChar8Encodable :: forall nms . AllEncodeInto "r-CHAR8" nms => String
+tstChar8Encodable = "I am CHAR8 encodable"
+
+tstD76Encodable :: forall nms . AllEncodeInto "r-UNICODE.D76" nms => String
+tstD76Encodable = "I can be a valid text"
+
+tstUTF8Encodable :: forall nms . AllEncodeInto "r-UTF8" nms => String
+tstUTF8Encodable = "I am a valid UTF8"
diff --git a/src/Data/TypedEncoding/Common/Class/Util/StringConstraints.hs b/src/Data/TypedEncoding/Common/Class/Util/StringConstraints.hs
--- a/src/Data/TypedEncoding/Common/Class/Util/StringConstraints.hs
+++ b/src/Data/TypedEncoding/Common/Class/Util/StringConstraints.hs
@@ -106,7 +106,8 @@
 
 -- |
 -- Used to find exceptions that violated "r-" encoding
--- Expected to be used to check encoding of ASCII-7 so Text and ByteString are compatible.
+-- Expected to be used to check encoding of ASCII-7 so Text and ByteString are compatible
+-- or to check 0-255 range restrictions. 
 --
 -- @since 0.3.0.0
 class Char8Find str where
@@ -141,3 +142,22 @@
 
 instance Char8Find BL.ByteString where
     find = BL8.find         
+
+
+
+-- -- |
+-- -- Finds character in @str@.
+-- -- @str@ is expected to represent full char range all the way to @'\x10FFFF'@
+-- --
+-- -- @since 0.3.1.0
+-- class CharFind str where
+--     findChar :: (Char -> Bool) -> str -> Maybe Char
+
+-- instance CharFind String where
+--     findChar = L.find
+
+-- instance CharFind T.Text where
+--     findChar = T.find
+
+-- instance CharFind TL.Text where
+--     findChar = TL.find         
diff --git a/src/Data/TypedEncoding/Common/Types/Common.hs b/src/Data/TypedEncoding/Common/Types/Common.hs
--- a/src/Data/TypedEncoding/Common/Types/Common.hs
+++ b/src/Data/TypedEncoding/Common/Types/Common.hs
@@ -80,3 +80,10 @@
     IsROrEmpty "" = True
     IsROrEmpty x  = IsR x
 
+-- | 
+-- >>> :kind! RemoveRs '["r-UPPER", "enc-test", "r-lower", "do-UPPER"]
+-- ...
+-- = '["enc-test", "do-UPPER"]
+type family RemoveRs (s :: [Symbol]) :: [Symbol] where
+    RemoveRs '[] = '[]
+    RemoveRs (x ': xs) = If (OrdBool (CmpSymbol "r-" (Take 2 x))) (RemoveRs xs) (x ': RemoveRs xs) 
diff --git a/src/Data/TypedEncoding/Common/Util/TypeLits.hs b/src/Data/TypedEncoding/Common/Util/TypeLits.hs
--- a/src/Data/TypedEncoding/Common/Util/TypeLits.hs
+++ b/src/Data/TypedEncoding/Common/Util/TypeLits.hs
@@ -41,6 +41,13 @@
     AcceptEq msg _ =  TypeError msg
 
 -- !
+-- @since 0.4.0.0
+type family OrdBool (c :: Ordering) :: Bool where
+    OrdBool EQ = 'True
+    OrdBool _  =  'False
+
+
+-- !
 -- @since 0.2.1.0
 type family And (b1 :: Bool) (b2 :: Bool) :: Bool where
     And 'True 'True = 'True
@@ -54,6 +61,12 @@
 
 -- !
 -- @since 0.2.1.0
+type family If (b1 :: Bool) (a :: k) (b :: k) :: k where
+    If 'True a _ = a
+    If 'False _ b = b
+
+-- !
+-- @since 0.2.1.0
 type family Repeat (n :: Nat) (s :: Symbol) :: Symbol where
     Repeat 0 s = ""
     Repeat n s = AppendSymbol s (Repeat (n - 1) s)
@@ -166,6 +179,7 @@
     LLast (_ ': xs) = LLast xs
 
 
+
 -- |
 -- >>> :kind! Concat (Snoc '["1","2","3"] "4") 
 -- ...
@@ -191,3 +205,5 @@
 
 type family UnSnocHelper (s :: k) (t :: ([k], k)) :: ([k], k) where 
    UnSnocHelper y ('(,) xs x) = '(,) (y ': xs) x   
+
+   
diff --git a/src/Data/TypedEncoding/Conv.hs b/src/Data/TypedEncoding/Conv.hs
--- a/src/Data/TypedEncoding/Conv.hs
+++ b/src/Data/TypedEncoding/Conv.hs
@@ -11,71 +11,157 @@
 -- * "Data.TypedEncoding.Conv.ByteString.Char8"
 -- * "Data.TypedEncoding.Conv.ByteString.Lazy.Char8"
 --
--- Two goals of conversions are:
+-- Two goals of these conversions are:
 --
--- * provide a way to easily convert encoded data directly between /text/ and /bytestring/ types.
 -- * provide added type safety for string conversions
+-- * provide a way to easily convert encoded data directly between /text/ and /bytestring/ types.
 --
--- == Enc conversions 
--- 
--- Consider defining a conversion function @:: Enc xs c str1 -> f (Enc xs c str2)@.
 --
--- One challenge is how do we know that @xs@ is a valid encoding stack also for @str2@?
--- Should we constrain that?      
+-- == Type Safety
 --
--- This is made even more difficult because this library plays (has to) games with orphan instances.
+-- Haskell has 3 (5 counting lazy versions) popular string types, unfortunately they are all quite different.
 --
--- The other challenge is how to ensure that if the destination decides to partially or fully decode, then
--- it will do so without errors and the decoding will be meaningful.
+-- Consider these 4 popular conversion functions:
 --
--- Current definition is not optimal, it was selected because it works with a wide range of
--- encodings (all @"r-"@ encodings, all non-@"r-"@ encodings available in this version of the library).
--- However, future versions should try to improve on this.    
+-- @
+-- import qualified Data.Text as T
+-- import qualified Data.ByteString.Char8 as B8
+-- import qualified Data.Text.Encoding as TE
 --
--- == Type Safety
+-- T.pack        :: String -> T.Text 
+-- T.unpack      :: T.Text -> String
+-- B8.pack       :: String -> B8.ByteString
+-- B8.unpack     :: B8.ByteString -> String
+-- TE.decodeUtf8 :: B8.ByteString -> T.Text 
+-- TE.encodeUtf8 :: T.Text -> B8.ByteString
+-- @
 --
--- Consider the following diagram(s) of popular /text/ and /bytestring/ conversion functions:
+-- They come in pairs but are not reversible.  
 --
+-- Going from A to C depends on B, none of the following 4 diagrams commutes:
+--
 -- @
 --  String -> B8.pack ->   ByteString
---   ^                    ^     |
---   |                    | encodeUtf8
---  id                    |     |
---   |               decodeUtf8 |
---   v                    |     v
---  String -> T.pack ->     Text
+--   ^                    ^        |
+--   |                    | TE.decodeUtf8
+--  id                    |        |
+--   |               TE.encodeUtf8 |
+--   v                    |        v
+--  String -> T.pack ->      Text
 -- @
 --
--- and the reverse of these:
---
 -- @
 --  String <- B8.unpack <- ByteString
---   ^                      ^     |
---   |                      | encodeUtf8
---  id                      |     |
---   |                 decodeUtf8 |
---   v                      |     v
+--   ^                      ^      |
+--   |                      | TE.decodeUtf8
+--  id                      |      |
+--   |               TE.encodeUtf8 |
+--   v                      |      v
 --  String <- T.unpack  <-    Text
 -- @
 --
--- These diagrams actually do not commute.  This makes it easy to code bugs
--- that are hard to find and hard to troubleshoot.
+-- All of this can lead to bugs that are hard to find and hard to troubleshoot.
 --
--- Well, they actually do commute on a subset of @String@ / @Text@ values:
+-- /typed-encoding/ provides more precise types so that all of this goes away.
+-- 
+-- Here are the type signatures simplified to one single encoding annotation:
 --
 -- @
--- Enc '["r-ASCII"] c String
--- Enc '["r-ASCII"] c ByteString
--- Enc '["r-ASCII"] c Text
--- @ 
+-- import qualified Data.TypedEncoding.Conv.Text as ET
+-- import qualified Data.TypedEncoding.Conv.ByteString.Char8 as EB8
+-- import qualified Data.TypedEncoding.Conv.Text.Encoding as ETE
 --
--- This is because /UTF8/ is backward compatible with /ASCII(-7)/ and we speak /UTF8/ when
--- converting and and from @Text@.
+-- ET.pack        :: (Superset "r-UNICODE.D76" r) => Enc '[r] c String -> Enc '[r] c T.Text 
+-- ET.unpack      :: (Superset "r-UNICODE.D76" r) => Enc '[r] c T.Text -> Enc '[r] c String
+-- EB8.pack       :: (Superset "r-CHAR8" r)       => Enc '[r] c String -> Enc '[r] c B8.ByteString
+-- EB8.unpack     :: (Superset "r-CHAR8" r)       => Enc '[r] c B8.ByteString -> Enc '[r] c String
+-- ETE.decodeUtf8 :: (Superset "r-UTF8" r)        => Enc '[r] c B8.ByteString -> Enc '[r] c T.Text 
+-- ETE.encodeUtf8 :: (Superset "r-UTF8" r)        => Enc '[r] c T.Text -> Enc '[r] c B8.ByteString  
+-- @
+--
+-- @"r-UNICODE.D76"@ and @"r-UTF8"@ is considered redundant for @T.Text@ and can be added or dropped as needed.
 -- 
--- This is the reason why this version of /typed-encoding/ decided on using
--- "r-ASCII" to constrain when wrapping @B8.pack@ and @B8.unpack@ in 
--- "Data.TypedEncoding.Conv.ByteString.Char8"
+-- Corresponding pairs reverse, this should be clear since the types are restricted to what @T.Text@ can store or to 
+-- how @B8.Char@ works.
 --
--- This approach seems to be limiting and future versions will work on relaxing it.
+-- Now consider any of the above diagrams, for instance, compare
+-- 
+-- @
+-- ETE.encodeUtf8 . ET.pack :: (Superset "r-UNICODE.D76" r, Superset "r-UTF8" r) => Enc '[r] c String -> Enc '[r] c B8.ByteString 
+-- -- and 
+-- EB8.pack :: (Superset "r-CHAR8" r) => Enc '[r] c String -> Enc '[r] c B8.ByteString
+-- @  
+--
+-- What is the set of common values allowing us to use any of these 2 options?
+--
+-- "r-UNICODE.D76" is not important here (it removes a range of Unicode values way above @\'\255\'@), what is the intersection of /UTF8/ and /CHAR8/ code point space?
+--
+-- There are many character set encodings that utilize one byte (/CHAR8/) and /UTF8/ is different from all of them
+-- but it backward compatible only within the /ASCII/ range of chars @ < 127@.  So the intersection should be /ASCII/, let us check that:
+--
+-- @
+-- ghci> :t ETE.encodeUtf8 . ET.pack @'["r-ASCII"]
+-- EncTe.encodeUtf8 . EncT.pack @'["r-ASCII"]
+--  :: Enc [Symbol] ((':) Symbol "r-ASCII" ('[] Symbol)) c String
+--     -> Enc [Symbol] ((':) Symbol "r-ASCII" ('[] Symbol)) c B.ByteString
+--
+-- ghci> :t EncB8.pack @'["r-ASCII"]
+--  :: Enc [Symbol] ((':) Symbol "r-ASCII" ('[] Symbol)) c String
+--    -> Enc [Symbol] ((':) Symbol "r-ASCII" ('[] Symbol)) c B.ByteString
+-- @  
+--
+-- They both accept that common denominator.  
+-- Now we could run a property test but it is clear that by the design these will match!
+--    
+-- Note, there is no @Superset "r-UNICODE.D76" "r-CHAR8"@ mapping, "r-CHAR8" supersets any
+-- 8-bit encoding like /ISO/IEC 8859/ family of encodings.  This is by design even if structurally such 
+-- definition would made sense.
+--
+-- This choice effectively prevents anything classified under @"r-CHAR8"@
+-- to end up as a visible encoding annotation in @Text@ (since that would made little sense as @Text@ is /UTF/ encoded).  
+-- This is just one example of added type level security that /type-encoding/ provides.
+--
+-- Currently, "r-CHAR8" is intended as upper bound on "r-" encodings only. There is no way
+-- to encode to it using provided encoding mechanisms (except for /unsafe/ options).
+-- Effectively the types
+-- 
+-- @
+-- Enc "r-CHAR8" c str
+-- @
+--
+-- can be viewed as uninhabited. 
+--
+-- However, @Char@ is often used instead of @Word8@
+-- for low level @ByteString@ programming. This is supported with the @"r-ByteRep"@ annotation.
+--
+-- @
+-- Enc "r-ByteRep" c str
+-- @
+--
+-- this one can be used as @Superset "r-CHAR8" "r-ByteRep"@! 
+-- That allows for @EncB8@ conversions to work on such data.
+-- However, there is no @Superset "r-UNICODE.D76" "r-ByteRep"@ so these cannot be converted to @Text@, which is 
+-- exactly what is intended. 
+--
+--
+-- == @Enc@ conversions 
+-- 
+-- Consider defining a conversion function @:: Enc xs c str1 -> f (Enc xs c str2)@.
+--
+-- One challenge is how do we know that @xs@ is a valid encoding stack also for @str2@?
+-- Should we constrain that?      
+--
+-- This is made even more difficult because this library uses (has to) orphan instances.
+--
+-- The other challenge is how to ensure that, if the destination is partially or fully decoded, then
+-- it will decode without errors and the decoding will be meaningful.
+--
+-- Current version does not impose any instance constraint about existence of the stack for @str2@. 
+-- It is possible to not have one, in that case @decodeAll@ combinators will not be available.
+--
+-- This is still useful as the payload could be safely extracted, to save to the database or do other things with it.
+--
+-- Future versions of /typed-encoding/ may provide ways to ensure validity of the encoding stack for @str2@.
+
 
 module Data.TypedEncoding.Conv where
diff --git a/src/Data/TypedEncoding/Conv/ByteString/Char8.hs b/src/Data/TypedEncoding/Conv/ByteString/Char8.hs
--- a/src/Data/TypedEncoding/Conv/ByteString/Char8.hs
+++ b/src/Data/TypedEncoding/Conv/ByteString/Char8.hs
@@ -18,18 +18,14 @@
 -- | 
 -- Type safer version of 'Data.ByteString.Char8.pack'.
 -- 
--- This assumes that each of the encodings in @xs@ work work equivalently in @String@ and @ByteString@.
---
--- This function assumes that encoding stack @xs@ does not shift characters outside of Char8 range.  
--- This is obviously true for all "r-" types
--- it is also true for any "enc-" and "do-" encodings currently available in this package. However, is possible to define a "do-" or "enc-" encodings that violate that. 
--- Future versions of /type-encoding/ are likely 
--- to introduce constraints to guard this aspect of the type safety better. 
+-- This assumes that each of the encodings in @xs@ work equivalently in @String@ and @ByteString@.
 --
 -- This function also (currently) does not insist that @xs@ is a valid encoding stack for @ByteString@. 
 -- This will be reexamined in the future, possibly offering alternatives with different safety levels.
 --
--- Currently this uses (an over-conservative) @"r-ASCII"@ superset constraint.
+-- Expected encoding stack @xs@ needs to have @"r-" as last element and it needs to be more restrictive 
+-- than "r-CHAR8" (String cannot have chars @> 255@).  Otherwise any encodings other than "r-" need to 
+-- encode into "r-CHAR8".
 --
 -- See "Data.TypedEncoding.Conv" for more detailed discussion.
 --
@@ -37,14 +33,18 @@
 -- ...
 -- ... error:
 -- ... Couldn't match type ...
--- ... "r-ASCII" "r-foo" ...
 -- ...
 --
 -- >>> displ $ pack (unsafeSetPayload () "Hello" :: Enc '["r-bar", "r-ASCII"] () String)
 -- "Enc '[r-bar,r-ASCII] () (ByteString Hello)"
 --
--- @since 0.2.2.0
-pack :: (Knds.LLast xs ~ t, IsSuperset "r-ASCII" t ~ 'True) => Enc xs c String -> Enc xs c B8.ByteString
+--  @since 0.4.0.0
+pack :: (
+    Knds.UnSnoc xs ~ '(,) ys y
+    , Superset "r-CHAR8" y
+    , encs ~ RemoveRs ys
+    , AllEncodeInto "r-CHAR8" encs
+    ) => Enc xs c String -> Enc xs c B8.ByteString
 pack = unsafeChangePayload B8.pack
 
 -- | @unpack@ on encoded strings.
@@ -56,8 +56,12 @@
 -- Future versions of /type-encoding/ are likely 
 -- to introduce constraints to guard this aspect of the type safety better. 
 --
--- @since 0.2.2.0
-unpack :: (Knds.LLast xs ~ t, IsSuperset "r-ASCII" t ~ 'True) => Enc xs c B8.ByteString -> Enc xs c String
+-- @since 0.4.0.0
+unpack :: (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-CHAR8" y
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-CHAR8" encs
+          ) => Enc xs c B8.ByteString -> Enc xs c String
 unpack = unsafeChangePayload B8.unpack      
 
--- TODO consider adding "r-CHAR8"
diff --git a/src/Data/TypedEncoding/Conv/ByteString/Lazy/Char8.hs b/src/Data/TypedEncoding/Conv/ByteString/Lazy/Char8.hs
--- a/src/Data/TypedEncoding/Conv/ByteString/Lazy/Char8.hs
+++ b/src/Data/TypedEncoding/Conv/ByteString/Lazy/Char8.hs
@@ -17,10 +17,20 @@
 
 -- | 
 -- Lazy version of 'Data.TypedEncoding.Conv.ByteString.Char8.pack'.
-pack :: (Knds.LLast xs ~ t, IsSuperset "r-ASCII" t ~ 'True) => Enc xs c String -> Enc xs c BL8.ByteString
+pack :: (
+     Knds.UnSnoc xs ~ '(,) ys y
+    , Superset "r-CHAR8" y 
+    , encs ~ RemoveRs ys
+    , AllEncodeInto "r-CHAR8" encs
+    ) => Enc xs c String -> Enc xs c BL8.ByteString
 pack = unsafeChangePayload BL8.pack
 
 -- | 
 -- Lazy version of 'Data.TypedEncoding.Conv.ByteString.Char8.unpack'.
-unpack :: (Knds.LLast xs ~ t, IsSuperset "r-ASCII" t ~ 'True) => Enc xs c BL8.ByteString -> Enc xs c String
+unpack :: (
+          Knds.UnSnoc xs ~ '(,) ys y
+        , Superset "r-CHAR8" y
+        , encs ~ RemoveRs ys
+        , AllEncodeInto "r-CHAR8" encs
+       ) => Enc xs c BL8.ByteString -> Enc xs c String
 unpack = unsafeChangePayload BL8.unpack          
diff --git a/src/Data/TypedEncoding/Conv/Text.hs b/src/Data/TypedEncoding/Conv/Text.hs
--- a/src/Data/TypedEncoding/Conv/Text.hs
+++ b/src/Data/TypedEncoding/Conv/Text.hs
@@ -1,12 +1,14 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE PolyKinds #-} -- removes need to annotate kinds as [Symbol]
+{-# LANGUAGE FlexibleContexts #-}
 
 -- | Text encoding combinators specific to 'T.Text'
 -- @since 0.2.2.0
 module Data.TypedEncoding.Conv.Text where
 
 import qualified Data.Text as T
+import qualified Data.TypedEncoding.Common.Util.TypeLits as Knds
 import           Data.TypedEncoding.Instances.Support
 
 
@@ -15,11 +17,21 @@
 
 
 -- | This assumes that each of the encodings in @xs@ work work equivalently in @String@ and @Text@. 
-pack :: Enc xs c String -> Enc xs c T.Text
+pack :: (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UNICODE.D76" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UNICODE.D76" encs
+          ) => Enc xs c String -> Enc xs c T.Text
 pack = unsafeChangePayload T.pack
 
 -- | This assumes that each of the encodings in @xs@ work work equivalently in @String@ and @Text@. 
-unpack :: Enc xs c T.Text -> Enc xs c String
+unpack :: (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UNICODE.D76" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UNICODE.D76" encs
+          ) => Enc xs c T.Text -> Enc xs c String
 unpack = unsafeChangePayload T.unpack 
 
 -- | 
@@ -42,3 +54,10 @@
 -- "Enc '[] () (Text Hello)"
 utf8Demote :: (UnSnoc xs ~ '(,) ys "r-UTF8") => Enc xs c T.Text -> Enc ys c T.Text
 utf8Demote = withUnsafeCoerce id
+
+
+d76Promote :: Enc xs c T.Text -> Enc (Snoc xs "r-UNICODE.D76") c T.Text
+d76Promote = withUnsafeCoerce id
+
+d76Demote :: (UnSnoc xs ~ '(,) ys "r-UNICODE.D76") => Enc xs c T.Text -> Enc ys c T.Text
+d76Demote = withUnsafeCoerce id
diff --git a/src/Data/TypedEncoding/Conv/Text/Encoding.hs b/src/Data/TypedEncoding/Conv/Text/Encoding.hs
--- a/src/Data/TypedEncoding/Conv/Text/Encoding.hs
+++ b/src/Data/TypedEncoding/Conv/Text/Encoding.hs
@@ -14,6 +14,7 @@
 import qualified Data.Text.Encoding as TE    
 
 import           Data.TypedEncoding.Instances.Support
+import qualified Data.TypedEncoding.Common.Util.TypeLits as Knds
 import           Data.TypedEncoding.Instances.Restriction.UTF8 ()
 import           Data.TypedEncoding.Instances.Restriction.ASCII ()
 import           Data.TypedEncoding.Unsafe (withUnsafe)
@@ -78,8 +79,13 @@
 --
 -- See "Data.TypedEncoding.Conv" for more detailed discussion.
 --
--- @since 0.2.2.0
-decodeUtf8 :: forall xs c t. (LLast xs ~ t, IsSuperset "r-UTF8" t ~ 'True) => Enc xs c B.ByteString -> Enc xs c T.Text 
+-- @since 0.4.0.0
+decodeUtf8 :: forall xs c t y ys encs. (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UTF8" y
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UTF8" encs
+        ) => Enc xs c B.ByteString -> Enc xs c T.Text 
 decodeUtf8 = withUnsafe (fmap TE.decodeUtf8)
 
 -- |
@@ -90,6 +96,11 @@
 --
 -- See "Data.TypedEncoding.Conv" for more detailed discussion.
 --
--- @since 0.2.2.0
-encodeUtf8 :: forall xs c t.  (LLast xs ~ t, IsSuperset "r-UTF8" t ~ 'True) => Enc xs c T.Text -> Enc xs c B.ByteString 
+-- @since 0.4.0.0
+encodeUtf8 :: forall xs c t y ys encs.   (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UTF8" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UTF8" encs
+        ) => Enc xs c T.Text -> Enc xs c B.ByteString 
 encodeUtf8 = withUnsafe (fmap TE.encodeUtf8)
diff --git a/src/Data/TypedEncoding/Conv/Text/Lazy.hs b/src/Data/TypedEncoding/Conv/Text/Lazy.hs
--- a/src/Data/TypedEncoding/Conv/Text/Lazy.hs
+++ b/src/Data/TypedEncoding/Conv/Text/Lazy.hs
@@ -4,13 +4,20 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE PolyKinds #-} -- removes need to annotate kinds as [Symbol]
+{-# LANGUAGE FlexibleContexts #-}
 
 module Data.TypedEncoding.Conv.Text.Lazy where
 
 import qualified Data.Text.Lazy as TL
+import qualified Data.TypedEncoding.Common.Util.TypeLits as Knds
 import           Data.TypedEncoding.Instances.Support
 
-pack :: Enc xs c String -> Enc xs c TL.Text
+pack :: (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UNICODE.D76" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UNICODE.D76" encs
+        ) => Enc xs c String -> Enc xs c TL.Text
 pack = unsafeChangePayload TL.pack
 
 unpack :: Enc xs c TL.Text -> Enc xs c String
diff --git a/src/Data/TypedEncoding/Conv/Text/Lazy/Encoding.hs b/src/Data/TypedEncoding/Conv/Text/Lazy/Encoding.hs
--- a/src/Data/TypedEncoding/Conv/Text/Lazy/Encoding.hs
+++ b/src/Data/TypedEncoding/Conv/Text/Lazy/Encoding.hs
@@ -14,15 +14,26 @@
 import qualified Data.Text.Lazy.Encoding as TEL    
 
 import           Data.TypedEncoding.Instances.Support
+import qualified Data.TypedEncoding.Common.Util.TypeLits as Knds
 import           Data.TypedEncoding.Instances.Restriction.UTF8 ()
 import           Data.TypedEncoding.Instances.Restriction.ASCII ()
 import           Data.TypedEncoding.Unsafe (withUnsafe)
 
 
 -- | Lazy version of 'Data.TypedEncoding.Conv.Text.Encoding.decodeUtf8'
-decodeUtf8 :: forall xs c t. (LLast xs ~ t, IsSuperset "r-UTF8" t ~ 'True) => Enc xs c BL.ByteString -> Enc xs c TL.Text 
+decodeUtf8 :: forall xs c t y ys encs. (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UTF8" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UTF8" encs
+        ) => Enc xs c BL.ByteString -> Enc xs c TL.Text 
 decodeUtf8 = withUnsafe (fmap TEL.decodeUtf8)
 
 -- | Lazy version of 'Data.TypedEncoding.Conv.Text.Encoding.encodeUtf8'
-encodeUtf8 :: forall xs c t.  (LLast xs ~ t, IsSuperset "r-UTF8" t ~ 'True) => Enc xs c TL.Text -> Enc xs c BL.ByteString 
+encodeUtf8 :: forall xs c t y ys encs. (
+          Knds.UnSnoc xs ~ '(,) ys y
+         , Superset "r-UTF8" y 
+         , encs ~ RemoveRs ys
+         , AllEncodeInto "r-UTF8" encs
+        ) => Enc xs c TL.Text -> Enc xs c BL.ByteString 
 encodeUtf8 = withUnsafe (fmap TEL.encodeUtf8)
diff --git a/src/Data/TypedEncoding/Instances/Enc/Base64.hs b/src/Data/TypedEncoding/Instances/Enc/Base64.hs
--- a/src/Data/TypedEncoding/Instances/Enc/Base64.hs
+++ b/src/Data/TypedEncoding/Instances/Enc/Base64.hs
@@ -78,6 +78,12 @@
 instance EncodingSuperset "enc-B64" where
     type EncSuperset "enc-B64" = "r-ASCII"
 
+-- |
+-- >>> tstChar8Encodable @ '["enc-B64-len", "enc-B64"]
+-- "I am CHAR8 encodable"
+instance EncodingSuperset "enc-B64-len" where
+    type EncSuperset "enc-B64-len" = "r-ASCII"
+
 -- * Encoders
 
 -- |
diff --git a/src/Data/TypedEncoding/Instances/Restriction/BoundedAlphaNums.hs b/src/Data/TypedEncoding/Instances/Restriction/BoundedAlphaNums.hs
--- a/src/Data/TypedEncoding/Instances/Restriction/BoundedAlphaNums.hs
+++ b/src/Data/TypedEncoding/Instances/Restriction/BoundedAlphaNums.hs
@@ -52,7 +52,7 @@
 
 type Ban s = (KnownSymbol s, IsBan s ~ 'True)
 
-type instance IsSupersetOpen "r-ASCII" "r-ban" xs = 'True
+type instance IsSupersetOpen "r-ASCII" x "r-ban" xs = 'True
 
 
 instance (Ban s, Algorithm s "r-ban", IsStringR str) => Encode (Either EncodeEx) s "r-ban" c str where
@@ -97,15 +97,16 @@
 -- Left "'G' not boulded by 'F'"
 -- >>> verifyBoundedAlphaNum (Proxy :: Proxy "r-ban:FF-FF") (T.pack "13G3E")
 -- Left "'G' not matching '-'"
--- >>> verifyBoundedAlphaNum (Proxy :: Proxy "r-ban:FF-FF") (T.pack "13-234")
--- Left "Input list has wrong size expecting 5 but length \"13-234\" == 6"
+-- >>> verifyBoundedAlphaNum (Proxy :: Proxy "r-ban:FFяFF") (T.pack "13я234")
+-- Left "Not ASCII char in annotation '\\1103'"
+-- 
 verifyBoundedAlphaNum :: forall s str . (KnownSymbol s, IsStringR str) => Proxy s -> str -> Either String str
-verifyBoundedAlphaNum p str = 
-    if pattl == inpl 
-    then case lefts match of
-        (e: _) -> Left e
+verifyBoundedAlphaNum p str =         
+    case (lefts match, notAscii, pattl == inpl) of
+        (_, Just ch, _) -> Left $ "Not ASCII char in annotation " ++ show ch
+        (_, _, False) -> Left $ "Input list has wrong size expecting " ++ show pattl ++ " but length " ++ show input ++ " == " ++ show inpl   
+        (e: _, _, _) -> Left e
         _ -> Right str
-    else Left $ "Input list has wrong size expecting " ++ show pattl ++ " but length " ++ show input ++ " == " ++ show inpl   
     where 
         patt = L.drop (L.length ("r-ban:" :: String)) . symbolVal $ p
         input = toString str
@@ -113,7 +114,7 @@
         inpl = L.length input 
         
         match = L.zipWith fn input patt
-
+        notAscii = L.find (not . isAscii) patt
 
         fn ci cp = case (isAlphaNum ci, isAlphaNum cp, ci <= cp, ci == cp) of
             (True, True, True, _) -> Right ()
diff --git a/src/Data/TypedEncoding/Instances/Restriction/ByteRep.hs b/src/Data/TypedEncoding/Instances/Restriction/ByteRep.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/TypedEncoding/Instances/Restriction/ByteRep.hs
@@ -0,0 +1,99 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+-- | 
+-- @"r-ByteRep"@ represents Characters used for Byte representations.
+--
+-- It is common to use @Char@ instead of @Word8@ when low level programming on @ByteString@.
+--
+-- This annotation represents such use of string characters.
+-- 
+-- Checks if all chars are @< \'\256\'@
+--
+-- Currently, this should be not used as superset 'Data.TypedEncoding.Common.Class.Superset.IsSuperset'
+--
+-- It is subset of "r-CHAR8":
+--
+-- @Superset "r-CHAR8" ""r-ByteRep"    
+--
+-- Currently, is (intentionally not decodable)
+--
+-- @since 0.3.1.0
+module Data.TypedEncoding.Instances.Restriction.ByteRep where
+
+import           Data.TypedEncoding.Instances.Support
+import           Data.TypedEncoding.Common.Class.Util.StringConstraints
+
+import           Data.TypedEncoding.Internal.Util (explainBool)
+import           Data.Char
+
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Lazy as BL
+
+-- $setup
+-- >>> :set -XDataKinds -XTypeApplications
+
+
+-----------------
+-- Encodings  --
+-----------------
+
+data CharOutOfRange = CharOutOfRange Int Char deriving (Eq, Show)
+
+-- * Encoding @"r-ByteRep"@
+
+instance Encode (Either EncodeEx) "r-ByteRep" "r-ByteRep" c Char where
+    encoding = encByteChar    
+
+instance Encode (Either EncodeEx) "r-ByteRep" "r-ByteRep" c B.ByteString where
+    encoding = encByteRepB
+
+instance Encode (Either EncodeEx) "r-ByteRep" "r-ByteRep" c BL.ByteString where
+    encoding = encByteRepBL
+
+instance Encode (Either EncodeEx) "r-ByteRep" "r-ByteRep" c String where
+    encoding = encByteRepS
+
+encByteChar :: Encoding (Either EncodeEx) "r-ByteRep" "r-ByteRep" c Char 
+encByteChar = _implEncodingEx (\c -> explainBool (CharOutOfRange 255) (c, (> 255) . ord $ c))    
+
+encByteRepB :: Encoding (Either EncodeEx) "r-ByteRep" "r-ByteRep" c B.ByteString
+encByteRepB = _implEncodingEx @"r-ByteRep" (encImpl 255)
+
+encByteRepBL :: Encoding (Either EncodeEx) "r-ByteRep" "r-ByteRep" c BL.ByteString
+encByteRepBL = _implEncodingEx @"r-ByteRep" (encImpl 255)
+
+encByteRepS :: Encoding (Either EncodeEx) "r-ByteRep" "r-ByteRep" c String
+encByteRepS = _implEncodingEx @"r-ByteRep" (encImpl 255)
+
+
+-- * Decoding @"r-ByteRep"@
+
+-- instance (Applicative f) => Decode f "r-ByteRep" "r-ByteRep" c str where
+--     decoding = decAnyR
+
+
+instance (RecreateErr f, Applicative f) => Validate f "r-ByteRep" "r-ByteRep" () B.ByteString where
+    validation = validR encByteRepB
+
+instance (RecreateErr f, Applicative f) => Validate f "r-ByteRep" "r-ByteRep" () BL.ByteString where
+    validation = validR encByteRepBL
+
+instance (RecreateErr f, Applicative f) => Validate f "r-ByteRep" "r-ByteRep" () String where
+    validation = validR encByteRepS
+
+
+-- * Implementation 
+
+-- 255 for CHAR8 / "r-ByteRep"
+encImpl :: Char8Find str => Int -> str -> Either CharOutOfRange str
+encImpl bound str = case find ((> bound) . ord) str of 
+    Nothing -> Right str
+    Just ch -> Left $ CharOutOfRange bound ch
+
diff --git a/src/Data/TypedEncoding/Instances/Restriction/CHAR8.hs b/src/Data/TypedEncoding/Instances/Restriction/CHAR8.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/TypedEncoding/Instances/Restriction/CHAR8.hs
@@ -0,0 +1,43 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+-- | 
+--
+-- Should not be used directly, only as superset
+--
+-- Checks if all chars are @< \'\256\'@
+--
+-- Encoding functions are here for test support only, no instances
+--
+-- @since 0.3.1.0
+module Data.TypedEncoding.Instances.Restriction.CHAR8 where
+
+import           Data.TypedEncoding.Instances.Support
+import           Data.TypedEncoding.Common.Class.Util.StringConstraints
+import           Data.TypedEncoding.Instances.Restriction.ByteRep (encImpl, CharOutOfRange (..))
+
+import           Data.TypedEncoding.Internal.Util (explainBool)
+import           Data.Char
+
+
+-- $setup
+-- >>> :set -XDataKinds -XTypeApplications
+
+
+-----------------
+-- Test Encodings  --
+-----------------
+
+testEncChar8Char :: Encoding (Either EncodeEx) "r-CHAR8" "r-CHAR8" c Char 
+testEncChar8Char = _implEncodingEx (\c -> explainBool (CharOutOfRange 255) (c, (> 255) . ord $ c))    
+
+testEncCHAR8 :: Char8Find str =>  Encoding (Either EncodeEx) "r-CHAR8" "r-CHAR8" c str
+testEncCHAR8 = _implEncodingEx @"r-CHAR8" (encImpl 255)
+
+
diff --git a/src/Data/TypedEncoding/Instances/Restriction/D76.hs b/src/Data/TypedEncoding/Instances/Restriction/D76.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/TypedEncoding/Instances/Restriction/D76.hs
@@ -0,0 +1,81 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+-- | 
+-- Checks that satisfy D76 Unicode standard (/text/ replaces chars that are in range
+-- U+D800 to U+DFFF inclusive)
+--
+-- Note, no IsSuperset "r-UNICODE.D76" "r-CHAR8" mapping even though the numeric range of D76 includes all CHAR8 bytes.
+-- This is more 'nominal' decision that prevents certain unwanted conversions from being possible.
+--
+-- Similarly no IsSuperset "r-UNICODE.D76" "r-ByteRep", this annotation acts as a guard to what can go into @Text@.
+-- 
+-- @since 0.4.0.0
+module Data.TypedEncoding.Instances.Restriction.D76 where
+
+import           Data.TypedEncoding.Instances.Support
+import           Data.TypedEncoding.Common.Class.Util.StringConstraints
+
+import           Data.TypedEncoding.Internal.Util (explainBool)
+import           Data.Char
+
+
+-- $setup
+-- >>> :set -XDataKinds -XTypeApplications
+
+
+-----------------
+-- Encodings  --
+-----------------
+
+newtype NonTextChar = NonTextChar Char deriving (Eq, Show)
+
+-- * Encoding @"r-UNICODE.D76"@
+
+instance Encode (Either EncodeEx) "r-UNICODE.D76" "r-UNICODE.D76" c Char where
+    encoding = encD76Char    
+
+instance Encode (Either EncodeEx) "r-UNICODE.D76" "r-UNICODE.D76" c String where
+    encoding = encD76
+
+encD76Char :: Encoding (Either EncodeEx) "r-UNICODE.D76" "r-UNICODE.D76" c Char 
+encD76Char = _implEncodingEx (\c -> explainBool NonTextChar (c, nonTextChar c))    
+
+encD76 :: Encoding (Either EncodeEx) "r-UNICODE.D76" "r-UNICODE.D76" c String
+encD76 = _implEncodingEx @"r-UNICODE.D76" encImpl
+
+-- | No-check version
+trustMe :: Applicative f =>  Encoding f "r-UNICODE.D76" "r-UNICODE.D76" c String
+trustMe = _implEncodingP id
+
+
+
+-- * Decoding @"r-UNICODE.D76"@
+
+instance (Applicative f) => Decode f "r-UNICODE.D76" "r-UNICODE.D76" c str where
+    decoding = decAnyR
+    
+instance (RecreateErr f, Applicative f) => Validate f "r-UNICODE.D76" "r-UNICODE.D76" () String where
+    validation = validR encD76
+
+
+-- * Implementation 
+
+-- @'\xd800'@ to  @'\xdfff'@ inclusive
+nonTextChar :: Char -> Bool
+nonTextChar c =  x >= 55296 && x <= 57343
+   where x = ord c
+
+
+-- \ UNICODE.D76
+encImpl :: String -> Either NonTextChar String
+encImpl str = case find nonTextChar str of 
+    Nothing -> Right str
+    Just ch -> Left $ NonTextChar ch
+
diff --git a/src/Examples/TypedEncoding/Conversions.hs b/src/Examples/TypedEncoding/Conversions.hs
--- a/src/Examples/TypedEncoding/Conversions.hs
+++ b/src/Examples/TypedEncoding/Conversions.hs
@@ -61,9 +61,11 @@
 import           Data.TypedEncoding.Instances.Enc.Base64 () 
 import           Data.TypedEncoding.Instances.Restriction.ASCII ()
 import           Data.TypedEncoding.Instances.Restriction.UTF8 ()
+import           Data.TypedEncoding.Instances.Restriction.D76 ()
+import           Data.TypedEncoding.Instances.Restriction.ByteRep ()
 
 import qualified Data.TypedEncoding.Conv.Text as EncT 
-import qualified Data.TypedEncoding.Conv.Text.Encoding as EncTe (decodeUtf8)
+import qualified Data.TypedEncoding.Conv.Text.Encoding as EncTe -- (decodeUtf8)
 
 import qualified Data.Text as T
 import qualified Data.ByteString as B
@@ -110,28 +112,23 @@
 -- "Enc '[r-ASCII] () (Text HeLlo world)"
 
 
--- * pack and unpack
+-- * @pack@ from String
 
 helloZero :: Enc ('[] :: [Symbol]) () String
 helloZero = toEncoding () "Hello"
--- ^ Consider 0-encoding of a 'String',  to move it to @Enc '[] () String@ one could try:
---
--- >>> displ . EncT.pack $ helloZero
--- "Enc '[] () (Text Hello)"
+-- ^ Consider 0-encoding of a 'String',  to move it to @Enc '[] () ByteString@ one could try:
 --
--- this works, but:
--- 
 -- >>> EncB8.pack helloZero
 -- ...
 -- ... error: 
--- ... Empty Symbol list not allowed
+-- ... Empty list, no last element
 -- ...
 --
 -- this does not compile.  And it should not. @pack@ from "Data.ByteString.Char8" is error prone.
 -- It is not an injection as it only considers first 8 bits of information from each 'Char'.  
 -- I doubt that there are any code examples of its intentional use on a String that has chars @> \'\255\'@.
 --
--- Current version of pack @EncB8.pack@ will not compile unless the encoding is ASCII restricted (@< \'\128\'@).
+-- @EncB8.pack@ will not compile unless the encoding has "r-CHAR8" as its superset.
 -- This works:
 -- 
 -- >>> fmap (displ . EncB8.pack) . encodeFAll @'["r-ASCII"] @(Either EncodeEx) $ helloZero
@@ -139,13 +136,18 @@
 --
 -- And the result is a @ByteString@ with bonus annotation describing its content.
 --
--- Future versions are likely to relax this restriction to a more permissive "r-" annotation that allows for any char @<= \'\255\'@
+-- Similar game is played for @Text@:
+--
+-- >>> fmap (displ . EncT.d76Demote . EncT.pack) . encodeFAll @'["r-UNICODE.D76"] @(Either EncodeEx) $ helloZero
+-- Right "Enc '[] () (Text Hello)"
+--
+-- See "Data.TypedEncoding.Conv" for more information on this.
 
 
 helloRestricted :: Either EncodeEx (Enc '["r-ban:zzzzz"] () B.ByteString)
 helloRestricted = fmap EncB8.pack . _runEncodings encodings $ toEncoding () "Hello"
 -- ^ more interestingly @EncB8.pack@ works fine on "r-" encodings that are subsets of "r-ASCII"
--- this example @"r-ban:zzzzz"@ restricts to 5 alpha-numeric charters all < @\'z\'@
+-- this example @"r-ban:zzzzz"@ restricts to 5 alpha-numeric charters all @< \'z\'@
 -- 
 -- >>> displ <$> helloRestricted
 -- Right "Enc '[r-ban:zzzzz] () (ByteString Hello)"
@@ -159,6 +161,9 @@
 -- Right "Enc '[r-ban:zzzzz] () (String Hello)"
 -- 
 
+byteRep :: Either EncodeEx (Enc '["r-ByteRep"] () B.ByteString)
+byteRep = fmap EncB8.pack . _runEncodings encodings $ toEncoding () "\254"
+-- ^ For low level use of @Char@ instead of @Word8@, "r-ByteRep" represents anything under @256@.
 
 -- * More complex rules
 
diff --git a/test/Test/SupersetSpec.hs b/test/Test/SupersetSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/SupersetSpec.hs
@@ -0,0 +1,42 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# OPTIONS_GHC -fwarn-unused-imports #-}
+
+-- | Verified backward compatibility of ASCII encoder changes in v0.3
+module Test.SupersetSpec where
+
+
+import           Data.TypedEncoding.Instances.Restriction.ASCII ()
+import           Data.TypedEncoding.Instances.Restriction.UTF8 ()
+import           Data.TypedEncoding.Instances.Restriction.D76 ()
+import           Data.TypedEncoding.Instances.Restriction.ByteRep ()
+import           Data.TypedEncoding.Instances.Enc.Base64 ()
+import qualified Data.TypedEncoding.Instances.Restriction.CHAR8 as CHAR8
+
+import           Data.TypedEncoding -- .Common.Class.Superset
+
+import           Test.QuickCheck.Instances.ByteString ()
+import qualified Data.ByteString as B
+import           Test.QuickCheck
+-- import           Test.QuickCheck.Property
+import           Test.Hspec
+
+
+spec :: Spec 
+spec =  
+    describe "Superset tests" $ do
+        describe "ByteString based" $ do
+            it "r-UTF8 > r-ASCII" $ property $ propSuperset_ @"r-UTF8" @"r-ASCII" @B.ByteString encoding encoding 
+            it "r-CHAR8 > r-ASCII" $ property $ propSuperset_ @"r-CHAR8" @"r-ASCII" @B.ByteString CHAR8.testEncCHAR8 encoding
+            it "r-CHAR8 > r-ByteRep" $ property $ propSuperset_ @"r-CHAR8" @"r-ByteRep" @B.ByteString CHAR8.testEncCHAR8 encoding
+        describe "String based" $ 
+            it "r-UNICODE.D76 > r-ASCII" $ property $ propSuperset_ @"r-UNICODE.D76" @"r-ASCII" @String encoding encoding
+        describe "EncodingSuperset test" $
+            it "enc-B64 < r-ASCII" $ property $ propEncodesInto_ @"enc-B64" @"r-ASCII" @B.ByteString encoding encoding
+runSpec :: IO ()
+runSpec = hspec spec   
diff --git a/typed-encoding.cabal b/typed-encoding.cabal
--- a/typed-encoding.cabal
+++ b/typed-encoding.cabal
@@ -4,10 +4,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 004e70cb6bb533b5bf1a14ddf696fa82800c2c9416d608734605d3e6103f521e
+-- hash: b0f10958b977104fdf20e2e9d875921fdf79c64e1c92b5243e8ed86b49519deb
 
 name:           typed-encoding
-version:        0.3.0.2
+version:        0.4.0.0
 synopsis:       Type safe string transformations
 description:    See README.md in the project github repository.
 category:       Data, Text
@@ -70,6 +70,9 @@
       Data.TypedEncoding.Instances.Restriction.ASCII
       Data.TypedEncoding.Instances.Restriction.Bool
       Data.TypedEncoding.Instances.Restriction.BoundedAlphaNums
+      Data.TypedEncoding.Instances.Restriction.ByteRep
+      Data.TypedEncoding.Instances.Restriction.CHAR8
+      Data.TypedEncoding.Instances.Restriction.D76
       Data.TypedEncoding.Instances.Restriction.Misc
       Data.TypedEncoding.Instances.Restriction.UTF8
       Data.TypedEncoding.Instances.Support
@@ -127,6 +130,7 @@
   other-modules:
       Test.Bc.IsStringRSpec
       Test.Bc.ASCIISpec
+      Test.SupersetSpec
   hs-source-dirs:
       test
   ghc-options: -threaded -rtsopts -with-rtsopts=-N