ominfra 0.0.0.dev128__py3-none-any.whl → 0.0.0.dev130__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -3,7 +3,7 @@
 # @omlish-lite
 # @omlish-script
 # @omlish-amalg-output ../supervisor/main.py
-# ruff: noqa: N802 UP006 UP007 UP012 UP036
+# ruff: noqa: N802 U006 UP006 UP007 UP012 UP036
 # Supervisor is licensed under the following license:
 #
 #  A copyright notice accompanies this license document that identifies the copyright holders.
@@ -102,6 +102,9 @@ V = ta.TypeVar('V')
 # ../../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 
+# ../../../omlish/lite/check.py
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+
 # ../../../omlish/lite/socket.py
 SocketAddress = ta.Any
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
@@ -1494,11 +1497,257 @@ def check_not_equal(l: T, r: T) -> T:
     return l
 
 
+def check_is(l: T, r: T) -> T:
+    if l is not r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_is_not(l: T, r: ta.Any) -> T:
+    if l is r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_in(v: T, c: ta.Container[T]) -> T:
+    if v not in c:
+        raise ValueError(v, c)
+    return v
+
+
+def check_not_in(v: T, c: ta.Container[T]) -> T:
+    if v in c:
+        raise ValueError(v, c)
+    return v
+
+
 def check_single(vs: ta.Iterable[T]) -> T:
     [v] = vs
     return v
 
 
+def check_empty(v: SizedT) -> SizedT:
+    if len(v):
+        raise ValueError(v)
+    return v
+
+
+def check_non_empty(v: SizedT) -> SizedT:
+    if not len(v):
+        raise ValueError(v)
+    return v
+
+
+########################################
+# ../../../omlish/lite/fdio/pollers.py
+
+
+##
+
+
+class FdIoPoller(abc.ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._readable: ta.Set[int] = set()
+        self._writable: ta.Set[int] = set()
+
+    #
+
+    def close(self) -> None:  # noqa
+        pass
+
+    def reopen(self) -> None:  # noqa
+        pass
+
+    #
+
+    @property
+    @ta.final
+    def readable(self) -> ta.AbstractSet[int]:
+        return self._readable
+
+    @property
+    @ta.final
+    def writable(self) -> ta.AbstractSet[int]:
+        return self._writable
+
+    #
+
+    @ta.final
+    def register_readable(self, fd: int) -> bool:
+        if fd in self._readable:
+            return False
+        self._readable.add(fd)
+        self._register_readable(fd)
+        return True
+
+    @ta.final
+    def register_writable(self, fd: int) -> bool:
+        if fd in self._writable:
+            return False
+        self._writable.add(fd)
+        self._register_writable(fd)
+        return True
+
+    @ta.final
+    def unregister_readable(self, fd: int) -> bool:
+        if fd not in self._readable:
+            return False
+        self._readable.discard(fd)
+        self._unregister_readable(fd)
+        return True
+
+    @ta.final
+    def unregister_writable(self, fd: int) -> bool:
+        if fd not in self._writable:
+            return False
+        self._writable.discard(fd)
+        self._unregister_writable(fd)
+        return True
+
+    #
+
+    def _register_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _register_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    #
+
+    def update(
+            self,
+            r: ta.AbstractSet[int],
+            w: ta.AbstractSet[int],
+    ) -> None:
+        for f in r - self._readable:
+            self.register_readable(f)
+        for f in w - self._writable:
+            self.register_writable(f)
+        for f in self._readable - r:
+            self.unregister_readable(f)
+        for f in self._writable - w:
+            self.unregister_writable(f)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class PollResult:
+        r: ta.Sequence[int] = ()
+        w: ta.Sequence[int] = ()
+
+        inv: ta.Sequence[int] = ()
+
+        msg: ta.Optional[str] = None
+        exc: ta.Optional[BaseException] = None
+
+    @abc.abstractmethod
+    def poll(self, timeout: ta.Optional[float]) -> PollResult:
+        raise NotImplementedError
+
+
+##
+
+
+class SelectFdIoPoller(FdIoPoller):
+    def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+        try:
+            r, w, x = select.select(
+                self._readable,
+                self._writable,
+                [],
+                timeout,
+            )
+
+        except OSError as exc:
+            if exc.errno == errno.EINTR:
+                return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+            elif exc.errno == errno.EBADF:
+                return FdIoPoller.PollResult(msg='EBADF encountered in poll', exc=exc)
+            else:
+                raise
+
+        return FdIoPoller.PollResult(r, w)
+
+
+##
+
+
+PollFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+if hasattr(select, 'poll'):
+
+    class _PollFdIoPoller(FdIoPoller):
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._poller = select.poll()
+
+        #
+
+        _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
+        _WRITE = select.POLLOUT
+
+        def _register_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _register_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _update_registration(self, fd: int) -> None:
+            r = fd in self._readable
+            w = fd in self._writable
+            if r or w:
+                self._poller.register(fd, (self._READ if r else 0) | (self._WRITE if w else 0))
+            else:
+                self._poller.unregister(fd)
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+            polled: ta.List[ta.Tuple[int, int]]
+            try:
+                polled = self._poller.poll(timeout * 1000 if timeout is not None else None)
+
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
+
+            r: ta.List[int] = []
+            w: ta.List[int] = []
+            inv: ta.List[int] = []
+            for fd, mask in polled:
+                if mask & select.POLLNVAL:
+                    self._poller.unregister(fd)
+                    self._readable.discard(fd)
+                    self._writable.discard(fd)
+                    inv.append(fd)
+                    continue
+                if mask & self._READ:
+                    r.append(fd)
+                if mask & self._WRITE:
+                    w.append(fd)
+            return FdIoPoller.PollResult(r, w, inv=inv)
+
+    PollFdIoPoller = _PollFdIoPoller
+else:
+    PollFdIoPoller = None
+
+
 ########################################
 # ../../../omlish/lite/http/versions.py
 
@@ -1718,6 +1967,73 @@ class SocketHandler(abc.ABC):
         raise NotImplementedError
 
 
+########################################
+# ../../../omlish/lite/strings.py
+
+
+##
+
+
+def camel_case(name: str, lower: bool = False) -> str:
+    if not name:
+        return ''
+    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
+    if lower:
+        s = s[0].lower() + s[1:]
+    return s
+
+
+def snake_case(name: str) -> str:
+    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
+
+
+##
+
+
+def is_dunder(name: str) -> bool:
+    return (
+        name[:2] == name[-2:] == '__' and
+        name[2:3] != '_' and
+        name[-3:-2] != '_' and
+        len(name) > 4
+    )
+
+
+def is_sunder(name: str) -> bool:
+    return (
+        name[0] == name[-1] == '_' and
+        name[1:2] != '_' and
+        name[-2:-1] != '_' and
+        len(name) > 2
+    )
+
+
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str) -> str:
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
+
+
+##
+
+
+FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
+
+
+def format_num_bytes(num_bytes: int) -> str:
+    for i, suffix in enumerate(FORMAT_NUM_BYTES_SUFFIXES):
+        value = num_bytes / 1024 ** i
+        if num_bytes < 1024 ** (i + 1):
+            if value.is_integer():
+                return f'{int(value)}{suffix}'
+            else:
+                return f'{value:.2f}{suffix}'
+
+    return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
+
+
 ########################################
 # ../../../omlish/lite/typing.py
 
@@ -2203,82 +2519,245 @@ def get_user(name: str) -> User:
 
 
 ########################################
-# ../../../omlish/lite/http/parsing.py
-# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
-# --------------------------------------------
-#
-# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
-# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
-# documentation.
-#
-# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
-# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
-# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
-# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
-# alone or in any derivative version prepared by Licensee.
-#
-# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
-# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
-# any such work a brief summary of the changes made to Python.
-#
-# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
-# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
-# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
-# RIGHTS.
-#
-# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
-# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
-# ADVISED OF THE POSSIBILITY THEREOF.
-#
-# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
-#
-# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
-# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
-# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
-#
-# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
-# License Agreement.
+# ../../../omlish/lite/fdio/handlers.py
 
 
-##
+class FdIoHandler(abc.ABC):
+    @abc.abstractmethod
+    def fd(self) -> int:
+        raise NotImplementedError
 
+    #
 
-class ParseHttpRequestResult(abc.ABC):  # noqa
-    __slots__ = (
-        'server_version',
-        'request_line',
-        'request_version',
-        'version',
-        'headers',
-        'close_connection',
-    )
+    @property
+    @abc.abstractmethod
+    def closed(self) -> bool:
+        raise NotImplementedError
 
-    def __init__(
-            self,
-            *,
-            server_version: HttpProtocolVersion,
-            request_line: str,
-            request_version: HttpProtocolVersion,
-            version: HttpProtocolVersion,
-            headers: ta.Optional[HttpHeaders],
-            close_connection: bool,
-    ) -> None:
-        super().__init__()
+    @abc.abstractmethod
+    def close(self) -> None:
+        raise NotImplementedError
 
-        self.server_version = server_version
-        self.request_line = request_line
-        self.request_version = request_version
-        self.version = version
-        self.headers = headers
-        self.close_connection = close_connection
+    #
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
+    def readable(self) -> bool:
+        return False
 
+    def writable(self) -> bool:
+        return False
 
