     }
 
     /// Adds a receiver that will return a receipt that simply removes itself from the list
-    @inlinable public func addReceipt(_ receptor: @escaping Receptor) -> Receipt {
+    public func addReceipt(_ receptor: @escaping Receptor) -> Receipt {
         let token = addReceiver(receptor)
         return ReceiptOf(canceler: { self.removeReceptor(token) })
     }
 
     /// Adds a custom receiver block and returns a token that can later be used to remove the receiver
-    @inlinable public func addReceiver(_ receptor: @escaping Receptor) -> Int64 {
+    public func addReceiver(_ receptor: @escaping Receptor) -> Int64 {
         precondition(entrancy.get() == 0, "cannot add to receivers while they are flowing")
         let index = receptorIndex.increment()
         receivers.append((index, receptor))
         return index
     }
 
-    @inlinable public func removeReceptor(_ index: Int64) {
+    public func removeReceptor(_ index: Int64) {
         receivers = receivers.filter { $0.index != index }
     }
 
     /// Clear all the receivers
-    @inlinable public func clear() {
+    public func clear() {
         receivers = []
     }
 }
 
 open class ReceiverQueueSource<T> {
-    @usableFromInline let receivers = ReceiverQueue<T>()
+    let receivers = ReceiverQueue<T>()
 }
 
 /// A Lock used for synchronizing access to the receiver queue
-public protocol Lock {
+protocol Lock {
     init()
     func lock()
     func unlock()

    public typealias Receptor = (T) -> ()
    public let maxdepth: Int

    @usableFromInline var receivers: ContiguousArray<(index: Int64, receptor: Receptor)> = []
    @usableFromInline let entrancy: Counter = 0
    @usableFromInline let receptorIndex: Counter = 0

    public var count: Int { return receivers.count }

    // os_unfair_lock would probably be faster (albeit unfair), but it seems to crash on forked processes (like when XCode unit tests in parallel; https://forums.developer.apple.com/thread/60622)
    // @usableFromInline let lock = UnfairLock()
    @usableFromInline let lock = ReentrantLock()

    @inlinable public init(maxdepth: Int? = nil) {
        self.maxdepth = maxdepth ?? ChannelZReentrancyLimit
    }

    @inlinable public func receive(_ element: T) {
        lock.lock()
        defer { lock.unlock() }


        assertSuccess(pthread_mutexattr_destroy(&mutexAttr))
    }

    func lock() {
        assertSuccess(pthread_mutex_lock(&self.mutex))
    }

    func unlock() {
        assertSuccess(pthread_mutex_unlock(&self.mutex))
    }

    func withLock<T>(_ f: () throws -> T) rethrows -> T {
        assertSuccess(pthread_mutex_lock(&self.mutex))
        defer { assertSuccess(pthread_mutex_unlock(&self.mutex)) }
        return try f()
    }

    func assertSuccess(_ f: @autoclosure () -> Int32) {
        let success = f()
        assert(success == 0, "critical error – pthread call failed \(success)")
    }
