   }
 }
 
-public protocol _UTFEncoding : UnicodeEncoding {
+internal protocol _UTFEncoding : UnicodeEncoding {
   /// Returns true if `x` only appears in this encoding as the representation of
   /// a complete scalar value.
   static func _isScalar(_ x: CodeUnit) -> Bool
 }
 
-public protocol _UTFDecoder : UnicodeDecoder
+public protocol _UTFParser : UnicodeParser
 where Encoding : _UTFEncoding,
   Encoding.EncodedScalar == _UIntBuffer<_UInt32, Encoding.CodeUnit>,
   _UInt32 == UInt32 {
   associatedtype _UInt32 = UInt32
   
   func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8)
-  var buffer: Encoding.EncodedScalar { get set }
+  var _buffer: Encoding.EncodedScalar { get set }
   func _bufferedScalar(bitCount: UInt8) -> Encoding.EncodedScalar
 }
 
-extension _UTFDecoder
+extension _UTFParser
 where Encoding.EncodedScalar == _UIntBuffer<UInt32, Encoding.CodeUnit> {
   public mutating func parseScalar<I : IteratorProtocol>(
     from input: inout I

  check(expected, "legacy, repairing: true")
  do {
    var iterator = utfStr.makeIterator()
    let errorCount = Codec.ForwardDecoder.decode(
      &iterator, repairingIllFormedSequences: true, into: output1)
    
    if expectedRepairedTail.isEmpty { expectEqual(0, errorCount) }


public protocol _UnicodeEncoding : _UnicodeEncodingBase {

  associatedtype ForwardParser : UnicodeParser
  // where ForwardParser.Encoding == Self
  
  associatedtype ReverseParser : UnicodeParser
  // where ReverseParser.Encoding == Self
}

public protocol UnicodeEncoding : _UnicodeEncoding
where ForwardParser.Encoding == Self, ReverseParser.Encoding == Self {}

extension UnicodeParser {
  @inline(__always)
  @discardableResult
  public static func decode<I: IteratorProtocol>(