-class EmptyParsedHttpResult(ParseHttpRequestResult):
-    pass
+    #
+
+    def on_readable(self) -> None:
+        raise TypeError
+
+    def on_writable(self) -> None:
+        raise TypeError
+
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
+        pass
+
+
+class SocketFdIoHandler(FdIoHandler, abc.ABC):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+    ) -> None:
+        super().__init__()
+
+        self._addr = addr
+        self._sock: ta.Optional[socket.socket] = sock
+
+    def fd(self) -> int:
+        return check_not_none(self._sock).fileno()
+
+    @property
+    def closed(self) -> bool:
+        return self._sock is None
+
+    def close(self) -> None:
+        if self._sock is not None:
+            self._sock.close()
+        self._sock = None
+
+
+########################################
+# ../../../omlish/lite/fdio/kqueue.py
+
+
+KqueueFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+
+    class _KqueueFdIoPoller(FdIoPoller):
+        DEFAULT_MAX_EVENTS = 1000
+
+        def __init__(
+                self,
+                *,
+                max_events: int = DEFAULT_MAX_EVENTS,
+        ) -> None:
+            super().__init__()
+
+            self._max_events = max_events
+
+            self._kqueue: ta.Optional[ta.Any] = None
+
+        #
+
+        def _get_kqueue(self) -> 'select.kqueue':
+            if (kq := self._kqueue) is not None:
+                return kq
+            kq = select.kqueue()
+            self._kqueue = kq
+            return kq
+
+        def close(self) -> None:
+            if self._kqueue is not None:
+                self._kqueue.close()
+                self._kqueue = None
+
+        def reopen(self) -> None:
+            for fd in self._readable:
+                self._register_readable(fd)
+            for fd in self._writable:
+                self._register_writable(fd)
+
+        #
+
+        def _register_readable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_ADD)
+
+        def _register_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_ADD)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_DELETE)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_DELETE)
+
+        def _control(self, fd: int, filter: int, flags: int) -> None:  # noqa
+            ke = select.kevent(fd, filter=filter, flags=flags)
+            kq = self._get_kqueue()
+            try:
+                kq.control([ke], 0)
+
+            except OSError as exc:
+                if exc.errno == errno.EBADF:
+                    # log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', ke.ident)
+                    pass
+                elif exc.errno == errno.ENOENT:
+                    # Can happen when trying to remove an already closed socket
+                    pass
+                else:
+                    raise
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+            kq = self._get_kqueue()
+            try:
+                kes = kq.control(None, self._max_events, timeout)
+
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
+
+            r: ta.List[int] = []
+            w: ta.List[int] = []
+            for ke in kes:
+                if ke.filter == select.KQ_FILTER_READ:
+                    r.append(ke.ident)
+                if ke.filter == select.KQ_FILTER_WRITE:
+                    w.append(ke.ident)
+
+            return FdIoPoller.PollResult(r, w)
+
+    KqueueFdIoPoller = _KqueueFdIoPoller
+else:
+    KqueueFdIoPoller = None
+
+
+########################################
+# ../../../omlish/lite/http/parsing.py
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+
+
+##
+
+
+class ParseHttpRequestResult(abc.ABC):  # noqa
+    __slots__ = (
+        'server_version',
+        'request_line',
+        'request_version',
+        'version',
+        'headers',
+        'close_connection',
+    )
+
+    def __init__(
+            self,
+            *,
+            server_version: HttpProtocolVersion,
+            request_line: str,
+            request_version: HttpProtocolVersion,
+            version: HttpProtocolVersion,
+            headers: ta.Optional[HttpHeaders],
+            close_connection: bool,
+    ) -> None:
+        super().__init__()
+
+        self.server_version = server_version
+        self.request_line = request_line
+        self.request_version = request_version
+        self.version = version
+        self.headers = headers
+        self.close_connection = close_connection
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
+
+
+class EmptyParsedHttpResult(ParseHttpRequestResult):
+    pass
 
 
 class ParseHttpRequestError(ParseHttpRequestResult):
@@ -2703,7 +3182,7 @@ class InjectorError(Exception):
     pass
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class InjectorKeyError(InjectorError):
     key: InjectorKey
 
@@ -2711,16 +3190,18 @@ class InjectorKeyError(InjectorError):
     name: ta.Optional[str] = None
 
 
-@dc.dataclass(frozen=True)
 class UnboundInjectorKeyError(InjectorKeyError):
     pass
 
 
-@dc.dataclass(frozen=True)
 class DuplicateInjectorKeyError(InjectorKeyError):
     pass
 
 
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
+
+
 ###
 # keys
 
@@ -2894,7 +3375,11 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 
     for b in bs.bindings():
         if b.key.array:
-            am.setdefault(b.key, []).append(b.provider)
+            al = am.setdefault(b.key, [])
+            if isinstance(b.provider, ArrayInjectorProvider):
+                al.extend(b.provider.ps)
+            else:
+                al.append(b.provider)
         else:
             if b.key in pm:
                 raise KeyError(b.key)
@@ -3042,6 +3527,14 @@ def build_injection_kwargs_target(
 _INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
 
 
+@dc.dataclass(frozen=True)
+class _InjectorEager:
+    key: InjectorKey
+
+
+_INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEager, array=True)
+
+
 class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
@@ -3054,22 +3547,69 @@ class _Injector(Injector):
         if _INJECTOR_INJECTOR_KEY in self._pfm:
             raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
+        self.__cur_req: ta.Optional[_Injector._Request] = None
+
+        if _INJECTOR_EAGER_ARRAY_KEY in self._pfm:
+            for e in self.provide(_INJECTOR_EAGER_ARRAY_KEY):
+                self.provide(e.key)
+
+    class _Request:
+        def __init__(self, injector: '_Injector') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: ta.Dict[InjectorKey, Maybe] = {}
+            self._seen_keys: ta.Set[InjectorKey] = set()
+
+        def handle_key(self, key: InjectorKey) -> Maybe[Maybe]:
+            try:
+                return Maybe.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyInjectorKeyError(key)
+            self._seen_keys.add(key)
+            return Maybe.empty()
+
+        def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
+            check_in(key, self._seen_keys)
+            check_not_in(key, self._provisions)
+            self._provisions[key] = mv
+            return mv
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        cr = self._Request(self)
+        try:
+            self.__cur_req = cr
+            yield cr
+        finally:
+            self.__cur_req = None
+
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         key = as_injector_key(key)
 
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
+        cr: _Injector._Request
+        with self._current_request() as cr:
+            if (rv := cr.handle_key(key)).present:
+                return rv.must()
 
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
+            if key == _INJECTOR_INJECTOR_KEY:
+                return cr.handle_provision(key, Maybe.just(self))
 
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
+            fn = self._pfm.get(key)
+            if fn is not None:
+                return cr.handle_provision(key, Maybe.just(fn(self)))
 
-        return Maybe.empty()
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return cr.handle_provision(key, Maybe.empty())
+
+            return cr.handle_provision(key, Maybe.empty())
 
     def provide(self, key: ta.Any) -> ta.Any:
         v = self.try_provide(key)
@@ -3170,6 +3710,8 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
@@ -3243,13 +3785,21 @@ class InjectorBinder:
         if singleton:
             provider = SingletonInjectorProvider(provider)
 
+        binding = InjectorBinding(key, provider)
+
         ##
 
-        binding = InjectorBinding(key, provider)
+        extras: ta.List[InjectorBinding] = []
+
+        if eager:
+            extras.append(bind_injector_eager_key(key))
 
         ##
 
-        return binding
+        if extras:
+            return as_injector_bindings(binding, *extras)
+        else:
+            return binding
 
 
 ###
