     //    return etch
     // }
     
-    internal func withUnwrap(unwrap: (ImpulseType -> AnyObject?)?) -> Etch {
+    public func withUnwrap(unwrap: (ImpulseType -> AnyObject?)?) -> Etch {
         var etch = self
         etch.unwrap = unwrap
         return etch
     }
     
-    internal func withQueue(queue: dispatch_queue_t?) -> Etch {
+    public func withQueue(queue: dispatch_queue_t?) -> Etch {
         var etch = self
         etch.queue = queue
         return etch
     }
     
-    internal func withDispatch(dispatch: (AnyObject -> [ImpulseType]?)) -> Etch {
+    public func withDispatch(dispatch: (AnyObject -> [ImpulseType]?)) -> Etch {
         var etch = self
         etch.dispatch = dispatch
         return etch
     }
 }
 
-extension Etch {
-    func withAliveHost(host: AnyObject) -> Etch {
-        return self.withAlive { [weak host] in host == nil }
+public extension Etch {
+    public func withAliveHost(host: AnyObject) -> Etch {
+        return self.withAlive { [weak host] in host != nil }
     }
 }
 
 extension Etch: Equatable {}
-func ==<T: Impulse>(lhs: Etch<T>, rhs: Etch<T>) -> Bool {
+public func ==<T: Impulse>(lhs: Etch<T>, rhs: Etch<T>) -> Bool {
     return lhs.id == rhs.id
 }
 
 /// A message. Intended to be an enum type.
-protocol Impulse { } // "Event"
+public protocol Impulse { } // "Event"
 
 infix operator <++ { associativity right precedence 93 }
-func <++<ImpulseType: Impulse>(lhs: Circuit<ImpulseType>, rhs: Etch<ImpulseType>) {
+public func <++<ImpulseType: Impulse>(lhs: Circuit<ImpulseType>, rhs: Etch<ImpulseType>) {
     lhs.addEtch(rhs)
 }
    }
}

struct Etch<ImpulseType: Impulse> { // "Observer"
    /// A unique identifier for this Etch. For supporting equatable.
    private let id = NSUUID()
    

    /// The code to run in response to a matching Impulse.
    private(set) internal var dispatch: (AnyObject -> [ImpulseType]?) = { _ in nil }
    
    public init() { }
    
    public func withAlive(block: (() -> Bool)) -> Etch {
        var etch = self
        etch.alive = block
        return etch
