                 return
             }
         }
-        self.lifecycleManager.activate(promise: promise)(self.pipeline)
+        self.lifecycleManager.activate()(promise, self.pipeline)
         self.readIfNeeded0()
     }
 }

    }

    private func badTransition(event: Event) -> Never {
        fatalError("illegal transition: state=\(self.currentState), event=\(event)")
    }

    @inline(__always) // we need to return a closure here and to not suffer from a potential allocation for that this must be inlined
    private mutating func doStateTransfer(newState: State, promise: EventLoopPromise<Void>?, _ callouts: @escaping (ChannelPipeline) -> Void) -> ((ChannelPipeline) -> Void) {
        self.currentState = newState

        return { pipeline in
            promise?.succeed(result: ())
            callouts(pipeline)
        }
    }

    // MARK: convenience properties


        // We always register with interested .none and will just trigger readIfNeeded0() later to re-register if needed.
        try self.safeRegister(interested: [.readEOF, .reset])
        self.lifecycleManager.finishRegistration()(nil, self.pipeline)
    }

    final func becomeActive0(promise: EventLoopPromise<Void>?) {