@@ -3272,6 +3822,26 @@ def make_injector_factory(
     return outer
 
 
+def bind_injector_array(
+        obj: ta.Any = None,
+        *,
+        tag: ta.Any = None,
+) -> InjectorBindingOrBindings:
+    key = as_injector_key(obj)
+    if tag is not None:
+        if key.tag is not None:
+            raise ValueError('Must not specify multiple tags')
+        key = dc.replace(key, tag=tag)
+
+    if key.array:
+        raise ValueError('Key must not be array')
+
+    return InjectorBinding(
+        dc.replace(key, array=True),
+        ArrayInjectorProvider([]),
+    )
+
+
 def make_injector_array_type(
         ele: ta.Union[InjectorKey, InjectorKeyCls],
         cls: U,
@@ -3293,6 +3863,10 @@ def make_injector_array_type(
     return inner
 
 
+def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
+    return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
+
+
 ##
 
 
@@ -3347,6 +3921,8 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
@@ -3361,6 +3937,8 @@ class Injection:
             to_key=to_key,
 
             singleton=singleton,
+
+            eager=eager,
         )
 
     # helpers
@@ -3374,6 +3952,15 @@ class Injection:
     ) -> InjectorBindingOrBindings:
         return cls.bind(make_injector_factory(fn, cls_, ann))
 
+    @classmethod
+    def bind_array(
+            cls,
+            obj: ta.Any = None,
+            *,
+            tag: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return bind_injector_array(obj, tag=tag)
+
     @classmethod
     def bind_array_type(
             cls,
@@ -3388,81 +3975,303 @@ inj = Injection
 
 
 ########################################
-# ../../../omlish/lite/journald.py
+# ../../../omlish/lite/io.py
 
 
-##
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
 
+    #
 
-class sd_iovec(ct.Structure):  # noqa
-    pass
+    class Error(Exception):
+        def __init__(self, buffer: 'DelimitingBuffer') -> None:
+            super().__init__(buffer)
+            self.buffer = buffer
 
+        def __repr__(self) -> str:
+            return attr_repr(self, 'buffer')
 
-sd_iovec._fields_ = [
-    ('iov_base', ct.c_void_p),  # Pointer to data.
-    ('iov_len', ct.c_size_t),  # Length of data.
-]
+    class ClosedError(Error):
+        pass
 
+    #
 
-##
+    DEFAULT_DELIMITERS: bytes = b'\n'
 
+    def __init__(
+            self,
+            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
+            *,
+            keep_ends: bool = False,
+            max_size: ta.Optional[int] = None,
+    ) -> None:
+        super().__init__()
 
-@cached_nullary
-def sd_libsystemd() -> ta.Any:
-    lib = ct.CDLL('libsystemd.so.0')
+        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
+        self._keep_ends = keep_ends
+        self._max_size = max_size
 
-    lib.sd_journal_sendv.restype = ct.c_int
-    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
 
-    return lib
+    #
 
+    @property
+    def is_closed(self) -> bool:
+        return self._buf is None
+
+    def tell(self) -> int:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.tell()
+
+    def peek(self) -> bytes:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.getvalue()
+
+    def _find_delim(self, data: ta.Union[bytes, bytearray], i: int) -> ta.Optional[int]:
+        r = None  # type: int | None
+        for d in self._delimiters:
+            if (p := data.find(d, i)) >= 0:
+                if r is None or p < r:
+                    r = p
+        return r
+
+    def _append_and_reset(self, chunk: bytes) -> bytes:
+        buf = check_not_none(self._buf)
+        if not buf.tell():
+            return chunk
+
+        buf.write(chunk)
+        ret = buf.getvalue()
+        buf.seek(0)
+        buf.truncate()
+        return ret
 
-@cached_nullary
-def sd_try_libsystemd() -> ta.Optional[ta.Any]:
-    try:
-        return sd_libsystemd()
-    except OSError:  # noqa
-        return None
+    class Incomplete(ta.NamedTuple):
+        b: bytes
 
+    def feed(self, data: ta.Union[bytes, bytearray]) -> ta.Generator[ta.Union[bytes, Incomplete], None, None]:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
 
-##
+        if not data:
+            self._buf = None
 
+            if buf.tell():
+                yield self.Incomplete(buf.getvalue())
 
-def sd_journald_send(**fields: str) -> int:
-    lib = sd_libsystemd()
+            return
 
-    msgs = [
-        f'{k.upper()}={v}\0'.encode('utf-8')
-        for k, v in fields.items()
-    ]
+        l = len(data)
+        i = 0
+        while i < l:
+            if (p := self._find_delim(data, i)) is None:
+                break
 
-    vec = (sd_iovec * len(msgs))()
-    cl = (ct.c_char_p * len(msgs))()  # noqa
-    for i in range(len(msgs)):
-        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
-        vec[i].iov_len = len(msgs[i]) - 1
+            n = p + 1
+            if self._keep_ends:
+                p = n
 
-    return lib.sd_journal_sendv(vec, len(msgs))
+            yield self._append_and_reset(data[i:p])
 
+            i = n
 
-##
+        if i >= l:
+            return
 
+        if self._max_size is None:
+            buf.write(data[i:])
+            return
 
-SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
-    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
-    # LOG_ALERT ?  # action must be taken immediately
-    logging.CRITICAL: syslog.LOG_CRIT,
-    logging.ERROR: syslog.LOG_ERR,
-    logging.WARNING: syslog.LOG_WARNING,
-    # LOG_NOTICE ?  # normal but significant condition
-    logging.INFO: syslog.LOG_INFO,
-    logging.DEBUG: syslog.LOG_DEBUG,
-}
+        while i < l:
+            remaining_data_len = l - i
+            remaining_buf_capacity = self._max_size - buf.tell()
 
+            if remaining_data_len < remaining_buf_capacity:
+                buf.write(data[i:])
+                return
 
-class JournaldLogHandler(logging.Handler):
-    """
-    TODO:
+            p = i + remaining_buf_capacity
+            yield self.Incomplete(self._append_and_reset(data[i:p]))
+            i = p
+
+
+class ReadableListBuffer:
+    def __init__(self) -> None:
+        super().__init__()
+        self._lst: list[bytes] = []
+
+    def feed(self, d: bytes) -> None:
+        if d:
+            self._lst.append(d)
+
+    def _chop(self, i: int, e: int) -> bytes:
+        lst = self._lst
+        d = lst[i]
+
+        o = b''.join([
+            *lst[:i],
+            d[:e],
+        ])
+
+        self._lst = [
+            *([d[e:]] if e < len(d) else []),
+            *lst[i + 1:],
+        ]
+
+        return o
+
+    def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
+        if n is None:
+            o = b''.join(self._lst)
+            self._lst = []
+            return o
+
+        if not (lst := self._lst):
+            return None
+
+        c = 0
+        for i, d in enumerate(lst):
+            r = n - c
+            if (l := len(d)) >= r:
+                return self._chop(i, r)
+            c += l
+
+        return None
+
+    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
+        if not (lst := self._lst):
+            return None
+
+        for i, d in enumerate(lst):
+            if (p := d.find(delim)) >= 0:
+                return self._chop(i, p + len(delim))
+
+        return None
+
+
+class IncrementalWriteBuffer:
+    def __init__(
+            self,
+            data: bytes,
+            *,
+            write_size: int = 0x10000,
+    ) -> None:
+        super().__init__()
+
+        check_non_empty(data)
+        self._len = len(data)
+        self._write_size = write_size
+
+        self._lst = [
+            data[i:i + write_size]
+            for i in range(0, len(data), write_size)
+        ]
+        self._pos = 0
+
+    @property
+    def rem(self) -> int:
+        return self._len - self._pos
+
+    def write(self, fn: ta.Callable[[bytes], int]) -> int:
+        lst = check_non_empty(self._lst)
+
+        t = 0
+        for i, d in enumerate(lst):  # noqa
+            n = fn(check_non_empty(d))
+            if not n:
+                break
+            t += n
+
+        if t:
+            self._lst = [
+                *([d[n:]] if n < len(d) else []),
+                *lst[i + 1:],
+            ]
+            self._pos += t
+
+        return t
+
+
+########################################
+# ../../../omlish/lite/journald.py
+
+
+##
+
+
+class sd_iovec(ct.Structure):  # noqa
+    pass
+
+
+sd_iovec._fields_ = [
+    ('iov_base', ct.c_void_p),  # Pointer to data.
+    ('iov_len', ct.c_size_t),  # Length of data.
+]
+
+
+##
+
+
+@cached_nullary
+def sd_libsystemd() -> ta.Any:
+    lib = ct.CDLL('libsystemd.so.0')
+
+    lib.sd_journal_sendv.restype = ct.c_int
+    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+
+    return lib
+
+
+@cached_nullary
+def sd_try_libsystemd() -> ta.Optional[ta.Any]:
+    try:
+        return sd_libsystemd()
+    except OSError:  # noqa
+        return None
+
+
+##
+
+
+def sd_journald_send(**fields: str) -> int:
+    lib = sd_libsystemd()
+
+    msgs = [
+        f'{k.upper()}={v}\0'.encode('utf-8')
+        for k, v in fields.items()
+    ]
+
+    vec = (sd_iovec * len(msgs))()
+    cl = (ct.c_char_p * len(msgs))()  # noqa
+    for i in range(len(msgs)):
+        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
+        vec[i].iov_len = len(msgs[i]) - 1
+
+    return lib.sd_journal_sendv(vec, len(msgs))
+
+
+##
+
+
+SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
+    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
+    # LOG_ALERT ?  # action must be taken immediately
+    logging.CRITICAL: syslog.LOG_CRIT,
+    logging.ERROR: syslog.LOG_ERR,
+    logging.WARNING: syslog.LOG_WARNING,
+    # LOG_NOTICE ?  # normal but significant condition
+    logging.INFO: syslog.LOG_INFO,
+    logging.DEBUG: syslog.LOG_DEBUG,
+}
+
+
+class JournaldLogHandler(logging.Handler):
+    """
+    TODO:
      - fallback handler for when this barfs
     """
 
@@ -4158,6 +4967,23 @@ def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
     return get_obj_marshaler(ty).unmarshal(o)
 
 
+########################################
+# ../../../omlish/lite/runtime.py
+
+
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+
+
+REQUIRED_PYTHON_VERSION = (3, 8)
+
+
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
 ########################################
 # ../../configs.py
 
@@ -4510,239 +5336,6 @@ def parse_logging_level(value: ta.Union[str, int]) -> int:
     return level
 
 
-########################################
-# ../poller.py
-
-
-class Poller(DaemonizeListener, abc.ABC):
-    def __init__(self) -> None:
-        super().__init__()
-
-    @abc.abstractmethod
-    def register_readable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def register_writable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_readable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_writable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-        raise NotImplementedError
-
-    def before_daemonize(self) -> None:  # noqa
-        pass
-
-    def after_daemonize(self) -> None:  # noqa
-        pass
-
-    def close(self) -> None:  # noqa
-        pass
-
-
-class SelectPoller(Poller):
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._readable: ta.Set[Fd] = set()
-        self._writable: ta.Set[Fd] = set()
-
-    def register_readable(self, fd: Fd) -> None:
-        self._readable.add(fd)
-
-    def register_writable(self, fd: Fd) -> None:
-        self._writable.add(fd)
-
-    def unregister_readable(self, fd: Fd) -> None:
-        self._readable.discard(fd)
-
-    def unregister_writable(self, fd: Fd) -> None:
-        self._writable.discard(fd)
-
-    def unregister_all(self) -> None:
-        self._readable.clear()
-        self._writable.clear()
-
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-        try:
-            r, w, x = select.select(
-                self._readable,
-                self._writable,
-                [], timeout,
-            )
-        except OSError as exc:
-            if exc.args[0] == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return [], []
-            if exc.args[0] == errno.EBADF:
-                log.debug('EBADF encountered in poll')
-                self.unregister_all()
-                return [], []
-            raise
-        return r, w
-
-
-class PollPoller(Poller):
-    _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
-    _WRITE = select.POLLOUT
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._poller = select.poll()
-        self._readable: set[Fd] = set()
-        self._writable: set[Fd] = set()
-
-    def register_readable(self, fd: Fd) -> None:
-        self._poller.register(fd, self._READ)
-        self._readable.add(fd)
-
-    def register_writable(self, fd: Fd) -> None:
-        self._poller.register(fd, self._WRITE)
-        self._writable.add(fd)
-
-    def unregister_readable(self, fd: Fd) -> None:
-        self._readable.discard(fd)
-        self._poller.unregister(fd)
-        if fd in self._writable:
-            self._poller.register(fd, self._WRITE)
-
-    def unregister_writable(self, fd: Fd) -> None:
-        self._writable.discard(fd)
-        self._poller.unregister(fd)
-        if fd in self._readable:
-            self._poller.register(fd, self._READ)
-
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-        fds = self._poll_fds(timeout)  # type: ignore
-        readable, writable = [], []
-        for fd, eventmask in fds:
-            if self._ignore_invalid(fd, eventmask):
-                continue
-            if eventmask & self._READ:
-                readable.append(fd)
-            if eventmask & self._WRITE:
-                writable.append(fd)
-        return readable, writable
-
-    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[Fd, Fd]]:
-        try:
-            return self._poller.poll(timeout * 1000)  # type: ignore
-        except OSError as exc:
-            if exc.args[0] == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return []
-            raise
-
-    def _ignore_invalid(self, fd: Fd, eventmask: int) -> bool:
-        if eventmask & select.POLLNVAL:
-            # POLLNVAL means `fd` value is invalid, not open. When a process quits it's `fd`s are closed so there is no
-            # more reason to keep this `fd` registered If the process restarts it's `fd`s are registered again.
-            self._poller.unregister(fd)
-            self._readable.discard(fd)
-            self._writable.discard(fd)
-            return True
-        return False
-
-
-if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
-    class KqueuePoller(Poller):
-        max_events = 1000
-
-        def __init__(self) -> None:
-            super().__init__()
-
-            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-            self._readable: set[Fd] = set()
-            self._writable: set[Fd] = set()
-
-        def register_readable(self, fd: Fd) -> None:
-            self._readable.add(fd)
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
-            self._kqueue_control(fd, kevent)
-
-        def register_writable(self, fd: Fd) -> None:
-            self._writable.add(fd)
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
-            self._kqueue_control(fd, kevent)
-
-        def unregister_readable(self, fd: Fd) -> None:
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
-            self._readable.discard(fd)
-            self._kqueue_control(fd, kevent)
-
-        def unregister_writable(self, fd: Fd) -> None:
-            kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
-            self._writable.discard(fd)
-            self._kqueue_control(fd, kevent)
-
-        def _kqueue_control(self, fd: Fd, kevent: 'select.kevent') -> None:
-            try:
-                self._kqueue.control([kevent], 0)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EBADF:
-                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
-                else:
-                    raise
-
-        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-            readable, writable = [], []  # type: ignore
-
-            try:
-                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EINTR:
-                    log.debug('EINTR encountered in poll')
-                    return readable, writable
-                raise
-
-            for kevent in kevents:
-                if kevent.filter == select.KQ_FILTER_READ:
-                    readable.append(kevent.ident)
-                if kevent.filter == select.KQ_FILTER_WRITE:
-                    writable.append(kevent.ident)
-
-            return readable, writable
-
-        def before_daemonize(self) -> None:
-            self.close()
-
-        def after_daemonize(self) -> None:
-            self._kqueue = select.kqueue()
-            for fd in self._readable:
-                self.register_readable(fd)
-            for fd in self._writable:
-                self.register_writable(fd)
-
-        def close(self) -> None:
-            self._kqueue.close()  # type: ignore
-            self._kqueue = None
-
-else:
-    KqueuePoller = None
-
-
-def get_poller_impl() -> ta.Type[Poller]:
-    if (
-            (sys.platform == 'darwin' or sys.platform.startswith('freebsd')) and
-            hasattr(select, 'kqueue') and
-            KqueuePoller is not None
-    ):
-        return KqueuePoller
-    elif hasattr(select, 'poll'):
-        return PollPoller
-    else:
-        return SelectPoller
-
-
 ########################################
 # ../../../omlish/lite/http/coroserver.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -5310,6 +5903,10 @@ class CoroHttpServerSocketHandler(SocketHandler):
 ##
 
 
+class ExitNow(Exception):  # noqa
+    pass
+
+
 ServerEpoch = ta.NewType('ServerEpoch', int)
 
 
@@ -5333,12 +5930,7 @@ class ConfigPriorityOrdered(abc.ABC):
 ##
 
 
-class ServerContext(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def config(self) -> ServerConfig:
-        raise NotImplementedError
-
+class SupervisorStateManager(abc.ABC):
     @property
     @abc.abstractmethod
     def state(self) -> SupervisorState:
@@ -5352,12 +5944,13 @@ class ServerContext(abc.ABC):
 ##
 
 
-class Dispatcher(abc.ABC):
-    @property
+class HasDispatchers(abc.ABC):
     @abc.abstractmethod
-    def process(self) -> 'Process':
+    def get_dispatchers(self) -> 'Dispatchers':
         raise NotImplementedError
 
+
+class ProcessDispatcher(FdIoHandler, abc.ABC):
     @property
     @abc.abstractmethod
     def channel(self) -> str:
@@ -5365,44 +5958,11 @@ class Dispatcher(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def fd(self) -> Fd:
+    def process(self) -> 'Process':
         raise NotImplementedError
 
-    @property
-    @abc.abstractmethod
-    def closed(self) -> bool:
-        raise NotImplementedError
-
-    #
-
-    @abc.abstractmethod
-    def close(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def handle_error(self) -> None:
-        raise NotImplementedError
-
-    #
-
-    @abc.abstractmethod
-    def readable(self) -> bool:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def writable(self) -> bool:
-        raise NotImplementedError
-
-    #
 
-    def handle_read_event(self) -> None:
-        raise TypeError
-
-    def handle_write_event(self) -> None:
-        raise TypeError
-
-
-class OutputDispatcher(Dispatcher, abc.ABC):
+class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def remove_logs(self) -> None:
         raise NotImplementedError
@@ -5412,7 +5972,7 @@ class OutputDispatcher(Dispatcher, abc.ABC):
         raise NotImplementedError
 
 
-class InputDispatcher(Dispatcher, abc.ABC):
+class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def write(self, chars: ta.Union[bytes, str]) -> None:
         raise NotImplementedError
@@ -5425,7 +5985,11 @@ class InputDispatcher(Dispatcher, abc.ABC):
 ##
 
 
-class Process(ConfigPriorityOrdered, abc.ABC):
+class Process(
+    ConfigPriorityOrdered,
+    HasDispatchers,
+    abc.ABC,
+):
     @property
     @abc.abstractmethod
     def name(self) -> str:
@@ -5448,11 +6012,6 @@ class Process(ConfigPriorityOrdered, abc.ABC):
 
     #
 
-    @property
-    @abc.abstractmethod
-    def context(self) -> ServerContext:
-        raise NotImplementedError
-
     @abc.abstractmethod
     def finish(self, sts: Rc) -> None:
         raise NotImplementedError
@@ -5469,18 +6028,15 @@ class Process(ConfigPriorityOrdered, abc.ABC):
     def transition(self) -> None:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def get_state(self) -> ProcessState:
+    def state(self) -> ProcessState:
         raise NotImplementedError
 
     @abc.abstractmethod
     def after_setuid(self) -> None:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def get_dispatchers(self) -> 'Dispatchers':
-        raise NotImplementedError
-
 
 ##
 
@@ -5521,81 +6077,138 @@ class ProcessGroup(
 
 
 ########################################
-# ../context.py
+# ../../../omlish/lite/fdio/corohttp.py
 
 
-class ServerContextImpl(ServerContext):
+class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
     def __init__(
             self,
-            config: ServerConfig,
-            poller: Poller,
+            addr: SocketAddress,
+            sock: socket.socket,
+            handler: HttpHandler,
             *,
-            epoch: ServerEpoch = ServerEpoch(0),
+            read_size: int = 0x10000,
+            write_size: int = 0x10000,
     ) -> None:
-        super().__init__()
+        check_state(not sock.getblocking())
 
-        self._config = config
-        self._poller = poller
-        self._epoch = epoch
+        super().__init__(addr, sock)
 
-        self._state: SupervisorState = SupervisorState.RUNNING
+        self._handler = handler
+        self._read_size = read_size
+        self._write_size = write_size
 
-    @property
-    def config(self) -> ServerConfig:
-        return self._config
+        self._read_buf = ReadableListBuffer()
+        self._write_buf: IncrementalWriteBuffer | None = None
 
-    @property
-    def epoch(self) -> ServerEpoch:
-        return self._epoch
+        self._coro_srv = CoroHttpServer(
+            addr,
+            handler=self._handler,
+        )
+        self._srv_coro: ta.Optional[ta.Generator[CoroHttpServer.Io, ta.Optional[bytes], None]] = self._coro_srv.coro_handle()  # noqa
 
-    @property
-    def first(self) -> bool:
-        return not self._epoch
+        self._cur_io: CoroHttpServer.Io | None = None
+        self._next_io()
 
-    @property
-    def state(self) -> SupervisorState:
-        return self._state
+    #
 
-    def set_state(self, state: SupervisorState) -> None:
-        self._state = state
+    def _next_io(self) -> None:  # noqa
+        coro = check_not_none(self._srv_coro)
+
+        d: bytes | None = None
+        o = self._cur_io
+        while True:
+            if o is None:
+                try:
+                    if d is not None:
+                        o = coro.send(d)
+                        d = None
+                    else:
+                        o = next(coro)
+                except StopIteration:
+                    self.close()
+                    o = None
+                    break
+
+            if isinstance(o, CoroHttpServer.AnyLogIo):
+                print(o)
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadIo):
+                if (d := self._read_buf.read(o.sz)) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadLineIo):
+                if (d := self._read_buf.read_until(b'\n')) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.WriteIo):
+                check_none(self._write_buf)
+                self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
+                break
+
+            else:
+                raise TypeError(o)
+
+        self._cur_io = o
+
+    #
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return self._write_buf is not None
 
     #
 
-    def waitpid(self) -> ta.Tuple[ta.Optional[Pid], ta.Optional[Rc]]:
-        # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
-        # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
-        # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
-        # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
-        # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
-        # lying around.
+    def on_readable(self) -> None:
         try:
-            pid, sts = os.waitpid(-1, os.WNOHANG)
-        except OSError as exc:
-            code = exc.args[0]
-            if code not in (errno.ECHILD, errno.EINTR):
-                log.critical('waitpid error %r; a process may not be cleaned up properly', code)
-            if code == errno.EINTR:
-                log.debug('EINTR during reap')
-            pid, sts = None, None
-        return pid, sts  # type: ignore
-
-    def get_auto_child_log_name(self, name: str, identifier: str, channel: str) -> str:
-        prefix = f'{name}-{channel}---{identifier}-'
-        logfile = mktempfile(
-            suffix='.log',
-            prefix=prefix,
-            dir=self.config.child_logdir,
-        )
-        return logfile
+            buf = check_not_none(self._sock).recv(self._read_size)
+        except BlockingIOError:
+            return
+        except ConnectionResetError:
+            self.close()
+            return
+        if not buf:
+            self.close()
+            return
+
+        self._read_buf.feed(buf)
+
+        if isinstance(self._cur_io, CoroHttpServer.AnyReadIo):
+            self._next_io()
+
+    def on_writable(self) -> None:
+        check_isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        wb = check_not_none(self._write_buf)
+        while wb.rem > 0:
+            def send(d: bytes) -> int:
+                try:
+                    return check_not_none(self._sock).send(d)
+                except ConnectionResetError:
+                    self.close()
+                    return 0
+                except BlockingIOError:
+                    return 0
+            if not wb.write(send):
+                break
+
+        if wb.rem < 1:
+            self._write_buf = None
+            self._cur_io = None
+            self._next_io()
 
 
 ########################################
 # ../dispatchers.py
 
 
-class Dispatchers(KeyedCollection[Fd, Dispatcher]):
-    def _key(self, v: Dispatcher) -> Fd:
-        return v.fd
+class Dispatchers(KeyedCollection[Fd, FdIoHandler]):
+    def _key(self, v: FdIoHandler) -> Fd:
+        return Fd(v.fd())
 
     #
 
@@ -5604,20 +6217,20 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
             # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
             # dispatcher (eg. call handle_listener_state_change for event listener processes)
             if d.readable():
-                d.handle_read_event()
+                d.on_readable()
             if d.writable():
-                d.handle_write_event()
+                d.on_writable()
 
     #
 
     def remove_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.remove_logs()
 
     def reopen_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.reopen_logs()
 
 
@@ -5625,7 +6238,7 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
 # ../dispatchersimpl.py
 
 
-class BaseDispatcherImpl(Dispatcher, abc.ABC):
+class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
@@ -5633,6 +6246,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__()
 
@@ -5640,6 +6254,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self._channel = channel  # 'stderr' or 'stdout'
         self._fd = fd
         self._event_callbacks = event_callbacks
+        self._server_config = server_config
 
         self._closed = False  # True if close() has been called
 
@@ -5658,7 +6273,6 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
     def channel(self) -> str:
         return self._channel
 
-    @property
     def fd(self) -> Fd:
         return self._fd
 
@@ -5673,14 +6287,14 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
             self._closed = True
 
-    def handle_error(self) -> None:
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:
         nil, t, v, tbinfo = compact_traceback()
 
         log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
         self.close()
 
 
-class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
+class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
     """
     Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
 
@@ -5696,12 +6310,14 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             event_type.channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._event_type = event_type
@@ -5725,11 +6341,10 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
 
         self._main_log_level = logging.DEBUG
 
-        self._log_to_main_log = process.context.config.loglevel <= self._main_log_level
+        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
 
-        config = self._process.config
-        self._stdout_events_enabled = config.stdout.events_enabled
-        self._stderr_events_enabled = config.stderr.events_enabled
+        self._stdout_events_enabled = self._process.config.stdout.events_enabled
+        self._stderr_events_enabled = self._process.config.stderr.events_enabled
 
     _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
     _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
@@ -5800,7 +6415,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
         if not data:
             return
 
-        if self._process.context.config.strip_ansi:
+        if self._server_config.strip_ansi:
             data = strip_escapes(as_bytes(data))
 
         if self._child_log:
@@ -5888,7 +6503,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             return False
         return True
 
-    def handle_read_event(self) -> None:
+    def on_readable(self) -> None:
         data = read_fd(self._fd)
         self._output_buffer += data
         self.record_output()
@@ -5898,7 +6513,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self.close()
 
 
-class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
+class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
     def __init__(
             self,
             process: Process,
@@ -5906,12 +6521,14 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._input_buffer = b''
@@ -5924,15 +6541,12 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             return True
         return False
 
-    def readable(self) -> bool:
-        return False
-
     def flush(self) -> None:
         # other code depends on this raising EPIPE if the pipe is closed
         sent = os.write(self._fd, as_bytes(self._input_buffer))
         self._input_buffer = self._input_buffer[sent:]
 
-    def handle_write_event(self) -> None:
+    def on_writable(self) -> None:
         if self._input_buffer:
             try:
                 self.flush()
@@ -5944,79 +6558,6 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
                     raise
 
 
-########################################
-# ../groups.py
-
-
-class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):
-    def __init__(
-            self,
-            *,
-            event_callbacks: EventCallbacks,
-    ) -> None:
-        super().__init__()
-
-        self._event_callbacks = event_callbacks
-
-        self._by_name: ta.Dict[str, ProcessGroup] = {}
-
-    @property
-    def _by_key(self) -> ta.Mapping[str, ProcessGroup]:
-        return self._by_name
-
-    #
-
-    def all_processes(self) -> ta.Iterator[Process]:
-        for g in self:
-            yield from g
-
-    #
-
-    def add(self, group: ProcessGroup) -> None:
-        if (name := group.name) in self._by_name:
-            raise KeyError(f'Process group already exists: {name}')
-
-        self._by_name[name] = group
-
-        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
-
-    def remove(self, name: str) -> None:
-        group = self._by_name[name]
-
-        group.before_remove()
-
-        del self._by_name[name]
-
-        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
-
-    def clear(self) -> None:
-        # FIXME: events?
-        self._by_name.clear()
-
-    #
-
-    class Diff(ta.NamedTuple):
-        added: ta.List[ProcessGroupConfig]
-        changed: ta.List[ProcessGroupConfig]
-        removed: ta.List[ProcessGroupConfig]
-
-    def diff(self, new: ta.Sequence[ProcessGroupConfig]) -> Diff:
-        cur = [group.config for group in self]
-
-        cur_by_name = {cfg.name: cfg for cfg in cur}
-        new_by_name = {cfg.name: cfg for cfg in new}
-
-        added = [cand for cand in new if cand.name not in cur_by_name]
-        removed = [cand for cand in cur if cand.name not in new_by_name]
-        changed = [cand for cand in new if cand != cur_by_name.get(cand.name, cand)]
-
-        return ProcessGroupManager.Diff(
-            added,
-            changed,
-            removed,
-        )
-
-
 ########################################
 # ../groupsimpl.py
 
@@ -6071,7 +6612,7 @@ class ProcessGroupImpl(ProcessGroup):
     #
 
     def get_unstopped_processes(self) -> ta.List[Process]:
-        return [x for x in self if not x.get_state().stopped]
+        return [x for x in self if not x.state.stopped]
 
     def stop_all(self) -> None:
         processes = list(self._by_name.values())
@@ -6079,7 +6620,7 @@ class ProcessGroupImpl(ProcessGroup):
         processes.reverse()  # stop in desc priority order
 
         for proc in processes:
-            state = proc.get_state()
+            state = proc.state
             if state == ProcessState.RUNNING:
                 # RUNNING -> STOPPING
                 proc.stop()
@@ -6362,304 +6903,151 @@ class SupervisorSetupImpl(SupervisorSetup):
 
 
 ########################################
-# ../spawning.py
-
+# ../groups.py
 
-@dc.dataclass(frozen=True)
-class SpawnedProcess:
-    pid: Pid
-    pipes: ProcessPipes
-    dispatchers: Dispatchers
 
+class ProcessGroupManager(
+    KeyedCollectionAccessors[str, ProcessGroup],
+    HasDispatchers,
+):
+    def __init__(
+            self,
+            *,
+            event_callbacks: EventCallbacks,
+    ) -> None:
+        super().__init__()
 
-class ProcessSpawnError(RuntimeError):
-    pass
+        self._event_callbacks = event_callbacks
 
+        self._by_name: ta.Dict[str, ProcessGroup] = {}
 
-class ProcessSpawning:
     @property
-    @abc.abstractmethod
-    def process(self) -> Process:
-        raise NotImplementedError
+    def _by_key(self) -> ta.Mapping[str, ProcessGroup]:
+        return self._by_name
 
     #
 
-    @abc.abstractmethod
-    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
-        raise NotImplementedError
+    def all_processes(self) -> ta.Iterator[Process]:
+        for g in self:
+            yield from g
 
+    #
 
-########################################
-# ../supervisor.py
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for g in self
+            for p in g
+            for d in p.get_dispatchers()
+        )
 
+    #
 
-##
+    def add(self, group: ProcessGroup) -> None:
+        if (name := group.name) in self._by_name:
+            raise KeyError(f'Process group already exists: {name}')
 
+        self._by_name[name] = group
 
-class ExitNow(Exception):  # noqa
-    pass
+        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
 
+    def remove(self, name: str) -> None:
+        group = self._by_name[name]
 
-def timeslice(period: int, when: float) -> int:
-    return int(when - (when % period))
+        group.before_remove()
 
+        del self._by_name[name]
 
-##
+        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
 
+    def clear(self) -> None:
+        # FIXME: events?
+        self._by_name.clear()
 
-class SignalHandler:
-    def __init__(
-            self,
-            *,
-            context: ServerContextImpl,
-            signal_receiver: SignalReceiver,
-            process_groups: ProcessGroupManager,
-    ) -> None:
-        super().__init__()
+    #
 
-        self._context = context
-        self._signal_receiver = signal_receiver
-        self._process_groups = process_groups
-
-    def set_signals(self) -> None:
-        self._signal_receiver.install(
-            signal.SIGTERM,
-            signal.SIGINT,
-            signal.SIGQUIT,
-            signal.SIGHUP,
-            signal.SIGCHLD,
-            signal.SIGUSR2,
-        )
-
-    def handle_signals(self) -> None:
-        sig = self._signal_receiver.get_signal()
-        if not sig:
-            return
+    class Diff(ta.NamedTuple):
+        added: ta.List[ProcessGroupConfig]
+        changed: ta.List[ProcessGroupConfig]
+        removed: ta.List[ProcessGroupConfig]
 
-        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
-            log.warning('received %s indicating exit request', sig_name(sig))
-            self._context.set_state(SupervisorState.SHUTDOWN)
+    def diff(self, new: ta.Sequence[ProcessGroupConfig]) -> Diff:
+        cur = [group.config for group in self]
 
-        elif sig == signal.SIGHUP:
-            if self._context.state == SupervisorState.SHUTDOWN:
-                log.warning('ignored %s indicating restart request (shutdown in progress)', sig_name(sig))  # noqa
-            else:
-                log.warning('received %s indicating restart request', sig_name(sig))  # noqa
-                self._context.set_state(SupervisorState.RESTARTING)
+        cur_by_name = {cfg.name: cfg for cfg in cur}
+        new_by_name = {cfg.name: cfg for cfg in new}
 
-        elif sig == signal.SIGCHLD:
-            log.debug('received %s indicating a child quit', sig_name(sig))
+        added = [cand for cand in new if cand.name not in cur_by_name]
+        removed = [cand for cand in cur if cand.name not in new_by_name]
+        changed = [cand for cand in new if cand != cur_by_name.get(cand.name, cand)]
 
-        elif sig == signal.SIGUSR2:
-            log.info('received %s indicating log reopen request', sig_name(sig))
+        return ProcessGroupManager.Diff(
+            added,
+            changed,
+            removed,
+        )
 
-            for p in self._process_groups.all_processes():
-                for d in p.get_dispatchers():
-                    if isinstance(d, OutputDispatcher):
-                        d.reopen_logs()
 
-        else:
-            log.debug('received %s indicating nothing', sig_name(sig))
+########################################
+# ../io.py
 
 
 ##
 
 
-class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
-    pass
+HasDispatchersList = ta.NewType('HasDispatchersList', ta.Sequence[HasDispatchers])
 
 
-class Supervisor:
+class IoManager(HasDispatchers):
     def __init__(
             self,
             *,
-            context: ServerContextImpl,
-            poller: Poller,
-            process_groups: ProcessGroupManager,
-            signal_handler: SignalHandler,
-            event_callbacks: EventCallbacks,
-            process_group_factory: ProcessGroupFactory,
-            pid_history: PidHistory,
-            setup: SupervisorSetup,
+            poller: FdIoPoller,
+            has_dispatchers_list: HasDispatchersList,
     ) -> None:
         super().__init__()
 
-        self._context = context
         self._poller = poller
-        self._process_groups = process_groups
-        self._signal_handler = signal_handler
-        self._event_callbacks = event_callbacks
-        self._process_group_factory = process_group_factory
-        self._pid_history = pid_history
-        self._setup = setup
-
-        self._ticks: ta.Dict[int, float] = {}
-        self._stop_groups: ta.Optional[ta.List[ProcessGroup]] = None  # list used for priority ordered shutdown
-        self._stopping = False  # set after we detect that we are handling a stop request
-        self._last_shutdown_report = 0.  # throttle for delayed process error reports at stop
-
-    #
-
-    @property
-    def context(self) -> ServerContextImpl:
-        return self._context
-
-    def get_state(self) -> SupervisorState:
-        return self._context.state
-
-    #
-
-    def add_process_group(self, config: ProcessGroupConfig) -> bool:
-        if self._process_groups.get(config.name) is not None:
-            return False
-
-        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
-        for process in group:
-            process.after_setuid()
-
-        self._process_groups.add(group)
-
-        return True
-
-    def remove_process_group(self, name: str) -> bool:
-        if self._process_groups[name].get_unstopped_processes():
-            return False
-
-        self._process_groups.remove(name)
-
-        return True
-
-    #
-
-    def shutdown_report(self) -> ta.List[Process]:
-        unstopped: ta.List[Process] = []
-
-        for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())
-
-        if unstopped:
-            # throttle 'waiting for x to die' reports
-            now = time.time()
-            if now > (self._last_shutdown_report + 3):  # every 3 secs
-                names = [p.config.name for p in unstopped]
-                namestr = ', '.join(names)
-                log.info('waiting for %s to die', namestr)
-                self._last_shutdown_report = now
-                for proc in unstopped:
-                    log.debug('%s state: %s', proc.config.name, proc.get_state().name)
-
-        return unstopped
-
-    #
-
-    def main(self, **kwargs: ta.Any) -> None:
-        self._setup.setup()
-        try:
-            self.run(**kwargs)
-        finally:
-            self._setup.cleanup()
-
-    def run(
-            self,
-            *,
-            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
-    ) -> None:
-        self._process_groups.clear()
-        self._stop_groups = None  # clear
-
-        self._event_callbacks.clear()
-
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
-
-            self._signal_handler.set_signals()
-
-            self._event_callbacks.notify(SupervisorRunningEvent())
-
-            while True:
-                if callback is not None and not callback(self):
-                    break
-
-                self._run_once()
-
-        finally:
-            self._poller.close()
-
-    #
-
-    def _run_once(self) -> None:
-        self._poll()
-        self._reap()
-        self._signal_handler.handle_signals()
-        self._tick()
-
-        if self._context.state < SupervisorState.RUNNING:
-            self._ordered_stop_groups_phase_2()
-
-    def _ordered_stop_groups_phase_1(self) -> None:
-        if self._stop_groups:
-            # stop the last group (the one with the "highest" priority)
-            self._stop_groups[-1].stop_all()
-
-    def _ordered_stop_groups_phase_2(self) -> None:
-        # after phase 1 we've transitioned and reaped, let's see if we can remove the group we stopped from the
-        # stop_groups queue.
-        if self._stop_groups:
-            # pop the last group (the one with the "highest" priority)
-            group = self._stop_groups.pop()
-            if group.get_unstopped_processes():
-                # if any processes in the group aren't yet in a stopped state, we're not yet done shutting this group
-                # down, so push it back on to the end of the stop group queue
-                self._stop_groups.append(group)
+        self._has_dispatchers_list = has_dispatchers_list
 
     def get_dispatchers(self) -> Dispatchers:
         return Dispatchers(
             d
-            for p in self._process_groups.all_processes()
-            for d in p.get_dispatchers()
+            for hd in self._has_dispatchers_list
+            for d in hd.get_dispatchers()
         )
 
