Finished Dates and Tags, Fixed encoder and non-stdlib types

Sources/CBOR/Decoder/CBORDecoder.swift

···
                 }
 
                 let context = DecodingContext(scanner: scanner)
-                let region = scanner.load(at: 0)
+                let region = scanner.results.load(at: 0, reader: scanner.reader)
 
                 return try SingleValueCBORDecodingContainer(context: context, data: region).decode(T.self)
             }
···
                     + "found \(found) at \(offset)"
                 )
             )
+        case .noTagInformation, .invalidMajorTypeForTaggedItem:
+            throw error // rethrow these guys
         }
     }
 }

Sources/CBOR/Decoder/Containers/DataRegion.swift

···
         return F(val)
     }
 }
-
-internal extension UInt8 {
-    func byteCount() -> UInt8? {
-        switch self {
-        case let value where value < Constants.maxArgSize:
-            0
-        case 24:
-            1
-        case 25:
-            2
-        case 26:
-            4
-        case 27:
-            8
-        default:
-            nil
-        }
-    }
-}

Sources/CBOR/Decoder/Containers/DecodingContextContainer.swift

···
     @discardableResult
     func checkType<T>( _ types: MajorType..., arguments: UInt8..., as: T.Type) throws -> UInt8 {
         guard types.contains(data.type) else {
-            throw DecodingError.typeMismatch(Bool.self, context.error("Unexpected type found: \(data.type)."))
+            throw DecodingError.typeMismatch(T.self, context.error("Unexpected type found: \(data.type)."))
         }
 
         let argument = data.argument // Already checked with type()

Sources/CBOR/Decoder/Containers/KeyedCBORDecodingContainer.swift

···
         guard let childCount = data.childCount else { fatalError("Map scanned but no child count recorded.") }
         decodedKeys.reserveCapacity(childCount / 2)
 
-        var mapOffset = context.scanner.firstChildIndex(data.mapOffset)
+        var mapOffset = context.scanner.results.firstChildIndex(data.mapOffset)
         for _ in 0..<childCount / 2 {
-            let key = context.scanner.load(at: mapOffset)
+            let key = context.scanner.results.load(at: mapOffset, reader: context.scanner.reader)
             let decodedKey: AnyKey
             switch key.type {
             case .uint, .nint:
···
                     context.error("Invalid key type found in map. Found \(key.type), expected an integer or string.")
                 )
             }
-            mapOffset = context.scanner.siblingIndex(mapOffset)
+            mapOffset = context.scanner.results.siblingIndex(mapOffset)
 
-            let value = context.scanner.load(at: mapOffset)
-            mapOffset = context.scanner.siblingIndex(mapOffset)
+            let value = context.scanner.results.load(at: mapOffset, reader: context.scanner.reader)
+            mapOffset = context.scanner.results.siblingIndex(mapOffset)
 
             decodedKeys[decodedKey] = value
         }

Sources/CBOR/Decoder/Containers/SingleValueCBORDecodingContainer.swift

···
     }
 
     func decode(_: Float.Type) throws -> Float {
-        try checkType(.simple, arguments: 26, as: Float.self)
+        let arg = try checkType(.simple, arguments: 25, 26, as: Float.self)
+        if arg == 25 {
+            let floatRaw = try data.read(as: UInt16.self)
+            guard let value = Float(halfPrecision: floatRaw) else {
+                throw DecodingError.dataCorrupted(
+                    context.error("Could not decode half-precision float into Swift Float.")
+                )
+            }
+            return value
+        }
+
         let floatRaw = try data.read(as: UInt32.self)
         return Float(bitPattern: floatRaw)
     }
