         return result
     }
 
-    public init(timetag: OSCTimeTag, content: [OSCMessage]) {
+    public init(timetag: OSCTimeTag, content: [OSCConvertible]) {
         self.timetag = timetag
         self.content = content
     }


        self.timetag = ts

        var msgs = [OSCMessage]()

        // Read up the content
        // from offset
        var ix = 16
        while ix < bytes.count {
            guard
                let chunk_len = Int(data: bytes[ix..<(ix+4)]),
                ix+4+chunk_len < bytes.count,
                /// FIXME: any OSCConvertible might come here!
                let msg = OSCMessage(data: [Byte]( bytes[(ix+4)..<(ix+chunk_len+4)] ))
            else {
                break
            }

            msgs.append(msg)

            /// step to the start of the next chunk
            ix = ix+4+chunk_len
        }

        self.content = msgs
    }

}



/// Iterator that breaks down the byte stream
/// into small chunks containing OSC packets
struct ChunkIt : IteratorProtocol {
    let bytes : ArraySlice<Byte>
    var index : Int

    init(_ bytes: ArraySlice<Byte>) { self.bytes = bytes; index = bytes.startIndex }

    mutating func next() -> ArraySlice<Byte>? {
        if index < bytes.endIndex, let len = Int(data: bytes[index..<(index+4)]) {
            let d = bytes[(index+4)..<(index+4+len)]
            index = index+4+len
            return d
        } else {
            return nil
        }
    }
}



public struct OSCBundle : OSCConvertible {
    public let timetag : OSCTimeTag

    /// Bundle elements 
    public let content : [OSCConvertible]

    public var oscValue : [Byte] {
        var result = [Byte]()