-    def _poll(self) -> None:
+    def poll(self) -> None:
         dispatchers = self.get_dispatchers()
 
-        sorted_groups = list(self._process_groups)
-        sorted_groups.sort()
-
-        if self._context.state < SupervisorState.RUNNING:
-            if not self._stopping:
-                # first time, set the stopping flag, do a notification and set stop_groups
-                self._stopping = True
-                self._stop_groups = sorted_groups[:]
-                self._event_callbacks.notify(SupervisorStoppingEvent())
-
-            self._ordered_stop_groups_phase_1()
-
-            if not self.shutdown_report():
-                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
-                raise ExitNow
-
-        for fd, dispatcher in dispatchers.items():
-            if dispatcher.readable():
-                self._poller.register_readable(fd)
-            if dispatcher.writable():
-                self._poller.register_writable(fd)
+        self._poller.update(
+            {fd for fd, d in dispatchers.items() if d.readable()},
+            {fd for fd, d in dispatchers.items() if d.writable()},
+        )
 
         timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        r, w = self._poller.poll(timeout)
-
-        for fd in r:
+        log.info(f'Polling: {timeout=}')  # noqa
+        polled = self._poller.poll(timeout)
+        log.info(f'Polled: {polled=}')  # noqa
+        if polled.msg is not None:
+            log.error(polled.msg)
+        if polled.exc is not None:
+            log.error('Poll exception: %r', polled.exc)
+
+        for r in polled.r:
+            fd = Fd(r)
             if fd in dispatchers:
+                dispatcher = dispatchers[fd]
                 try:
-                    dispatcher = dispatchers[fd]
                     log.debug('read event caused by %r', dispatcher)
-                    dispatcher.handle_read_event()
+                    dispatcher.on_readable()
                     if not dispatcher.readable():
                         self._poller.unregister_readable(fd)
                 except ExitNow:
                     raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
             else:
                 # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
                 # time, which may cause 100% cpu usage
@@ -6669,18 +7057,20 @@ class Supervisor:
                 except Exception:  # noqa
                     pass
 
-        for fd in w:
+        for w in polled.w:
+            fd = Fd(w)
             if fd in dispatchers:
+                dispatcher = dispatchers[fd]
                 try:
-                    dispatcher = dispatchers[fd]
                     log.debug('write event caused by %r', dispatcher)
-                    dispatcher.handle_write_event()
+                    dispatcher.on_writable()
                     if not dispatcher.writable():
                         self._poller.unregister_writable(fd)
                 except ExitNow:
                     raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
             else:
                 log.debug('unexpected write event from fd %r', fd)
                 try:
@@ -6688,49 +7078,150 @@ class Supervisor:
                 except Exception:  # noqa
                     pass
 
-        for group in sorted_groups:
-            for process in group:
-                process.transition()
 