···
     }
 
     private func _decode(_: Date.Type) throws -> Date {
-        // Will pop this first byte.
         let argument = try checkType(.tagged, arguments: 0, 1, as: Date.self)
         if argument == 0 {
             // String
···
     }
 
     private func decodeStringDate() throws -> Date {
-        let string = try decode(String.self)
+        let taggedData = context.scanner.results.loadTagData(
+            tagMapIndex: data.mapOffset,
+            reader: context.scanner.reader
+        )
+        let string = try SingleValueCBORDecodingContainer(context: context, data: taggedData).decode(String.self)
         guard let date = ISO8601DateFormatter().date(from: string) else {
             throw DecodingError.dataCorrupted(context.error("Failed to decode date from \"\(string)\""))
         }
···
 
     private func decodeEpochDate() throws -> Date {
         // Epoch Timestamp, can be a floating point or positive/negative integer value
-        switch data.type {
-        case .uint:
-            let int = try data.readInt(as: UInt.self)
+        let taggedData = context.scanner.results.loadTagData(
+            tagMapIndex: data.mapOffset,
+            reader: context.scanner.reader
+        )
+        switch (taggedData.type, taggedData.argument) {
+        case (.uint, _):
+            let int = try taggedData.readInt(as: Int.self)
             return Date(timeIntervalSince1970: Double(int))
-        case .nint:
-            let int = -1 - (try data.readInt(as: Int.self))
+        case (.nint, _):
+            let int = -1 - (try taggedData.readInt(as: Int.self))
             return Date(timeIntervalSince1970: Double(int))
-        case .simple:
-            switch data.argument {
-            case 26:
-                // Float
-                let float = try decode(Float.self)
-                return Date(timeIntervalSince1970: Double(float))
-            case 27:
-                // Double
-                let double = try decode(Double.self)
-                return Date(timeIntervalSince1970: double)
-            default:
-                throw DecodingError.typeMismatch(
-                    Date.self,
-                    context.error("Could not find valid data type for Epoch Date.")
-                )
-            }
+        case (.simple, 25), (.simple, 26):
+            // Float
+            let float = try SingleValueCBORDecodingContainer(context: context, data: taggedData).decode(Float.self)
+            return Date(timeIntervalSince1970: Double(float))
+        case (.simple, 27):
+            // Double
+            let double = try SingleValueCBORDecodingContainer(context: context, data: taggedData).decode(Double.self)
+            return Date(timeIntervalSince1970: double)
         default:
             throw DecodingError.typeMismatch(
                 Date.self,
-                context.error("Could not find valid data type for Epoch Date.")
+                context.error("Invalid type found for epoch date: \(taggedData.type) at \(taggedData.globalIndex)")
             )
         }
     }
 
     private func _decode(_: UUID.Type) throws -> UUID {
         try checkType(.tagged, arguments: 24, as: UUID.self)
-        guard data.canRead(17) else { // UUID size + tag
-            throw DecodingError.valueNotFound(Bool.self, context.error("Unexpected end of data"))
+        let taggedData = context.scanner.results.loadTagData(
+            tagMapIndex: data.mapOffset,
+            reader: context.scanner.reader
+        )
+        let data = try SingleValueCBORDecodingContainer(context: context, data: taggedData).decode(Data.self)
+        guard data.count == 16 else { // UUID size + tag
+            throw DecodingError.dataCorruptedError(
+                in: self,
+                debugDescription: "Data decoded for UUID tag is not 16 bytes long."
+            )
         }
-        let data = data[1..<17]
         return data.withUnsafeBytes { ptr in ptr.load(as: UUID.self) }
     }
 

Sources/CBOR/Decoder/Containers/UnkeyedCBORDecodingContainer.swift

···
         try checkType(.array)
         guard let childCount = data.childCount else { fatalError("Array scanned but no child count recorded.") }
         self.count = childCount
-        self.currentMapIndex = context.scanner.firstChildIndex(data.mapOffset)
+        self.currentMapIndex = context.scanner.results.firstChildIndex(data.mapOffset)
     }
 
     /// Consumes one decoder off the scanned array.
     private mutating func consumeDecoder() throws -> SingleValueCBORDecodingContainer {
         defer {
             currentIndex += 1
-            currentMapIndex = context.scanner.siblingIndex(currentMapIndex)
+            currentMapIndex = context.scanner.results.siblingIndex(currentMapIndex)
         }
 
-        let region = context.scanner.load(at: currentMapIndex)
+        let region = context.scanner.results.load(at: currentMapIndex, reader: context.scanner.reader)
         return SingleValueCBORDecodingContainer(
             context: context.appending(UnkeyedCodingKey(intValue: currentIndex)),
             data: region
···
     }
 
     mutating func decodeNil() throws -> Bool {
-        context.scanner.load(at: currentMapIndex).isNil()
+        context.scanner.results.load(at: currentMapIndex, reader: context.scanner.reader).isNil()
     }
 
     mutating func decode<T: Decodable>(_ type: T.Type) throws -> T {

Sources/CBOR/Decoder/Scanner/CBORScanner+DebugDescription.swift

···
         func indent(_ other: String, d: Int) { string += String(repeating: " ", count: d * 2) + other + "\n" }
 
         func gen(_ idx: Int, depth: Int) {
-            let value = load(at: idx)
+            let value = results.load(at: idx, reader: reader)
             switch value.type {
             case .map, .array:
                 indent(
                     "\(value.type), mapIdx: \(value.mapOffset), children: \(value.childCount!), bytes: \(value.count)",
                     d: depth
                 )
-                var idx = firstChildIndex(idx)
+                var idx = results.firstChildIndex(idx)
                 for _ in 0..<value.childCount! {
                     gen(idx, depth: depth + 1)
-                    idx = siblingIndex(idx)
+                    idx = results.siblingIndex(idx)
                 }
             default:
                 indent("\(value.type), mapIdx: \(value.mapOffset), arg: \(value.argument)", d: depth)

Sources/CBOR/Decoder/Scanner/CBORScanner+Results.swift

···
+//
+//  ScanItem.swift
+//  CBOR
+//
+//  Created by Khan Winter on 9/1/25.
+//
+
+extension CBORScanner {
+    /// After the scanner scans, this contains a map that allows the CBOR data to be scanned for values at arbitrary
+    /// positions, keys, etc. The map contents are represented literally as ints for performance but uses the
+    /// following map:
+    /// ```
+    /// enum ScanItem: Int {
+    ///     case map // (childCount: Int, mapCount: Int, offset: Int, byteCount: Int)
+    ///     case array // (childCount: Int, mapCount: Int, offset: Int, byteCount: Int)
+    ///
+    ///     case int // (offset: Int, byteCount: Int)
+    ///     case string
+    ///     case byteString
+    ///     case simple // (offset: Int)
+    ///     case tagged
+    /// }
+    /// ```
+    struct Results {
+        var map: [Int] = []
+
+        init(dataCount: Int) {
+            self.map = []
+            map.reserveCapacity(dataCount * 4)
+        }
+
+        mutating func recordMapStart(currentByteIndex: Int) -> Int {
+            map.append(MajorType.map.intValue)
+            map.append(0)
+            map.append(map.count + 3)
+            map.append(currentByteIndex)
+            map.append(currentByteIndex)
+            return map.count - 5
+        }
+
+        mutating func recordArrayStart(currentByteIndex: Int) -> Int {
+            map.append(MajorType.array.intValue)
+            map.append(0) // child count
+            map.append(map.count + 3) // map count
+            map.append(currentByteIndex) // start byte
+            map.append(currentByteIndex) // byte count
+            return map.count - 5
+        }
+
+        mutating func recordEnd(childCount: Int, resultLocation: Int, currentByteIndex: Int) {
+            map[resultLocation + 1] = childCount
+            map[resultLocation + 2] = map.count - map[resultLocation + 2]
+            map[resultLocation + 4] = currentByteIndex - map[resultLocation + 4]
+        }
+
+        mutating func recordType(_ type: UInt8, currentByteIndex: Int, length: Int) {
+            map.append(Int(type))
+            map.append(currentByteIndex)
+            map.append(length)
+        }
+
+        mutating func recordSimple(_ type: UInt8, currentByteIndex: Int) {
+            map.append(Int(type))
+            map.append(currentByteIndex)
+        }
+
+        // MARK: - Load Values
+
+        func load(at mapIndex: Int, reader: DataReader) -> DataRegion {
+            assert(mapIndex < map.count)
+            let byte = UInt8(map[mapIndex])
+            let argument = byte & 0b1_1111
+            guard let type = MajorType(rawValue: byte) else {
+                fatalError("Invalid type found in map: \(map[mapIndex]) at index: \(mapIndex)")
+            }
+            switch type {
+            case .uint, .nint, .bytes, .string, .tagged:
+                assert(mapIndex + 1 < map.count)
+                let location = map[mapIndex + 1]
+                let length = map[mapIndex + 2]
+                let slice = reader.slice(location..<(location + length))
+                return DataRegion(type: type, argument: argument, childCount: nil, mapOffset: mapIndex, data: slice)
+            case .simple:
+                let length = UInt8(map[mapIndex]).simpleLength()
+                let slice: Slice<UnsafeRawBufferPointer>
+                if length == 0 {
+                    slice = reader.slice(0..<0)
+                } else {
+                    let location = map[mapIndex + 1] + 1 // skip type & arg byte.
+                    slice = reader.slice(location..<(location + length))
+                }
+                return DataRegion(type: type, argument: argument, childCount: nil, mapOffset: mapIndex, data: slice)
+            case .array, .map:
+                // Map determines the slice size
+                let childCount = map[mapIndex + 1]
+                let location = map[mapIndex + 3]
+                let length = map[mapIndex + 4]
+                let slice = reader.slice(location..<(location + length))
+                return DataRegion(type: type, argument: argument, childCount: childCount, mapOffset: mapIndex, data: slice)
+            }
+        }
+
+        // MARK: - Map Navigation
+
+        func firstChildIndex(_ mapIndex: Int) -> Int {
+            let byte = UInt8(map[mapIndex])
+            guard let type = MajorType(rawValue: byte) else {
+                fatalError("Invalid type found in map: \(map[mapIndex]) at index: \(mapIndex)")
+            }
+            switch type {
+            case .uint, .nint, .bytes, .string, .tagged, .simple:
+                fatalError("Can't find child index for non-container type.")
+            case .array, .map: // type byte + 4 map values
+                return mapIndex + 5
+            }
+        }
+
+        func siblingIndex(_ mapIndex: Int) -> Int {
+            let byte = UInt8(map[mapIndex])
+            guard let type = MajorType(rawValue: byte) else {
+                fatalError("Invalid type found in map: \(map[mapIndex]) at index: \(mapIndex)")
+            }
+            switch type {
+            case .uint, .nint, .bytes, .string:
+                return mapIndex + 3
+            case .simple:
+                return mapIndex + 2
+            case .array, .map: // Map contains the map/array count
+                return mapIndex + 5 + map[mapIndex + 2]
+            case .tagged:
+                // Find the next index after the scanned data for the tagged item.
+                return siblingIndex(mapIndex + 3)
+            }
+        }
+
+        func loadTagData(tagMapIndex mapIndex: Int, reader: DataReader) -> DataRegion {
+            return load(at: mapIndex + 3, reader: reader)
+        }
+    }
+}

Sources/CBOR/Decoder/Scanner/CBORScanner.swift

···
     case typeInIndeterminateString(type: MajorType, offset: Int)
     case rejectedIndeterminateLength(type: MajorType, offset: Int)
     case cannotRepresentInt(max: UInt, found: UInt, offset: Int)
+    case noTagInformation(tag: UInt, offset: Int)
+    case invalidMajorTypeForTaggedItem(tag: UInt, expected: Set<MajorType>, found: MajorType, offset: Int)
 }
 
 /// # Why Scan?
···
 ///   take either indeterminate or specific lengths and decode them.
 @usableFromInline
 final class CBORScanner {
-    // MARK: - Results
-
-    /// After the scanner scans, this contains a map that allows the CBOR data to be scanned for values at arbitrary
-    /// positions, keys, etc. The map contents are represented literally as ints for performance but uses the
-    /// following map:
-    /// ```
-    /// enum ScanItem: Int {
-    ///     case map // (childCount: Int, mapCount: Int, offset: Int, byteCount: Int)
-    ///     case array // (childCount: Int, mapCount: Int, offset: Int, byteCount: Int)
-    ///
-    ///     case int // (offset: Int, byteCount: Int)
-    ///     case string
-    ///     case byteString
-    ///     case tagged
-    ///     case simple (byteCount: Int)
-    /// }
-    /// ```
-    struct Results {
-        var map: [Int] = []
-
-        init(dataCount: Int) {
-            self.map = []
-            map.reserveCapacity(dataCount * 4)
-        }
-
-        mutating func recordMapStart(currentByteIndex: Int) -> Int {
-            map.append(MajorType.map.intValue)
-            map.append(0)
-            map.append(map.count + 3)
-            map.append(currentByteIndex)
-            map.append(currentByteIndex)
-            return map.count - 5
-        }
-
-        mutating func recordArrayStart(currentByteIndex: Int) -> Int {
-            map.append(MajorType.array.intValue)
-            map.append(0) // child count
-            map.append(map.count + 3) // map count
-            map.append(currentByteIndex) // start byte
-            map.append(currentByteIndex) // byte count
-            return map.count - 5
-        }
-
-        mutating func recordEnd(childCount: Int, resultLocation: Int, currentByteIndex: Int) {
-            map[resultLocation + 1] = childCount
-            map[resultLocation + 2] = map.count - map[resultLocation + 2]
-            map[resultLocation + 4] = currentByteIndex - map[resultLocation + 4]
-        }
-
-        mutating func recordType(_ type: UInt8, currentByteIndex: Int, length: Int) {
-            map.append(Int(type))
-            map.append(currentByteIndex)
-            map.append(length)
-        }
-
-        mutating func recordSimple(_ type: UInt8, currentByteIndex: Int) {
-            map.append(Int(type))
-            map.append(currentByteIndex)
-        }
-    }
-
     var reader: DataReader
     var results: Results
     let options: DecodingOptions
+
+    let taggedScanMap: [UInt: Set<MajorType>] = [
+        0: [.string],               // Date (string)
+        1: [.uint, .nint, .simple], // Date (epoch)
+        37: [.bytes],               // UUID
+    ]
 
     var isEmpty: Bool {
         results.map.isEmpty
···
         self.options = options
     }
 
-    // MARK: - Load Values
-
-    func load(at mapIndex: Int) -> DataRegion {
-        assert(mapIndex < results.map.count)
-        let byte = UInt8(results.map[mapIndex])
-        let argument = byte & 0b1_1111
-        guard let type = MajorType(rawValue: byte) else {
-            fatalError("Invalid type found in map: \(results.map[mapIndex]) at index: \(mapIndex)")
-        }
-        switch type {
-        case .uint, .nint, .bytes, .string, .tagged:
-            assert(mapIndex + 1 < results.map.count)
-            let location = results.map[mapIndex + 1]
-            let length = results.map[mapIndex + 2]
-            let slice = reader.slice(location..<(location + length))
-            return DataRegion(type: type, argument: argument, childCount: nil, mapOffset: mapIndex, data: slice)
-        case .simple:
-            let length = simpleLength(UInt8(results.map[mapIndex]))
-            let slice: Slice<UnsafeRawBufferPointer>
-            if length == 0 {
-                slice = reader.slice(0..<0)
-            } else {
-                let location = results.map[mapIndex + 1] + 1 // skip type & arg byte.
-                slice = reader.slice(location..<(location + length))
-            }
-            return DataRegion(type: type, argument: argument, childCount: nil, mapOffset: mapIndex, data: slice)
-        case .array, .map:
-            // Map determines the slice size
-            let childCount = results.map[mapIndex + 1]
-            let location = results.map[mapIndex + 3]
-            let length = results.map[mapIndex + 4]
-            let slice = reader.slice(location..<(location + length))
-            return DataRegion(type: type, argument: argument, childCount: childCount, mapOffset: mapIndex, data: slice)
-        }
-    }
-
-    // MARK: - Map Navigation
-
-    func firstChildIndex(_ mapIndex: Int) -> Int {
-        let byte = UInt8(results.map[mapIndex])
-        guard let type = MajorType(rawValue: byte) else {
-            fatalError("Invalid type found in map: \(results.map[mapIndex]) at index: \(mapIndex)")
-        }
-        switch type {
-        case .uint, .nint, .bytes, .string, .tagged, .simple:
-            fatalError("Can't find child index for non-container type.")
-        case .array, .map: // type byte + 4 map values
-            return mapIndex + 5
-        }
-    }
-
-    func siblingIndex(_ mapIndex: Int) -> Int {
-        let byte = UInt8(results.map[mapIndex])
-        guard let type = MajorType(rawValue: byte) else {
-            fatalError("Invalid type found in map: \(results.map[mapIndex]) at index: \(mapIndex)")
-        }
-        switch type {
-        case .uint, .nint, .bytes, .string, .tagged:
-            return mapIndex + 3
-        case .simple:
-            return mapIndex + 2
-        case .array, .map: // Map contains the map/array count
-            return mapIndex + 5 + results.map[mapIndex + 2]
-        }
-    }
-
     // MARK: - Scan
 
     func scan() throws {
···
             }
         }
 
+        try scanType(type: type, raw: raw)
+    }
+
+    private func scanType(type: MajorType, raw: UInt8) throws {
         switch type {
         case .uint, .nint:
             try scanInt(raw: raw)
         case .bytes:
-            try scanBytesOrString(.bytes)
+            try scanBytesOrString(.bytes, raw: raw)
         case .string:
-            try scanBytesOrString(.string)
+            try scanBytesOrString(.string, raw: raw)
         case .array:
             try scanArray()
         case .map:
···
         case .simple:
             try scanSimple(raw: raw)
         case .tagged:
-            throw ScanError.expectedMajorType(offset: 0)
+            try scanTagged(raw: raw)
         }
     }
 
···
     private func scanSimple(raw: UInt8) throws {
         let idx = reader.index
         results.recordSimple(reader.pop(), currentByteIndex: idx)
-        guard reader.canRead(simpleLength(raw)) else {
+        guard reader.canRead(raw.simpleLength()) else {
             throw ScanError.unexpectedEndOfData
         }
-        reader.pop(simpleLength(raw))
-    }
-
-    private func simpleLength(_ arg: UInt8) -> Int {
-        switch arg & 0b11111 {
-        case 25:
-            2 // Half-float
-        case 26:
-            4 // Float
-        case 27:
-            8 // Double
-        default:
-            0 // Just this byte.
-        }
+        reader.pop(raw.simpleLength())
     }
 
     // MARK: - Scan String/Bytes
 
-    private func scanBytesOrString(_ type: MajorType) throws {
-        let raw = reader._peek() // already checked previously
-
+    private func scanBytesOrString(_ type: MajorType, raw: UInt8) throws {
         guard peekIsIndeterminate() else {
             let size = try reader.readNextInt(as: Int.self)
             let offset = reader.index
···
         // Pop the break byte
         reader.pop()
         results.recordEnd(childCount: count, resultLocation: mapIdx, currentByteIndex: reader.index)
+    }
+
+    private func scanTagged(raw: UInt8) throws {
+        guard let size = reader.peekArgument()?.byteCount() else {
+            throw ScanError.invalidSize(byte: reader.peekArgument() ?? .max, offset: reader.index)
+        }
+        let offset = reader.index
+        results.recordType(raw, currentByteIndex: offset, length: Int(size))
+
+        let tag = try reader.readNextInt(as: UInt.self)
+
+        guard let validMajorTypes = taggedScanMap[tag] else {
+            throw ScanError.noTagInformation(tag: tag, offset: reader.index)
+        }
+
+        guard let nextRaw = reader.peek(), let nextTag = MajorType(rawValue: nextRaw) else {
+            throw ScanError.unexpectedEndOfData
+        }
+
+        guard validMajorTypes.contains(nextTag) else {
+            throw ScanError.invalidMajorTypeForTaggedItem(
+                tag: tag,
+                expected: validMajorTypes,
+                found: nextTag,
+                offset: offset
+            )
+        }
+
+        try scanType(type: nextTag, raw: nextRaw)
     }
 }

Sources/CBOR/Encoder/CBOREncoder.swift

···
     /// Create a new CBOR encoder.
     /// - Parameters:
     ///   - forceStringKeys: See ``EncodingOptions/forceStringKeys``.
-    ///   - useStringDates: See ``EncodingOptions/useStringDates``.
+    ///   - dateEncodingStrategy: See ``EncodingOptions/dateEncodingStrategy``.
     ///   - assumeUInt8IsByteString: See ``EncodingOptions/assumeUInt8IsByteString``.
-    public init(forceStringKeys: Bool = false, useStringDates: Bool = false, assumeUInt8IsByteString: Bool = true) {
+    public init(
+        forceStringKeys: Bool = false,
+        dateEncodingStrategy: EncodingOptions.DateStrategy = .double,
+        assumeUInt8IsByteString: Bool = true
+    ) {
         options = EncodingOptions(
             forceStringKeys: forceStringKeys,
-            useStringDates: useStringDates,
+            dateEncodingStrategy: dateEncodingStrategy,
             assumeUInt8IsByteString: assumeUInt8IsByteString
         )
     }
···
 
         let encodingContext = EncodingContext(options: options)
         let encoder = SingleValueCBOREncodingContainer(parent: tempStorage, context: encodingContext)
-        try value.encode(to: encoder)
+        try encoder.encode(value)
 
         let dataSize = tempStorage.value.size
         var data = Data(count: dataSize)
         data.withUnsafeMutableBytes { ptr in
             var slice = ptr[...]
             tempStorage.value.write(to: &slice)
-            assert(slice.isEmpty)
-        }
-        return data
-    }
-
-    /// Returns a CBOR-encoded representation of the value you supply.
-    /// - Note: This method is identical to ``encode(_:)-6zhmp``. This is a fast path included due to the lack of
-    ///         ability to specialize Codable containers for specific types, such as byte strings.
-    /// - Parameter value: The value to encode as CBOR data.
-    /// - Returns: The encoded CBOR data.
-    public func encode(_ value: Data) throws -> Data {
-        // Fast path for plain data objects. See comments in ``UnkekedCBOREncodingContainer`` for why this can't be done
-        // via the real Codable APIs. Hate that we have to 'cheat' like this to get the performance I'd like for
-        // byte strings. >:(
-
-        var optimizer = ByteStringOptimizer(value: value)
-        let dataSize = optimizer.size
-        var data = Data(count: dataSize)
-        data.withUnsafeMutableBytes { ptr in
-            var slice = ptr[...]
-            optimizer.write(to: &slice)
             assert(slice.isEmpty)
         }
         return data

Sources/CBOR/Encoder/Containers/KeyedCBOREncodingContainer.swift

···
     }
 
     func encode<T>(_ value: T, forKey key: Key) throws where T: Encodable {
-        try value.encode(to: encoder(for: key))
+        try encoder(for: key).encode(value)
     }
 
     mutating func encodeNil(forKey key: Key) throws {

Sources/CBOR/Encoder/Containers/SingleValueCBOREncodingContainer.swift

···
         // special encoding cases. It's still lame.
 
         if let date = value as? Date {
-            if options.useStringDates {
+            switch options.dateEncodingStrategy {
+            case .string:
                 parent.register(StringDateOptimizer(value: date))
-            } else {
-                parent.register(EpochDateOptimizer(value: date))
+            case .float:
+                parent.register(EpochFloatDateOptimizer(value: date))
+            case .double:
+                parent.register(EpochDoubleDateOptimizer(value: date))
             }
         } else if let uuid = value as? UUID {
             parent.register(UUIDOptimizer(value: uuid))

Sources/CBOR/Encoder/Containers/UnkeyedCBOREncodingContainer.swift

···
     }
 
     func encode<T: Encodable>(_ value: T) throws {
-        try value.encode(
-            to: SingleValueCBOREncodingContainer(parent: storage.forAppending(), context: nextContext())
-        )
-    }
-
-    func encode(_ value: UInt8) throws {
-        storage.data.append(value)
-        if !context.options.assumeUInt8IsByteString {
-            try value.encode(
-                to: SingleValueCBOREncodingContainer(parent: storage.forAppending(), context: nextContext())
-            )
-        }
+        try SingleValueCBOREncodingContainer(parent: storage.forAppending(), context: nextContext()).encode(value)
     }
 
     mutating func encodeNil() throws {
···
 
         let parent: ParentStorage
         var items: [EncodingOptimizer] = []
-        var data: [UInt8] = []
 
         init(parent: ParentStorage) {
             self.parent = parent
···
         }
 
         deinit {
-            // Swift doesn't give us a good way to detect a 'byte string'. So, we record both UInt8 values and
-            // some optimizers. At this point, we can check if we're encoding either a collection of multiple
-            // types (items.count > data.count), or a pure data collection (data.count == items.count).
-            // This is terrible in terms of memory use, but lets us encode byte strings using the most optimal
-            // encoding method.
-            // CBOR also mandates that an empty collection is by default an array, so we check if this is empty.
-            // Frankly, this blows and I wish Swift's Codable API was even a smidgen less fucked.
-
-            if items.count <= data.count && !data.isEmpty {
-                parent.register(ByteStringOptimizer(value: data))
-            } else {
-                parent.register(UnkeyedOptimizer(value: items))
-            }
+            parent.register(UnkeyedOptimizer(value: items))
         }
     }
 

Sources/CBOR/Encoder/EncodingOptions.swift

···
 public struct EncodingOptions {
     /// Force encoded maps to use string keys even when integer keys are available.
     public let forceStringKeys: Bool
+    
+    /// Methods for encoding dates.
+    public enum DateStrategy {
+        /// Encodes dates as `ISO8601` date strings under tag `0`.
+        case string
+        /// Encodes dates as an epoch date using a Float value. Loses precision at the benefit of half the size
+        /// of a double.
+        case float
+        /// Encodes dates as an epoch date using a Double value.
+        /// Highest precision.
+        case double
+    }
 
-    /// Encode dates as strings instead of epoch timestamps (Doubles)
-    public let useStringDates: Bool
+    /// Determine how to encode dates.
+    public let dateEncodingStrategy: DateStrategy
 
     /// Codable can't tell us if we're encoding a Data or [UInt8] object. By default this library assumes that if it's
     /// encoding an unkeyed container or UInt8 objects it's a byte string. Toggle this to false to disable this.
···
     /// Initialize new encoding options.
     /// - Parameters:
     ///   - forceStringKeys: Force encoded maps to use string keys even when integer keys are available.
-    ///   - useStringDates: Encode dates as strings instead of epoch timestamps (Doubles)
+    ///   - useStringDates: See ``dateEncodingStrategy`` and ``DateStrategy``.
     ///   - assumeUInt8IsByteString: See ``assumeUInt8IsByteString``.
-    public init(forceStringKeys: Bool, useStringDates: Bool, assumeUInt8IsByteString: Bool) {
+    public init(forceStringKeys: Bool, dateEncodingStrategy: DateStrategy, assumeUInt8IsByteString: Bool) {
         self.forceStringKeys = forceStringKeys
-        self.useStringDates = useStringDates
+        self.dateEncodingStrategy = dateEncodingStrategy
         self.assumeUInt8IsByteString = assumeUInt8IsByteString
     }
 }

Sources/CBOR/Encoder/Optimizers/DateOptimizer.swift

···
     }
 }
 
-struct EpochDateOptimizer: EncodingOptimizer {
+struct EpochDoubleDateOptimizer: EncodingOptimizer {
     var optimizer: DoubleOptimizer
 
     var type: MajorType { .tagged }
···
         optimizer.write(to: &data)
     }
 }
+
+struct EpochFloatDateOptimizer: EncodingOptimizer {
+    var optimizer: FloatOptimizer
+
+    var type: MajorType { .tagged }
+    var argument: UInt8 { 1 }
+    var contentSize: Int { optimizer.size }
+
+    init(value: Date) {
+        optimizer = FloatOptimizer(value: Float(value.timeIntervalSince1970))
+    }
+
+    mutating func writePayload(to data: inout Slice<UnsafeMutableRawBufferPointer>) {
+        optimizer.write(to: &data)
+    }
+}

Sources/CBOR/Extensions/Float32+Float16.swift Sources/CBOR/Extensions/Float/Float+Float16.swift

···
 //
-//  Float32+Float16.swift
-//  SwiftCBOR
+//  Float+Float16.swift
+//  CBOR
 //
 //  Created by Khan Winter on 8/17/25.
 //
 
-extension Float32 {
+// Copied with modifications from: https://github.com/valpackett/SwiftCBOR
+
+extension Float {
     // https://gist.github.com/martinkallman/5049614
     // rewritten to Swift + applied fixes from comments + added NaN/Inf checks
     // should be good enough, who cares about float16
     @inlinable
-    static func readFloat16(x: UInt16) -> Float32 {
+    init?(halfPrecision x: UInt16) {
         if (x & 0x7fff) > 0x7c00 {
-            return Float32.nan
+            self = .nan
         }
         if x == 0x7c00 {
-            return Float32.infinity
+            self = .infinity
         }
         if x == 0xfc00 {
-            return -Float32.infinity
+            self = -.infinity
         }
         var t1 = UInt32(x & 0x7fff)        // Non-sign bits
         var t2 = UInt32(x & 0x8000)        // Sign bit
···
         t1 += 0x38000000                   // Adjust bias
         t1 = (t3 == 0 ? 0 : t1)            // Denormals-as-zero
         t1 |= t2                           // Re-insert sign bit
-        return Float32(bitPattern: t1)
+        self = Float(bitPattern: t1)
     }
 }

Sources/CBOR/Extensions/UInt8/UInt8+byteCount.swift

···
+//
+//  UInt8+byteCount.swift
+//  CBOR
+//
+//  Created by Khan Winter on 9/1/25.
+//
+
+internal extension UInt8 {
+    func byteCount() -> UInt8? {
+        switch self {
+        case let value where value < Constants.maxArgSize:
+            0
+        case 24:
+            1
+        case 25:
+            2
+        case 26:
+            4
+        case 27:
+            8
+        default:
+            nil
+        }
+    }
+}

Sources/CBOR/Extensions/UInt8/UInt8+simpleLength.swift

···
+//
+//  UInt8+simpleLength.swift
+//  CBOR
+//
+//  Created by Khan Winter on 9/1/25.
+//
+
+extension UInt8 {
+    @inlinable
+    func simpleLength() -> Int {
+        switch self & 0b11111 {
+        case 25:
+            2 // Half-float
+        case 26:
+            4 // Float
+        case 27:
+            8 // Double
+        default:
+            0 // Just this byte.
+        }
+    }
+}

Sources/CBOR/MajorType.swift

···
 //  Created by Khan Winter on 8/17/25.
 //
 
-@usableFromInline
-enum MajorType: UInt8, Sendable, Hashable, Equatable {
+/// Represents a major type as described by the CBOR specification.
+@frozen public enum MajorType: UInt8, Sendable, Hashable, Equatable {
     case uint = 0
     case nint = 1
     case bytes = 2
···
     case tagged = 6
     case simple = 7
 
+    /// Create a major type using a raw integer (only uses the highest 3 bits).
     @inline(__always)
-    @usableFromInline
-    init?(rawValue: UInt8) {
+    public init?(rawValue: UInt8) {
         // We only care about the top 3 bits
         switch rawValue >> 5 {
         case MajorType.uint.rawValue: self = .uint
···
     }
 
     @inline(__always)
-    @inlinable var bits: UInt8 {
+    var bits: UInt8 {
         rawValue << 5
     }
 
+    @inline(__always)
     var intValue: Int {
         Int(bits)
     }

Tests/CBORTests/DecodableTests.swift

···
             let context = DecodingContext(scanner: scanner)
             let container = SingleValueCBORDecodingContainer(
                 context: context,
-                data: scanner.load(at: 0)
+                data: scanner.results.load(at: 0, reader: scanner.reader)
             )
 
             var unkeyedContainer = try container.unkeyedContainer()
···
     func emptyData() throws {
         let data = Data()
         #expect(throws: DecodingError.self) { try CBORDecoder().decode(Data.self, from: data) }
+    }
+
+    @Test
+    func date() throws {
+        let data = "C11A5C295C00".asHexData()
+        let expected = Date(timeIntervalSince1970: 1546214400.0)
+        let value = try CBORDecoder().decode(Date.self, from: data)
+        #expect(value == expected)
     }
 }

Tests/CBORTests/RoundTripTests.swift

···
             #expect(first.name == Person.mock.name)
         }
     }
+
+    @Test
+    func dateEpoch() throws {
+        let value = Date()
+        let encoded = try CBOREncoder().encode(value)
+        let decoded = try CBORDecoder().decode(Date.self, from: encoded)
+        #expect(decoded.timeIntervalSince1970.rounded(.down) == value.timeIntervalSince1970.rounded(.down))
+    }
+
+    @Test
+    func dateString() throws {
+        let value = Date()
+        let encoded = try CBOREncoder(dateEncodingStrategy: .string).encode(value)
+        let decoded = try CBORDecoder().decode(Date.self, from: encoded)
+        #expect(decoded.timeIntervalSince1970.rounded(.down) == value.timeIntervalSince1970.rounded(.down))
+    }
+
+    @Test
+    func uuid() throws {
+        let value = UUID()
+        let encoded = try CBOREncoder().encode(value)
+        let decoded = try CBORDecoder().decode(UUID.self, from: encoded)
+        #expect(decoded == value)
+    }
 }

Tests/CBORTests/ScannerTests.swift

···
             let map = scanner.results.map
             #expect(map == [Int(MajorType.uint.bits | argument), 1, byteCount])
 
-            #expect(scanner.load(at: 0).type == .uint)
-            #expect(scanner.load(at: 0).argument == argument)
-            #expect(scanner.load(at: 0).count == byteCount)
+            #expect(scanner.results.load(at: 0, reader: scanner.reader).type == .uint)
+            #expect(scanner.results.load(at: 0, reader: scanner.reader).argument == argument)
+            #expect(scanner.results.load(at: 0, reader: scanner.reader).count == byteCount)
         }
     }