-    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
-        if depth >= 100:
-            return
+########################################
+# ../spawning.py
 
-        pid, sts = self._context.waitpid()
-        if not pid:
-            return
 
-        process = self._pid_history.get(pid, None)
-        if process is None:
-            _, msg = decode_wait_status(check_not_none(sts))
-            log.info('reaped unknown pid %s (%s)', pid, msg)
-        else:
-            process.finish(check_not_none(sts))
-            del self._pid_history[pid]
+@dc.dataclass(frozen=True)
+class SpawnedProcess:
+    pid: Pid
+    pipes: ProcessPipes
+    dispatchers: Dispatchers
 
-        if not once:
-            # keep reaping until no more kids to reap, but don't recurse infinitely
-            self._reap(once=False, depth=depth + 1)
 
-    def _tick(self, now: ta.Optional[float] = None) -> None:
-        """Send one or more 'tick' events when the timeslice related to the period for the event type rolls over"""
+class ProcessSpawnError(RuntimeError):
+    pass
 
-        if now is None:
-            # now won't be None in unit tests
-            now = time.time()
 
-        for event in TICK_EVENTS:
-            period = event.period
+class ProcessSpawning:
+    @property
+    @abc.abstractmethod
+    def process(self) -> Process:
+        raise NotImplementedError
 
-            last_tick = self._ticks.get(period)
-            if last_tick is None:
-                # we just started up
-                last_tick = self._ticks[period] = timeslice(period, now)
+    #
+
+    @abc.abstractmethod
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        raise NotImplementedError
+
+
+########################################
+# ../http.py
+
+
+##
+
+
+class SocketServerFdIoHandler(SocketFdIoHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            on_connect: ta.Callable[[socket.socket, SocketAddress], None],
+    ) -> None:
+        sock = socket.create_server(addr)
+        sock.setblocking(False)
+
+        super().__init__(addr, sock)
+
+        self._on_connect = on_connect
+
+        sock.listen(1)
+
+    def readable(self) -> bool:
+        return True
+
+    def on_readable(self) -> None:
+        cli_sock, cli_addr = check_not_none(self._sock).accept()
+        cli_sock.setblocking(False)
+
+        self._on_connect(cli_sock, cli_addr)
 
-            this_tick = timeslice(period, now)
-            if this_tick != last_tick:
-                self._ticks[period] = this_tick
-                self._event_callbacks.notify(event(this_tick, self))
+
+##
+
+
+class HttpServer(HasDispatchers):
+    class Address(ta.NamedTuple):
+        a: SocketAddress
+
+    class Handler(ta.NamedTuple):
+        h: HttpHandler
+
+    def __init__(
+            self,
+            handler: Handler,
+            addr: Address = Address(('localhost', 8000)),
+    ) -> None:
+        super().__init__()
+
+        self._handler = handler.h
+        self._addr = addr.a
+
+        self._server = SocketServerFdIoHandler(self._addr, self._on_connect)
+
+        self._conns: ta.List[CoroHttpServerConnectionFdIoHandler] = []
+
+    def get_dispatchers(self) -> Dispatchers:
+        l = []
+        for c in self._conns:
+            if not c.closed:
+                l.append(c)
+        self._conns = l
+        return Dispatchers([
+            self._server,
+            *l,
+        ])
+
+    def _on_connect(self, sock: socket.socket, addr: SocketAddress) -> None:
+        conn = CoroHttpServerConnectionFdIoHandler(
+            addr,
+            sock,
+            self._handler,
+        )
+
+        self._conns.append(conn)
+
+
+##
+
+
+class SupervisorHttpHandler:
+    def __init__(
+            self,
+            *,
+            groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._groups = groups
+
+    def handle(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        dct = {
+            'method': req.method,
+            'path': req.path,
+            'data': len(req.data or b''),
+            'groups': {
+                g.name: {
+                    'processes': {
+                        p.name: {
+                            'pid': p.pid,
+                        }
+                        for p in g
+                    },
+                }
+                for g in self._groups
+            },
+        }
+
+        return HttpHandlerResponse(
+            200,
+            data=json.dumps(dct, **JSON_PRETTY_KWARGS).encode('utf-8') + b'\n',
+            headers={
+                'Content-Type': 'application/json',
+            },
+        )
 
 
 ########################################
@@ -6752,7 +7243,7 @@ class ProcessImpl(Process):
             config: ProcessConfig,
             group: ProcessGroup,
             *,
-            context: ServerContext,
+            supervisor_states: SupervisorStateManager,
             event_callbacks: EventCallbacks,
             process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
@@ -6761,7 +7252,7 @@ class ProcessImpl(Process):
         self._config = config
         self._group = group
 
-        self._context = context
+        self._supervisor_states = supervisor_states
         self._event_callbacks = event_callbacks
 
         self._spawning = process_spawning_factory(self)
@@ -6792,7 +7283,7 @@ class ProcessImpl(Process):
     #
 
     def __repr__(self) -> str:
-        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self._state.name}>'
 
     #
 
@@ -6814,10 +7305,6 @@ class ProcessImpl(Process):
 
     #
 
-    @property
-    def context(self) -> ServerContext:
-        return self._context
-
     @property
     def state(self) -> ProcessState:
         return self._state
@@ -6880,7 +7367,7 @@ class ProcessImpl(Process):
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
@@ -7087,6 +7574,7 @@ class ProcessImpl(Process):
         self._last_stop = now
 
         if now > self._last_start:
+            log.info(f'{now - self._last_start=}')  # noqa
             too_quickly = now - self._last_start < self._config.startsecs
         else:
             too_quickly = False
@@ -7150,18 +7638,13 @@ class ProcessImpl(Process):
         self._pipes = ProcessPipes()
         self._dispatchers = Dispatchers([])
 
-    def get_state(self) -> ProcessState:
-        return self._state
-
     def transition(self) -> None:
         now = time.time()
         state = self._state
 
         self._check_and_adjust_for_system_clock_rollback(now)
 
-        logger = log
-
-        if self.context.state > SupervisorState.RESTARTING:
+        if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
                 if self._config.autorestart:
@@ -7192,14 +7675,14 @@ class ProcessImpl(Process):
                 self.check_in_state(ProcessState.STARTING)
                 self.change_state(ProcessState.RUNNING)
                 msg = ('entered RUNNING state, process has stayed up for > than %s seconds (startsecs)' % self._config.startsecs)  # noqa
-                logger.info('success: %s %s', self.name, msg)
+                log.info('success: %s %s', self.name, msg)
 
         if state == ProcessState.BACKOFF:
             if self._backoff > self._config.startretries:
                 # BACKOFF -> FATAL if the proc has exceeded its number of retries
                 self.give_up()
                 msg = ('entered FATAL state, too many start retries too quickly')
-                logger.info('gave up: %s %s', self.name, msg)
+                log.info('gave up: %s %s', self.name, msg)
 
         elif state == ProcessState.STOPPING:
             time_left = self._delay - now
@@ -7221,15 +7704,74 @@ class ProcessImpl(Process):
         pass
 
 
+########################################
+# ../signals.py
+
+
+class SignalHandler:
+    def __init__(
+            self,
+            *,
+            states: SupervisorStateManager,
+            signal_receiver: SignalReceiver,
+            process_groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._states = states
+        self._signal_receiver = signal_receiver
+        self._process_groups = process_groups
+
+    def set_signals(self) -> None:
+        self._signal_receiver.install(
+            signal.SIGTERM,
+            signal.SIGINT,
+            signal.SIGQUIT,
+            signal.SIGHUP,
+            signal.SIGCHLD,
+            signal.SIGUSR2,
+        )
+
+    def handle_signals(self) -> None:
+        sig = self._signal_receiver.get_signal()
+        if not sig:
+            return
+
+        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
+            log.warning('received %s indicating exit request', sig_name(sig))
+            self._states.set_state(SupervisorState.SHUTDOWN)
+
+        elif sig == signal.SIGHUP:
+            if self._states.state == SupervisorState.SHUTDOWN:
+                log.warning('ignored %s indicating restart request (shutdown in progress)', sig_name(sig))  # noqa
+            else:
+                log.warning('received %s indicating restart request', sig_name(sig))  # noqa
+                self._states.set_state(SupervisorState.RESTARTING)
+
+        elif sig == signal.SIGCHLD:
+            log.debug('received %s indicating a child quit', sig_name(sig))
+
+        elif sig == signal.SIGUSR2:
+            log.info('received %s indicating log reopen request', sig_name(sig))
+
+            for p in self._process_groups.all_processes():
+                for d in p.get_dispatchers():
+                    if isinstance(d, ProcessOutputDispatcher):
+                        d.reopen_logs()
+
+        else:
+            log.debug('received %s indicating nothing', sig_name(sig))
+
+
 ########################################
 # ../spawningimpl.py
 
 
-class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, OutputDispatcher]):
+class ProcessOutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, ProcessOutputDispatcher]):
     pass
 
 
-class InputDispatcherFactory(Func3[Process, str, Fd, InputDispatcher]):
+class ProcessInputDispatcherFactory(Func3[Process, str, Fd, ProcessInputDispatcher]):
     pass
 
 
@@ -7247,8 +7789,8 @@ class ProcessSpawningImpl(ProcessSpawning):
             server_config: ServerConfig,
             pid_history: PidHistory,
 
-            output_dispatcher_factory: OutputDispatcherFactory,
-            input_dispatcher_factory: InputDispatcherFactory,
+            output_dispatcher_factory: ProcessOutputDispatcherFactory,
+            input_dispatcher_factory: ProcessInputDispatcherFactory,
 
             inherited_fds: ta.Optional[InheritedFds] = None,
     ) -> None:
@@ -7381,28 +7923,28 @@ class ProcessSpawningImpl(ProcessSpawning):
         return exe, args
 
     def _make_dispatchers(self, pipes: ProcessPipes) -> Dispatchers:
-        dispatchers: ta.List[Dispatcher] = []
+        dispatchers: ta.List[FdIoHandler] = []
 
         if pipes.stdout is not None:
             dispatchers.append(check_isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStdoutEvent,
                 pipes.stdout,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stderr is not None:
             dispatchers.append(check_isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStderrEvent,
                 pipes.stderr,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stdin is not None:
             dispatchers.append(check_isinstance(self._input_dispatcher_factory(
                 self.process,
                 'stdin',
                 pipes.stdin,
-            ), InputDispatcher))
+            ), ProcessInputDispatcher))
 
         return Dispatchers(dispatchers)
 
@@ -7531,10 +8073,296 @@ def check_execv_args(
         raise NoPermissionError(f'No permission to run command {exe!r}')
 
 
+########################################
+# ../supervisor.py
+
+
+##
+
+
+def timeslice(period: int, when: float) -> int:
+    return int(when - (when % period))
+
+
+##
+
+
+class SupervisorStateManagerImpl(SupervisorStateManager):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._state: SupervisorState = SupervisorState.RUNNING
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._state
+
+    def set_state(self, state: SupervisorState) -> None:
+        self._state = state
+
+
+##
+
+
+class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
+    pass
+
+
+class Supervisor:
+    def __init__(
+            self,
+            *,
+            config: ServerConfig,
+            poller: FdIoPoller,
+            process_groups: ProcessGroupManager,
+            signal_handler: SignalHandler,
+            event_callbacks: EventCallbacks,
+            process_group_factory: ProcessGroupFactory,
+            pid_history: PidHistory,
+            setup: SupervisorSetup,
+            states: SupervisorStateManager,
+            io: IoManager,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._poller = poller
+        self._process_groups = process_groups
+        self._signal_handler = signal_handler
+        self._event_callbacks = event_callbacks
+        self._process_group_factory = process_group_factory
+        self._pid_history = pid_history
+        self._setup = setup
+        self._states = states
+        self._io = io
+
+        self._ticks: ta.Dict[int, float] = {}
+        self._stop_groups: ta.Optional[ta.List[ProcessGroup]] = None  # list used for priority ordered shutdown
+        self._stopping = False  # set after we detect that we are handling a stop request
+        self._last_shutdown_report = 0.  # throttle for delayed process error reports at stop
+
+    #
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._states.state
+
+    #
+
+    def add_process_group(self, config: ProcessGroupConfig) -> bool:
+        if self._process_groups.get(config.name) is not None:
+            return False
+
+        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
+        for process in group:
+            process.after_setuid()
+
+        self._process_groups.add(group)
+
+        return True
+
+    def remove_process_group(self, name: str) -> bool:
+        if self._process_groups[name].get_unstopped_processes():
+            return False
+
+        self._process_groups.remove(name)
+
+        return True
+
+    #
+
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
+
+        for group in self._process_groups:
+            unstopped.extend(group.get_unstopped_processes())
+
+        if unstopped:
+            # throttle 'waiting for x to die' reports
+            now = time.time()
+            if now > (self._last_shutdown_report + 3):  # every 3 secs
+                names = [p.config.name for p in unstopped]
+                namestr = ', '.join(names)
+                log.info('waiting for %s to die', namestr)
+                self._last_shutdown_report = now
+                for proc in unstopped:
+                    log.debug('%s state: %s', proc.config.name, proc.state.name)
+
+        return unstopped
+
+    #
+
+    def main(self, **kwargs: ta.Any) -> None:
+        self._setup.setup()
+        try:
+            self.run(**kwargs)
+        finally:
+            self._setup.cleanup()
+
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups.clear()
+        self._stop_groups = None  # clear
+
+        self._event_callbacks.clear()
+
+        try:
+            for config in self._config.groups or []:
+                self.add_process_group(config)
+
+            self._signal_handler.set_signals()
+
+            self._event_callbacks.notify(SupervisorRunningEvent())
+
+            while True:
+                if callback is not None and not callback(self):
+                    break
+
+                self._run_once()
+
+        finally:
+            self._poller.close()
+
+    #
+
+    def _run_once(self) -> None:
+        now = time.time()
+        self._poll()
+        log.info(f'Poll took {time.time() - now}')  # noqa
+        self._reap()
+        self._signal_handler.handle_signals()
+        self._tick()
+
+        if self._states.state < SupervisorState.RUNNING:
+            self._ordered_stop_groups_phase_2()
+
+    def _ordered_stop_groups_phase_1(self) -> None:
+        if self._stop_groups:
+            # stop the last group (the one with the "highest" priority)
+            self._stop_groups[-1].stop_all()
+
+    def _ordered_stop_groups_phase_2(self) -> None:
+        # after phase 1 we've transitioned and reaped, let's see if we can remove the group we stopped from the
+        # stop_groups queue.
+        if self._stop_groups:
+            # pop the last group (the one with the "highest" priority)
+            group = self._stop_groups.pop()
+            if group.get_unstopped_processes():
+                # if any processes in the group aren't yet in a stopped state, we're not yet done shutting this group
+                # down, so push it back on to the end of the stop group queue
+                self._stop_groups.append(group)
+
+    def _poll(self) -> None:
+        sorted_groups = list(self._process_groups)
+        sorted_groups.sort()
+
+        if self._states.state < SupervisorState.RUNNING:
+            if not self._stopping:
+                # first time, set the stopping flag, do a notification and set stop_groups
+                self._stopping = True
+                self._stop_groups = sorted_groups[:]
+                self._event_callbacks.notify(SupervisorStoppingEvent())
+
+            self._ordered_stop_groups_phase_1()
+
+            if not self.shutdown_report():
+                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
+                raise ExitNow
+
+        self._io.poll()
+
+        for group in sorted_groups:
+            for process in group:
+                process.transition()
+
+    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
+        if depth >= 100:
+            return
+
+        wp = waitpid()
+        log.info(f'Waited pid: {wp}')  # noqa
+        if wp is None or not wp.pid:
+            return
+
+        process = self._pid_history.get(wp.pid, None)
+        if process is None:
+            _, msg = decode_wait_status(wp.sts)
+            log.info('reaped unknown pid %s (%s)', wp.pid, msg)
+        else:
+            process.finish(wp.sts)
+            del self._pid_history[wp.pid]
+
+        if not once:
+            # keep reaping until no more kids to reap, but don't recurse infinitely
+            self._reap(once=False, depth=depth + 1)
+
+    def _tick(self, now: ta.Optional[float] = None) -> None:
+        """Send one or more 'tick' events when the timeslice related to the period for the event type rolls over"""
+
+        if now is None:
+            # now won't be None in unit tests
+            now = time.time()
+
+        for event in TICK_EVENTS:
+            period = event.period
+
+            last_tick = self._ticks.get(period)
+            if last_tick is None:
+                # we just started up
+                last_tick = self._ticks[period] = timeslice(period, now)
+
+            this_tick = timeslice(period, now)
+            if this_tick != last_tick:
+                self._ticks[period] = this_tick
+                self._event_callbacks.notify(event(this_tick, self))
+
+
+##
+
+
+class WaitedPid(ta.NamedTuple):
+    pid: Pid
+    sts: Rc
+
+
+def waitpid() -> ta.Optional[WaitedPid]:
+    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
+    # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
+    # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
+    # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
+    # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
+    # lying around.
+    try:
+        pid, sts = os.waitpid(-1, os.WNOHANG)
+    except OSError as exc:
+        code = exc.args[0]
+        if code not in (errno.ECHILD, errno.EINTR):
+            log.critical('waitpid error %r; a process may not be cleaned up properly', code)
+        if code == errno.EINTR:
+            log.debug('EINTR during reap')
+        return None
+    else:
+        return WaitedPid(pid, sts)  # type: ignore
+
+
 ########################################
 # ../inject.py
 
 
+@dc.dataclass(frozen=True)
+class _FdIoPollerDaemonizeListener(DaemonizeListener):
+    _poller: FdIoPoller
+
+    def before_daemonize(self) -> None:
+        self._poller.close()
+
+    def after_daemonize(self) -> None:
+        self._poller.reopen()
+
+
 def bind_server(
         config: ServerConfig,
         *,
@@ -7544,24 +8372,30 @@ def bind_server(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(config),
 
+        inj.bind_array(DaemonizeListener),
         inj.bind_array_type(DaemonizeListener, DaemonizeListeners),
 
         inj.bind(SupervisorSetupImpl, singleton=True),
         inj.bind(SupervisorSetup, to_key=SupervisorSetupImpl),
 
-        inj.bind(DaemonizeListener, array=True, to_key=Poller),
-
-        inj.bind(ServerContextImpl, singleton=True),
-        inj.bind(ServerContext, to_key=ServerContextImpl),
-
         inj.bind(EventCallbacks, singleton=True),
 
         inj.bind(SignalReceiver, singleton=True),
 
+        inj.bind(IoManager, singleton=True),
+        inj.bind_array(HasDispatchers),
+        inj.bind_array_type(HasDispatchers, HasDispatchersList),
+
         inj.bind(SignalHandler, singleton=True),
+
         inj.bind(ProcessGroupManager, singleton=True),
+        inj.bind(HasDispatchers, array=True, to_key=ProcessGroupManager),
+
         inj.bind(Supervisor, singleton=True),
 
+        inj.bind(SupervisorStateManagerImpl, singleton=True),
+        inj.bind(SupervisorStateManager, to_key=SupervisorStateManagerImpl),
+
         inj.bind(PidHistory()),
 
         inj.bind_factory(ProcessGroupImpl, ProcessGroupFactory),
@@ -7569,8 +8403,8 @@ def bind_server(
 
         inj.bind_factory(ProcessSpawningImpl, ProcessSpawningFactory),
 
-        inj.bind_factory(OutputDispatcherImpl, OutputDispatcherFactory),
-        inj.bind_factory(InputDispatcherImpl, InputDispatcherFactory),
+        inj.bind_factory(ProcessOutputDispatcherImpl, ProcessOutputDispatcherFactory),
+        inj.bind_factory(ProcessInputDispatcherImpl, ProcessInputDispatcherFactory),
     ]
 
     #
@@ -7588,7 +8422,26 @@ def bind_server(
 
     #
 
-    lst.append(inj.bind(get_poller_impl(), key=Poller, singleton=True))
+    poller_impl = next(filter(None, [
+        KqueueFdIoPoller,
+        PollFdIoPoller,
+        SelectFdIoPoller,
+    ]))
+    lst.append(inj.bind(poller_impl, key=FdIoPoller, singleton=True))
+    inj.bind(_FdIoPollerDaemonizeListener, array=True, singleton=True)
+
+    #
+
+    def _provide_http_handler(s: SupervisorHttpHandler) -> HttpServer.Handler:
+        return HttpServer.Handler(s.handle)
+
+    lst.extend([
+        inj.bind(HttpServer, singleton=True, eager=True),
+        inj.bind(HasDispatchers, array=True, to_key=HttpServer),
+
+        inj.bind(SupervisorHttpHandler, singleton=True),
+        inj.bind(_provide_http_handler),
+    ])
 
     #
 
@@ -7627,7 +8480,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
         )
 
     #
@@ -7650,7 +8503,6 @@ def main(
             inherited_fds=inherited_fds,
         ))
 
-        context = injector[ServerContextImpl]
         supervisor = injector[Supervisor]
 
         try:
@@ -7658,7 +8510,7 @@ def main(
         except ExitNow:
             pass
 
-        if context.state < SupervisorState.RESTARTING:
+        if supervisor.state < SupervisorState.RESTARTING:
             break