ominfra 0.0.0.dev119__py3-none-any.whl → 0.0.0.dev121__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -18,10 +18,12 @@ import fcntl
 import fractions
 import functools
 import grp
+import inspect
 import itertools
 import json
 import logging
 import os
+import os.path
 import pwd
 import re
 import resource
@@ -29,6 +31,7 @@ import select
 import shlex
 import signal
 import stat
+import string
 import sys
 import syslog
 import tempfile
@@ -53,6 +56,11 @@ if sys.version_info < (3, 8):
 ########################################
 
 
+# ../../../omdev/toml/parser.py
+TomlParseFloat = ta.Callable[[str], ta.Any]
+TomlKey = ta.Tuple[str, ...]
+TomlPos = int  # ta.TypeAlias
+
 # ../compat.py
 T = ta.TypeVar('T')
 
@@ -60,6 +68,837 @@ T = ta.TypeVar('T')
 ProcessState = int  # ta.TypeAlias
 SupervisorState = int  # ta.TypeAlias
 
+# ../../../omlish/lite/inject.py
+InjectorKeyCls = ta.Union[type, ta.NewType]
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+
+# ../../configs.py
+ConfigMapping = ta.Mapping[str, ta.Any]
+
+# ../context.py
+ServerEpoch = ta.NewType('ServerEpoch', int)
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+
+
+########################################
+# ../../../omdev/toml/parser.py
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+#
+# 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, 2018, 2019, 2020, 2021, 2022, 2023 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.
+#
+# https://github.com/python/cpython/blob/9ce90206b7a4649600218cf0bd4826db79c9a312/Lib/tomllib/_parser.py
+
+
+##
+
+
+_TOML_TIME_RE_STR = r'([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?'
+
+TOML_RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+TOML_RE_LOCALTIME = re.compile(_TOML_TIME_RE_STR)
+TOML_RE_DATETIME = re.compile(
+    rf"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TOML_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def toml_match_to_datetime(match: re.Match) -> ta.Union[datetime.datetime, datetime.date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return datetime.date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    if offset_sign_str:
+        tz: ta.Optional[datetime.tzinfo] = toml_cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str,
+        )
+    elif zulu_time:
+        tz = datetime.UTC
+    else:  # local date-time
+        tz = None
+    return datetime.datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+@functools.lru_cache()  # noqa
+def toml_cached_tz(hour_str: str, minute_str: str, sign_str: str) -> datetime.timezone:
+    sign = 1 if sign_str == '+' else -1
+    return datetime.timezone(
+        datetime.timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        ),
+    )
+
+
+def toml_match_to_localtime(match: re.Match) -> datetime.time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
+
+
+def toml_match_to_number(match: re.Match, parse_float: TomlParseFloat) -> ta.Any:
+    if match.group('floatpart'):
+        return parse_float(match.group())
+    return int(match.group(), 0)
+
+
+TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are currently handled as separate cases in the parser
+# functions.
+TOML_ILLEGAL_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t')
+TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t\n')
+
+TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+
+TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS = frozenset(' \t')
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset('\n')
+TOML_BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + '-_')
+TOML_KEY_INITIAL_CHARS = TOML_BARE_KEY_CHARS | frozenset("\"'")
+TOML_HEXDIGIT_CHARS = frozenset(string.hexdigits)
+
+TOML_BASIC_STR_ESCAPE_REPLACEMENTS = types.MappingProxyType(
+    {
+        '\\b': '\u0008',  # backspace
+        '\\t': '\u0009',  # tab
+        '\\n': '\u000A',  # linefeed
+        '\\f': '\u000C',  # form feed
+        '\\r': '\u000D',  # carriage return
+        '\\"': '\u0022',  # quote
+        '\\\\': '\u005C',  # backslash
+    },
+)
+
+
+class TomlDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
+
+
+def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
+    """Parse TOML from a binary file object."""
+    b = fp.read()
+    try:
+        s = b.decode()
+    except AttributeError:
+        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
+    return toml_loads(s, parse_float=parse_float)
+
+
+def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string literals. Let's do so to simplify parsing.
+    try:
+        src = s.replace('\r\n', '\n')
+    except (AttributeError, TypeError):
+        raise TypeError(f"Expected str object, not '{type(s).__qualname__}'") from None
+    pos = 0
+    out = TomlOutput(TomlNestedDict(), TomlFlags())
+    header: TomlKey = ()
+    parse_float = toml_make_safe_parse_float(parse_float)
+
+    # Parse one statement at a time (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == '\n':
+            pos += 1
+            continue
+        if char in TOML_KEY_INITIAL_CHARS:
+            pos = toml_key_value_rule(src, pos, out, header, parse_float)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char == '[':
+            try:
+                second_char: ta.Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            out.flags.finalize_pending()
+            if second_char == '[':
+                pos, header = toml_create_list_rule(src, pos, out)
+            else:
+                pos, header = toml_create_dict_rule(src, pos, out)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char != '#':
+            raise toml_suffixed_err(src, pos, 'Invalid statement')
+
+        # 3. Skip comment
+        pos = toml_skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != '\n':
+            raise toml_suffixed_err(
+                src, pos, 'Expected newline or end of document after a statement',
+            )
+        pos += 1
+
+    return out.data.dict
+
+
+class TomlFlags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
+
+    def __init__(self) -> None:
+        self._flags: ta.Dict[str, dict] = {}
+        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
+
+    def add_pending(self, key: TomlKey, flag: int) -> None:
+        self._pending_flags.add((key, flag))
+
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
+
+    def unset_all(self, key: TomlKey) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]['nested']
+        cont.pop(key[-1], None)
+
+    def set(self, key: TomlKey, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+            cont = cont[k]['nested']
+        if key_stem not in cont:
+            cont[key_stem] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+        cont[key_stem]['recursive_flags' if recursive else 'flags'].add(flag)
+
+    def is_(self, key: TomlKey, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont['recursive_flags']:
+                return True
+            cont = inner_cont['nested']
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont['flags'] or flag in cont['recursive_flags']
+        return False
+
+
+class TomlNestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: ta.Dict[str, ta.Any] = {}
+
+    def get_or_create_nest(
+            self,
+            key: TomlKey,
+            *,
+            access_lists: bool = True,
+    ) -> dict:
+        cont: ta.Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError('There is no nest behind this key')
+        return cont
+
+    def append_nest_to_list(self, key: TomlKey) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            if not isinstance(list_, list):
+                raise KeyError('An object other than list found behind this key')
+            list_.append({})
+        else:
+            cont[last_key] = [{}]
+
+
+class TomlOutput(ta.NamedTuple):
+    data: TomlNestedDict
+    flags: TomlFlags
+
+
+def toml_skip_chars(src: str, pos: TomlPos, chars: ta.Iterable[str]) -> TomlPos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def toml_skip_until(
+        src: str,
+        pos: TomlPos,
+        expect: str,
+        *,
+        error_on: ta.FrozenSet[str],
+        error_on_eof: bool,
+) -> TomlPos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise toml_suffixed_err(src, new_pos, f'Expected {expect!r}') from None
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise toml_suffixed_err(src, pos, f'Found invalid character {src[pos]!r}')
+    return new_pos
+
+
+def toml_skip_comment(src: str, pos: TomlPos) -> TomlPos:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == '#':
+        return toml_skip_until(
+            src, pos + 1, '\n', error_on=TOML_ILLEGAL_COMMENT_CHARS, error_on_eof=False,
+        )
+    return pos
+
+
+def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
+    while True:
+        pos_before_skip = pos
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = toml_skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 1  # Skip "["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.EXPLICIT_NEST) or out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot declare {key} twice')
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+    return pos + 1, key
+
+
+def toml_create_list_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 2  # Skip "[["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']]', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+    return pos + 2, key
+
+
+def toml_key_value_rule(
+        src: str,
+        pos: TomlPos,
+        out: TomlOutput,
+        header: TomlKey,
+        parse_float: TomlParseFloat,
+) -> TomlPos:
+    pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
+    for cont_key in relative_path_cont_keys:
+        # Check that dotted key syntax does not redefine an existing table
+        if out.flags.is_(cont_key, TomlFlags.EXPLICIT_NEST):
+            raise toml_suffixed_err(src, pos, f'Cannot redefine namespace {cont_key}')
+        # Containers in the relative path can't be opened with the table syntax or dotted key/value syntax in following
+        # table sections.
+        out.flags.add_pending(cont_key, TomlFlags.EXPLICIT_NEST)
+
+    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
+        raise toml_suffixed_err(
+            src,
+            pos,
+            f'Cannot mutate immutable namespace {abs_key_parent}',
+        )
+
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    if key_stem in nest:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value')
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, TomlFlags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def toml_parse_key_value_pair(
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, TomlKey, ta.Any]:
+    pos, key = toml_parse_key(src, pos)
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != '=':
+        raise toml_suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
+    pos += 1
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, value = toml_parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
+    pos, key_part = toml_parse_key_part(src, pos)
+    key: TomlKey = (key_part,)
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: ta.Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != '.':
+            return pos, key
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        pos, key_part = toml_parse_key_part(src, pos)
+        key += (key_part,)
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in TOML_BARE_KEY_CHARS:
+        start_pos = pos
+        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return toml_parse_literal_str(src, pos)
+    if char == '"':
+        return toml_parse_one_line_basic_str(src, pos)
+    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
+
+
+def toml_parse_one_line_basic_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1
+    return toml_parse_basic_str(src, pos, multiline=False)
+
+
+def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
+    pos += 1
+    array: list = []
+
+    pos = toml_skip_comments_and_array_ws(src, pos)
+    if src.startswith(']', pos):
+        return pos + 1, array
+    while True:
+        pos, val = toml_parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = toml_skip_comments_and_array_ws(src, pos)
+
+        c = src[pos:pos + 1]
+        if c == ']':
+            return pos + 1, array
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed array')
+        pos += 1
+
+        pos = toml_skip_comments_and_array_ws(src, pos)
+        if src.startswith(']', pos):
+            return pos + 1, array
+
+
+def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
+    pos += 1
+    nested_dict = TomlNestedDict()
+    flags = TomlFlags()
+
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    if src.startswith('}', pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, TomlFlags.FROZEN):
+            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+        if key_stem in nest:
+            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
+        nest[key_stem] = value
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        c = src[pos:pos + 1]
+        if c == '}':
+            return pos + 1, nested_dict.dict
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
+        if isinstance(value, (dict, list)):
+            flags.set(key, TomlFlags.FROZEN, recursive=True)
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_basic_str_escape(
+        src: str,
+        pos: TomlPos,
+        *,
+        multiline: bool = False,
+) -> ta.Tuple[TomlPos, str]:
+    escape_id = src[pos:pos + 2]
+    pos += 2
+    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
+        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
+        # newline.
+        if escape_id != '\\\n':
+            pos = toml_skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ''
+            if char != '\n':
+                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
+            pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ''
+    if escape_id == '\\u':
+        return toml_parse_hex_char(src, pos, 4)
+    if escape_id == '\\U':
+        return toml_parse_hex_char(src, pos, 8)
+    try:
+        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
+
+
+def toml_parse_basic_str_escape_multiline(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    return toml_parse_basic_str_escape(src, pos, multiline=True)
+
+
+def toml_parse_hex_char(src: str, pos: TomlPos, hex_len: int) -> ta.Tuple[TomlPos, str]:
+    hex_str = src[pos:pos + hex_len]
+    if len(hex_str) != hex_len or not TOML_HEXDIGIT_CHARS.issuperset(hex_str):
+        raise toml_suffixed_err(src, pos, 'Invalid hex value')
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not toml_is_unicode_scalar_value(hex_int):
+        raise toml_suffixed_err(src, pos, 'Escaped character is not a Unicode scalar value')
+    return pos, chr(hex_int)
+
+
+def toml_parse_literal_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = toml_skip_until(
+        src, pos, "'", error_on=TOML_ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True,
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
+    pos += 3
+    if src.startswith('\n', pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = toml_skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = toml_parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def toml_parse_basic_str(src: str, pos: TomlPos, *, multiline: bool) -> ta.Tuple[TomlPos, str]:
+    if multiline:
+        error_on = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape_multiline
+    else:
+        error_on = TOML_ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape
+    result = ''
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise toml_suffixed_err(src, pos, 'Unterminated string') from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == '\\':
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise toml_suffixed_err(src, pos, f'Illegal character {char!r}')
+        pos += 1
+
+
+def toml_parse_value(  # noqa: C901
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, ta.Any]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+
+    # IMPORTANT: order conditions based on speed of checking and likelihood
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return toml_parse_multiline_str(src, pos, literal=False)
+        return toml_parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return toml_parse_multiline_str(src, pos, literal=True)
+        return toml_parse_literal_str(src, pos)
+
+    # Booleans
+    if char == 't':
+        if src.startswith('true', pos):
+            return pos + 4, True
+    if char == 'f':
+        if src.startswith('false', pos):
+            return pos + 5, False
+
+    # Arrays
+    if char == '[':
+        return toml_parse_array(src, pos, parse_float)
+
+    # Inline tables
+    if char == '{':
+        return toml_parse_inline_table(src, pos, parse_float)
+
+    # Dates and times
+    datetime_match = TOML_RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = toml_match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise toml_suffixed_err(src, pos, 'Invalid date or datetime') from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = TOML_RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), toml_match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats. The regex will greedily match any type starting with a decimal char, so needs to be
+    # located after handling of dates and times.
+    number_match = TOML_RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), toml_match_to_number(number_match, parse_float)
+
+    # Special floats
+    first_three = src[pos:pos + 3]
+    if first_three in {'inf', 'nan'}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos:pos + 4]
+    if first_four in {'-inf', '+inf', '-nan', '+nan'}:
+        return pos + 4, parse_float(first_four)
+
+    raise toml_suffixed_err(src, pos, 'Invalid value')
+
+
+def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
+    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
+
+    def coord_repr(src: str, pos: TomlPos) -> str:
+        if pos >= len(src):
+            return 'end of document'
+        line = src.count('\n', 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex('\n', 0, pos)
+        return f'line {line}, column {column}'
+
+    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
+
+
+def toml_is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
+
+
+def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
+    """A decorator to make `parse_float` safe.
+
+    `parse_float` must not return dicts or lists, because these types would be mixed with parsed TOML tables and arrays,
+    thus confusing the parser. The returned decorated callable raises `ValueError` instead of returning illegal types.
+    """
+    # The default `float` callable never returns illegal types. Optimize it.
+    if parse_float is float:
+        return float
+
+    def safe_parse_float(float_str: str) -> ta.Any:
+        float_value = parse_float(float_str)
+        if isinstance(float_value, (dict, list)):
+            raise ValueError('parse_float must not return dicts or lists')  # noqa
+        return float_value
+
+    return safe_parse_float
+
 
 ########################################
 # ../compat.py
@@ -215,6 +1054,19 @@ def close_fd(fd: int) -> bool:
     return True
 
 
+def is_fd_open(fd: int) -> bool:
+    try:
+        n = os.dup(fd)
+    except OSError:
+        return False
+    os.close(n)
+    return True
+
+
+def get_open_fds(limit: int) -> ta.FrozenSet[int]:
+    return frozenset(filter(is_fd_open, range(limit)))
+
+
 def mktempfile(suffix: str, prefix: str, dir: str) -> str:  # noqa
     fd, filename = tempfile.mkstemp(suffix, prefix, dir)
     os.close(fd)
@@ -489,7 +1341,7 @@ class _cached_nullary:  # noqa
         return bound
 
 
-def cached_nullary(fn: ta.Callable[..., T]) -> ta.Callable[..., T]:
+def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _cached_nullary(fn)
 
 
@@ -580,6 +1432,50 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/maybes.py
+
+
+class Maybe(ta.Generic[T]):
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    @classmethod
+    def just(cls, v: T) -> 'Maybe[T]':
+        return tuple.__new__(_Maybe, (v,))  # noqa
+
+    _empty: ta.ClassVar['Maybe']
+
+    @classmethod
+    def empty(cls) -> 'Maybe[T]':
+        return Maybe._empty
+
+
+class _Maybe(Maybe[T], tuple):
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    @property
+    def present(self) -> bool:
+        return bool(self)
+
+    def must(self) -> T:
+        if not self:
+            raise ValueError
+        return self[0]
+
+
+Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+
+
 ########################################
 # ../../../omlish/lite/reflect.py
 
@@ -628,179 +1524,681 @@ def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
 
 
 ########################################
-# ../configs.py
+# ../states.py
+
+
+##
+
+
+def _names_by_code(states: ta.Any) -> ta.Dict[int, str]:
+    d = {}
+    for name in states.__dict__:
+        if not name.startswith('__'):
+            code = getattr(states, name)
+            d[code] = name
+    return d
+
+
+##
+
+
+class ProcessStates:
+    STOPPED = 0
+    STARTING = 10
+    RUNNING = 20
+    BACKOFF = 30
+    STOPPING = 40
+    EXITED = 100
+    FATAL = 200
+    UNKNOWN = 1000
+
+
+STOPPED_STATES = (
+    ProcessStates.STOPPED,
+    ProcessStates.EXITED,
+    ProcessStates.FATAL,
+    ProcessStates.UNKNOWN,
+)
+
+RUNNING_STATES = (
+    ProcessStates.RUNNING,
+    ProcessStates.BACKOFF,
+    ProcessStates.STARTING,
+)
+
+SIGNALLABLE_STATES = (
+    ProcessStates.RUNNING,
+    ProcessStates.STARTING,
+    ProcessStates.STOPPING,
+)
+
+
+_process_states_by_code = _names_by_code(ProcessStates)
+
+
+def get_process_state_description(code: ProcessState) -> str:
+    return check_not_none(_process_states_by_code.get(code))
+
+
+##
+
+
+class SupervisorStates:
+    FATAL = 2
+    RUNNING = 1
+    RESTARTING = 0
+    SHUTDOWN = -1
+
+
+_supervisor_states_by_code = _names_by_code(SupervisorStates)
+
+
+def get_supervisor_state_description(code: SupervisorState) -> str:
+    return check_not_none(_supervisor_states_by_code.get(code))
+
+
+########################################
+# ../../../omlish/lite/inject.py
+
+
+###
+# types
 
 
 @dc.dataclass(frozen=True)
-class ProcessConfig:
-    name: str
-    command: str
+class InjectorKey:
+    cls: InjectorKeyCls
+    tag: ta.Any = None
+    array: bool = False
 
-    uid: ta.Optional[int] = None
-    directory: ta.Optional[str] = None
-    umask: ta.Optional[int] = None
-    priority: int = 999
 
-    autostart: bool = True
-    autorestart: str = 'unexpected'
+##
 
-    startsecs: int = 1
-    startretries: int = 3
 
-    numprocs: int = 1
-    numprocs_start: int = 0
+class InjectorProvider(abc.ABC):
+    @abc.abstractmethod
+    def provider_fn(self) -> InjectorProviderFn:
+        raise NotImplementedError
 
-    @dc.dataclass(frozen=True)
-    class Log:
-        file: ta.Optional[str] = None
-        capture_maxbytes: ta.Optional[int] = None
-        events_enabled: bool = False
-        syslog: bool = False
-        backups: ta.Optional[int] = None
-        maxbytes: ta.Optional[int] = None
 
-    stdout: Log = Log()
-    stderr: Log = Log()
+##
 
-    stopsignal: int = signal.SIGTERM
-    stopwaitsecs: int = 10
-    stopasgroup: bool = False
 
-    killasgroup: bool = False
+@dc.dataclass(frozen=True)
+class InjectorBinding:
+    key: InjectorKey
+    provider: InjectorProvider
 
-    exitcodes: ta.Sequence[int] = (0,)
 
-    redirect_stderr: bool = False
+class InjectorBindings(abc.ABC):
+    @abc.abstractmethod
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        raise NotImplementedError
 
-    environment: ta.Optional[ta.Mapping[str, str]] = None
+##
+
+
+class Injector(abc.ABC):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(self, obj: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+
+###
+# exceptions
 
 
 @dc.dataclass(frozen=True)
-class ProcessGroupConfig:
+class InjectorKeyError(Exception):
+    key: InjectorKey
+
+    source: ta.Any = None
+    name: ta.Optional[str] = None
+
+
+@dc.dataclass(frozen=True)
+class UnboundInjectorKeyError(InjectorKeyError):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class DuplicateInjectorKeyError(InjectorKeyError):
+    pass
+
+
+###
+# keys
+
+
+def as_injector_key(o: ta.Any) -> InjectorKey:
+    if o is inspect.Parameter.empty:
+        raise TypeError(o)
+    if isinstance(o, InjectorKey):
+        return o
+    if isinstance(o, (type, ta.NewType)):
+        return InjectorKey(o)
+    raise TypeError(o)
+
+
+###
+# providers
+
+
+@dc.dataclass(frozen=True)
+class FnInjectorProvider(InjectorProvider):
+    fn: ta.Any
+
+    def __post_init__(self) -> None:
+        check_not_isinstance(self.fn, type)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.inject(self.fn)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class CtorInjectorProvider(InjectorProvider):
+    cls: type
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.cls, type)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.inject(self.cls)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class ConstInjectorProvider(InjectorProvider):
+    v: ta.Any
+
+    def provider_fn(self) -> InjectorProviderFn:
+        return lambda _: self.v
+
+
+@dc.dataclass(frozen=True)
+class SingletonInjectorProvider(InjectorProvider):
+    p: InjectorProvider
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.p, InjectorProvider)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        v = not_set = object()
+
+        def pfn(i: Injector) -> ta.Any:
+            nonlocal v
+            if v is not_set:
+                v = ufn(i)
+            return v
+
+        ufn = self.p.provider_fn()
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class LinkInjectorProvider(InjectorProvider):
+    k: InjectorKey
+
+    def __post_init__(self) -> None:
+        check_isinstance(self.k, InjectorKey)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            return i.provide(self.k)
+
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class ArrayInjectorProvider(InjectorProvider):
+    ps: ta.Sequence[InjectorProvider]
+
+    def provider_fn(self) -> InjectorProviderFn:
+        ps = [p.provider_fn() for p in self.ps]
+
+        def pfn(i: Injector) -> ta.Any:
+            rv = []
+            for ep in ps:
+                o = ep(i)
+                rv.append(o)
+            return rv
+
+        return pfn
+
+
+###
+# bindings
+
+
+@dc.dataclass(frozen=True)
+class _InjectorBindings(InjectorBindings):
+    bs: ta.Optional[ta.Sequence[InjectorBinding]] = None
+    ps: ta.Optional[ta.Sequence[InjectorBindings]] = None
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        if self.bs is not None:
+            yield from self.bs
+        if self.ps is not None:
+            for p in self.ps:
+                yield from p.bindings()
+
+
+def as_injector_bindings(*args: InjectorBindingOrBindings) -> InjectorBindings:
+    bs: ta.List[InjectorBinding] = []
+    ps: ta.List[InjectorBindings] = []
+    for a in args:
+        if isinstance(a, InjectorBindings):
+            ps.append(a)
+        elif isinstance(a, InjectorBinding):
+            bs.append(a)
+        else:
+            raise TypeError(a)
+    return _InjectorBindings(
+        bs or None,
+        ps or None,
+    )
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class OverridesInjectorBindings(InjectorBindings):
+    p: InjectorBindings
+    m: ta.Mapping[InjectorKey, InjectorBinding]
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        for b in self.p.bindings():
+            yield self.m.get(b.key, b)
+
+
+def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    m: ta.Dict[InjectorKey, InjectorBinding] = {}
+    for b in as_injector_bindings(*args).bindings():
+        if b.key in m:
+            raise DuplicateInjectorKeyError(b.key)
+        m[b.key] = b
+    return OverridesInjectorBindings(p, m)
+
+
+##
+
+
+def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey, InjectorProvider]:
+    pm: ta.Dict[InjectorKey, InjectorProvider] = {}
+    am: ta.Dict[InjectorKey, ta.List[InjectorProvider]] = {}
+
+    for b in bs.bindings():
+        if b.key.array:
+            am.setdefault(b.key, []).append(b.provider)
+        else:
+            if b.key in pm:
+                raise KeyError(b.key)
+            pm[b.key] = b.provider
+
+    if am:
+        for k, aps in am.items():
+            pm[k] = ArrayInjectorProvider(aps)
+
+    return pm
+
+
+###
+# inspection
+
+
+_INJECTION_SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+
+
+def _injection_signature(obj: ta.Any) -> inspect.Signature:
+    try:
+        return _INJECTION_SIGNATURE_CACHE[obj]
+    except TypeError:
+        return inspect.signature(obj)
+    except KeyError:
+        pass
+    sig = inspect.signature(obj)
+    _INJECTION_SIGNATURE_CACHE[obj] = sig
+    return sig
+
+
+class InjectionKwarg(ta.NamedTuple):
     name: str
+    key: InjectorKey
+    has_default: bool
+
+
+class InjectionKwargsTarget(ta.NamedTuple):
+    obj: ta.Any
+    kwargs: ta.Sequence[InjectionKwarg]
+
+
+def build_injection_kwargs_target(
+        obj: ta.Any,
+        *,
+        skip_args: int = 0,
+        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        raw_optional: bool = False,
+) -> InjectionKwargsTarget:
+    sig = _injection_signature(obj)
+
+    seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
+    kws: ta.List[InjectionKwarg] = []
+    for p in list(sig.parameters.values())[skip_args:]:
+        if p.annotation is inspect.Signature.empty:
+            if p.default is not inspect.Parameter.empty:
+                raise KeyError(f'{obj}, {p.name}')
+            continue
+
+        if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            raise TypeError(sig)
+
+        ann = p.annotation
+        if (
+                not raw_optional and
+                is_optional_alias(ann)
+        ):
+            ann = get_optional_alias_arg(ann)
+
+        k = as_injector_key(ann)
+
+        if k in seen:
+            raise DuplicateInjectorKeyError(k)
+        seen.add(k)
+
+        kws.append(InjectionKwarg(
+            p.name,
+            k,
+            p.default is not inspect.Parameter.empty,
+        ))
+
+    return InjectionKwargsTarget(
+        obj,
+        kws,
+    )
+
+
+###
+# binder
+
+
+class InjectorBinder:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    _FN_TYPES: ta.Tuple[type, ...] = (
+        types.FunctionType,
+        types.MethodType,
+
+        classmethod,
+        staticmethod,
+
+        functools.partial,
+        functools.partialmethod,
+    )
+
+    @classmethod
+    def _is_fn(cls, obj: ta.Any) -> bool:
+        return isinstance(obj, cls._FN_TYPES)
+
+    @classmethod
+    def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
+        check_isinstance(icls, type)
+        if icls not in cls._FN_TYPES:
+            cls._FN_TYPES = (*cls._FN_TYPES, icls)
+        return icls
+
+    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+        InjectorProvider,
+    )
+
+    @classmethod
+    def bind(
+            cls,
+            obj: ta.Any,
+            *,
+            key: ta.Any = None,
+            tag: ta.Any = None,
+            array: ta.Optional[bool] = None,  # noqa
+
+            to_fn: ta.Any = None,
+            to_ctor: ta.Any = None,
+            to_const: ta.Any = None,
+            to_key: ta.Any = None,
+
+            singleton: bool = False,
+    ) -> InjectorBinding:
+        if obj is None or obj is inspect.Parameter.empty:
+            raise TypeError(obj)
+        if isinstance(obj, cls._BANNED_BIND_TYPES):
+            raise TypeError(obj)
+
+        ##
+
+        if key is not None:
+            key = as_injector_key(key)
+
+        ##
+
+        has_to = (
+            to_fn is not None or
+            to_ctor is not None or
+            to_const is not None or
+            to_key is not None
+        )
+        if isinstance(obj, InjectorKey):
+            if key is None:
+                key = obj
+        elif isinstance(obj, type):
+            if not has_to:
+                to_ctor = obj
+            if key is None:
+                key = InjectorKey(obj)
+        elif cls._is_fn(obj) and not has_to:
+            to_fn = obj
+            if key is None:
+                sig = _injection_signature(obj)
+                ty = check_isinstance(sig.return_annotation, type)
+                key = InjectorKey(ty)
+        else:
+            if to_const is not None:
+                raise TypeError('Cannot bind instance with to_const')
+            to_const = obj
+            if key is None:
+                key = InjectorKey(type(obj))
+        del has_to
+
+        ##
+
+        if tag is not None:
+            if key.tag is not None:
+                raise TypeError('Tag already set')
+            key = dc.replace(key, tag=tag)
+
+        if array is not None:
+            key = dc.replace(key, array=array)
+
+        ##
+
+        providers: ta.List[InjectorProvider] = []
+        if to_fn is not None:
+            providers.append(FnInjectorProvider(to_fn))
+        if to_ctor is not None:
+            providers.append(CtorInjectorProvider(to_ctor))
+        if to_const is not None:
+            providers.append(ConstInjectorProvider(to_const))
+        if to_key is not None:
+            providers.append(LinkInjectorProvider(as_injector_key(to_key)))
+        if not providers:
+            raise TypeError('Must specify provider')
+        if len(providers) > 1:
+            raise TypeError('May not specify multiple providers')
+        provider, = providers
+
+        ##
+
+        if singleton:
+            provider = SingletonInjectorProvider(provider)
+
+        ##
+
+        binding = InjectorBinding(key, provider)
+
+        ##
+
+        return binding
 
-    priority: int = 999
 
-    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
+###
+# injector
 
 
-@dc.dataclass(frozen=True)
-class ServerConfig:
-    user: ta.Optional[str] = None
-    nodaemon: bool = False
-    umask: int = 0o22
-    directory: ta.Optional[str] = None
-    logfile: str = 'supervisord.log'
-    logfile_maxbytes: int = 50 * 1024 * 1024
-    logfile_backups: int = 10
-    loglevel: int = logging.INFO
-    pidfile: str = 'supervisord.pid'
-    identifier: str = 'supervisor'
-    child_logdir: str = '/dev/null'
-    minfds: int = 1024
-    minprocs: int = 200
-    nocleanup: bool = False
-    strip_ansi: bool = False
-    silent: bool = False
+_INJECTOR_INJECTOR_KEY = InjectorKey(Injector)
 
-    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
 
-    @classmethod
-    def new(
-            cls,
-            umask: ta.Union[int, str] = 0o22,
-            directory: ta.Optional[str] = None,
-            logfile: str = 'supervisord.log',
-            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
-            loglevel: ta.Union[int, str] = logging.INFO,
-            pidfile: str = 'supervisord.pid',
-            child_logdir: ta.Optional[str] = None,
-            **kwargs: ta.Any,
-    ) -> 'ServerConfig':
-        return cls(
-            umask=octal_type(umask),
-            directory=existing_directory(directory) if directory is not None else None,
-            logfile=existing_dirpath(logfile),
-            logfile_maxbytes=byte_size(logfile_maxbytes),
-            loglevel=logging_level(loglevel),
-            pidfile=existing_dirpath(pidfile),
-            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
-            **kwargs,
-        )
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
 
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
 
-########################################
-# ../states.py
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
 
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
-##
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
 
+        if key == _INJECTOR_INJECTOR_KEY:
+            return Maybe.just(self)
 
-def _names_by_code(states: ta.Any) -> ta.Dict[int, str]:
-    d = {}
-    for name in states.__dict__:
-        if not name.startswith('__'):
-            code = getattr(states, name)
-            d[code] = name
-    return d
+        fn = self._pfm.get(key)
+        if fn is not None:
+            return Maybe.just(fn(self))
 
+        if self._p is not None:
+            pv = self._p.try_provide(key)
+            if pv is not None:
+                return Maybe.empty()
 
-##
+        return Maybe.empty()
 
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
 
-class ProcessStates:
-    STOPPED = 0
-    STARTING = 10
-    RUNNING = 20
-    BACKOFF = 30
-    STOPPING = 40
-    EXITED = 100
-    FATAL = 200
-    UNKNOWN = 1000
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(obj)
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
 
+    def inject(self, obj: ta.Any) -> ta.Any:
+        kws = self.provide_kwargs(obj)
+        return obj(**kws)
 
-STOPPED_STATES = (
-    ProcessStates.STOPPED,
-    ProcessStates.EXITED,
-    ProcessStates.FATAL,
-    ProcessStates.UNKNOWN,
-)
 
-RUNNING_STATES = (
-    ProcessStates.RUNNING,
-    ProcessStates.BACKOFF,
-    ProcessStates.STARTING,
-)
+###
+# injection helpers
 
-SIGNALLABLE_STATES = (
-    ProcessStates.RUNNING,
-    ProcessStates.STARTING,
-    ProcessStates.STOPPING,
-)
 
+class Injection:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
 
-_process_states_by_code = _names_by_code(ProcessStates)
+    # keys
 
+    @classmethod
+    def as_key(cls, o: ta.Any) -> InjectorKey:
+        return as_injector_key(o)
 
-def get_process_state_description(code: ProcessState) -> str:
-    return check_not_none(_process_states_by_code.get(code))
+    @classmethod
+    def array(cls, o: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), array=True)
 
+    @classmethod
+    def tag(cls, o: ta.Any, t: ta.Any) -> InjectorKey:
+        return dc.replace(as_injector_key(o), tag=t)
 
-##
+    # bindings
 
+    @classmethod
+    def as_bindings(cls, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return as_injector_bindings(*args)
 
-class SupervisorStates:
-    FATAL = 2
-    RUNNING = 1
-    RESTARTING = 0
-    SHUTDOWN = -1
+    @classmethod
+    def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+        return injector_override(p, *args)
 
+    # binder
 
-_supervisor_states_by_code = _names_by_code(SupervisorStates)
+    @classmethod
+    def bind(
+            cls,
+            obj: ta.Any,
+            *,
+            key: ta.Any = None,
+            tag: ta.Any = None,
+            array: ta.Optional[bool] = None,  # noqa
+
+            to_fn: ta.Any = None,
+            to_ctor: ta.Any = None,
+            to_const: ta.Any = None,
+            to_key: ta.Any = None,
+
+            singleton: bool = False,
+    ) -> InjectorBinding:
+        return InjectorBinder.bind(
+            obj,
+
+            key=key,
+            tag=tag,
+            array=array,
+
+            to_fn=to_fn,
+            to_ctor=to_ctor,
+            to_const=to_const,
+            to_key=to_key,
+
+            singleton=singleton,
+        )
 
+    # injector
 
-def get_supervisor_state_description(code: SupervisorState) -> str:
-    return check_not_none(_supervisor_states_by_code.get(code))
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), p)
+
+
+inj = Injection
 
 
 ########################################
@@ -1575,6 +2973,66 @@ def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
     return get_obj_marshaler(ty).unmarshal(o)
 
 
+########################################
+# ../../configs.py
+
+
+def read_config_file(
+        path: str,
+        cls: ta.Type[T],
+        *,
+        prepare: ta.Optional[ta.Callable[[ConfigMapping], ConfigMapping]] = None,
+) -> T:
+    with open(path) as cf:
+        if path.endswith('.toml'):
+            config_dct = toml_loads(cf.read())
+        else:
+            config_dct = json.loads(cf.read())
+
+    if prepare is not None:
+        config_dct = prepare(config_dct)  # type: ignore
+
+    return unmarshal_obj(config_dct, cls)
+
+
+def build_config_named_children(
+        o: ta.Union[
+            ta.Sequence[ConfigMapping],
+            ta.Mapping[str, ConfigMapping],
+            None,
+        ],
+        *,
+        name_key: str = 'name',
+) -> ta.Optional[ta.Sequence[ConfigMapping]]:
+    if o is None:
+        return None
+
+    lst: ta.List[ConfigMapping] = []
+    if isinstance(o, ta.Mapping):
+        for k, v in o.items():
+            check_isinstance(v, ta.Mapping)
+            if name_key in v:
+                n = v[name_key]
+                if k != n:
+                    raise KeyError(f'Given names do not match: {n} != {k}')
+                lst.append(v)
+            else:
+                lst.append({name_key: k, **v})
+
+    else:
+        check_not_isinstance(o, str)
+        lst.extend(o)
+
+    seen = set()
+    for d in lst:
+        n = d['name']
+        if n in d:
+            raise KeyError(f'Duplicate name: {n}')
+        seen.add(n)
+
+    return lst
+
+
 ########################################
 # ../events.py
 
@@ -1602,12 +3060,9 @@ class EventCallbacks:
 
 EVENT_CALLBACKS = EventCallbacks()
 
-notify_event = EVENT_CALLBACKS.notify
-clear_events = EVENT_CALLBACKS.clear
-
 
 class Event(abc.ABC):  # noqa
-    """Abstract event type """
+    """Abstract event type."""
 
 
 class ProcessLogEvent(Event, abc.ABC):
@@ -1687,7 +3142,7 @@ class RemoteCommunicationEvent(Event):
 
 
 class SupervisorStateChangeEvent(Event):
-    """ Abstract class """
+    """Abstract class."""
 
     def payload(self):
         return ''
@@ -1709,7 +3164,7 @@ class EventRejectedEvent:  # purposely does not subclass Event
 
 
 class ProcessStateEvent(Event):
-    """ Abstract class, never raised directly """
+    """Abstract class, never raised directly."""
     frm = None
     to = None
 
@@ -1798,7 +3253,7 @@ class ProcessGroupRemovedEvent(ProcessGroupEvent):
 
 
 class TickEvent(Event):
-    """ Abstract """
+    """Abstract."""
 
     def __init__(self, when, supervisord):
         super().__init__()
@@ -2080,34 +3535,155 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
 
             return readables, writables
 
-        def before_daemonize(self) -> None:
-            self.close()
+        def before_daemonize(self) -> None:
+            self.close()
+
+        def after_daemonize(self) -> None:
+            self._kqueue = select.kqueue()
+            for fd in self._readables:
+                self.register_readable(fd)
+            for fd in self._writables:
+                self.register_writable(fd)
+
+        def close(self) -> None:
+            self._kqueue.close()  # type: ignore
+            self._kqueue = None
+
+else:
+    KqueuePoller = None
+
+
+Poller: ta.Type[BasePoller]
+if (
+        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
+        hasattr(select, 'kqueue') and KqueuePoller is not None
+):
+    Poller = KqueuePoller
+elif hasattr(select, 'poll'):
+    Poller = PollPoller
+else:
+    Poller = SelectPoller
+
+
+########################################
+# ../configs.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ProcessConfig:
+    name: str
+    command: str
+
+    uid: ta.Optional[int] = None
+    directory: ta.Optional[str] = None
+    umask: ta.Optional[int] = None
+    priority: int = 999
+
+    autostart: bool = True
+    autorestart: str = 'unexpected'
+
+    startsecs: int = 1
+    startretries: int = 3
+
+    numprocs: int = 1
+    numprocs_start: int = 0
+
+    @dc.dataclass(frozen=True)
+    class Log:
+        file: ta.Optional[str] = None
+        capture_maxbytes: ta.Optional[int] = None
+        events_enabled: bool = False
+        syslog: bool = False
+        backups: ta.Optional[int] = None
+        maxbytes: ta.Optional[int] = None
+
+    stdout: Log = Log()
+    stderr: Log = Log()
+
+    stopsignal: int = signal.SIGTERM
+    stopwaitsecs: int = 10
+    stopasgroup: bool = False
+
+    killasgroup: bool = False
+
+    exitcodes: ta.Sequence[int] = (0,)
+
+    redirect_stderr: bool = False
+
+    environment: ta.Optional[ta.Mapping[str, str]] = None
+
+
+@dc.dataclass(frozen=True)
+class ProcessGroupConfig:
+    name: str
+
+    priority: int = 999
+
+    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
+
+
+@dc.dataclass(frozen=True)
+class ServerConfig:
+    user: ta.Optional[str] = None
+    nodaemon: bool = False
+    umask: int = 0o22
+    directory: ta.Optional[str] = None
+    logfile: str = 'supervisord.log'
+    logfile_maxbytes: int = 50 * 1024 * 1024
+    logfile_backups: int = 10
+    loglevel: int = logging.INFO
+    pidfile: str = 'supervisord.pid'
+    identifier: str = 'supervisor'
+    child_logdir: str = '/dev/null'
+    minfds: int = 1024
+    minprocs: int = 200
+    nocleanup: bool = False
+    strip_ansi: bool = False
+    silent: bool = False
+
+    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
+
+    @classmethod
+    def new(
+            cls,
+            umask: ta.Union[int, str] = 0o22,
+            directory: ta.Optional[str] = None,
+            logfile: str = 'supervisord.log',
+            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
+            loglevel: ta.Union[int, str] = logging.INFO,
+            pidfile: str = 'supervisord.pid',
+            child_logdir: ta.Optional[str] = None,
+            **kwargs: ta.Any,
+    ) -> 'ServerConfig':
+        return cls(
+            umask=octal_type(umask),
+            directory=existing_directory(directory) if directory is not None else None,
+            logfile=existing_dirpath(logfile),
+            logfile_maxbytes=byte_size(logfile_maxbytes),
+            loglevel=logging_level(loglevel),
+            pidfile=existing_dirpath(pidfile),
+            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
+            **kwargs,
+        )
+
 
-        def after_daemonize(self) -> None:
-            self._kqueue = select.kqueue()
-            for fd in self._readables:
-                self.register_readable(fd)
-            for fd in self._writables:
-                self.register_writable(fd)
+##
 
-        def close(self) -> None:
-            self._kqueue.close()  # type: ignore
-            self._kqueue = None
 
-else:
-    KqueuePoller = None
+def prepare_process_group_config(dct: ConfigMapping) -> ConfigMapping:
+    out = dict(dct)
+    out['processes'] = build_config_named_children(out.get('processes'))
+    return out
 
 
-Poller: ta.Type[BasePoller]
-if (
-        sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
-        hasattr(select, 'kqueue') and KqueuePoller is not None
-):
-    Poller = KqueuePoller
-elif hasattr(select, 'poll'):
-    Poller = PollPoller
-else:
-    Poller = SelectPoller
+def prepare_server_config(dct: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.Any]:
+    out = dict(dct)
+    group_dcts = build_config_named_children(out.get('groups'))
+    out['groups'] = [prepare_process_group_config(group_dct) for group_dct in group_dcts or []]
+    return out
 
 
 ########################################
@@ -2134,6 +3710,11 @@ class AbstractServerContext(abc.ABC):
     def pid_history(self) -> ta.Dict[int, 'AbstractSubprocess']:
         raise NotImplementedError
 
+    @property
+    @abc.abstractmethod
+    def inherited_fds(self) -> ta.FrozenSet[int]:
+        raise NotImplementedError
+
 
 class AbstractSubprocess(abc.ABC):
     @property
@@ -2165,12 +3746,14 @@ class ServerContext(AbstractServerContext):
             self,
             config: ServerConfig,
             *,
-            epoch: int = 0,
+            epoch: ServerEpoch = ServerEpoch(0),
+            inherited_fds: ta.Optional[InheritedFds] = None,
     ) -> None:
         super().__init__()
 
         self._config = config
         self._epoch = epoch
+        self._inherited_fds = InheritedFds(frozenset(inherited_fds or []))
 
         self._pid_history: ta.Dict[int, AbstractSubprocess] = {}
         self._state: SupervisorState = SupervisorStates.RUNNING
@@ -2194,7 +3777,7 @@ class ServerContext(AbstractServerContext):
         return self._config
 
     @property
-    def epoch(self) -> int:
+    def epoch(self) -> ServerEpoch:
         return self._epoch
 
     @property
@@ -2224,6 +3807,10 @@ class ServerContext(AbstractServerContext):
     def gid(self) -> ta.Optional[int]:
         return self._gid
 
+    @property
+    def inherited_fds(self) -> InheritedFds:
+        return self._inherited_fds
+
     ##
 
     def set_signals(self) -> None:
@@ -2752,10 +4339,10 @@ class OutputDispatcher(Dispatcher):
 
             if self._channel == 'stdout':
                 if self._stdout_events_enabled:
-                    notify_event(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+                    EVENT_CALLBACKS.notify(ProcessLogStdoutEvent(self._process, self._process.pid, data))
 
             elif self._stderr_events_enabled:
-                notify_event(ProcessLogStderrEvent(self._process, self._process.pid, data))
+                EVENT_CALLBACKS.notify(ProcessLogStderrEvent(self._process, self._process.pid, data))
 
     def record_output(self):
         if self._capture_log is None:
@@ -2806,7 +4393,7 @@ class OutputDispatcher(Dispatcher):
                 channel = self._channel
                 procname = self._process.config.name
                 event = self.event_type(self._process, self._process.pid, data)
-                notify_event(event)
+                EVENT_CALLBACKS.notify(event)
 
                 log.debug('%r %s emitted a comm event', procname, channel)
                 for handler in self._capture_log.handlers:
@@ -2867,6 +4454,9 @@ class InputDispatcher(Dispatcher):
 # ../process.py
 
 
+##
+
+
 @functools.total_ordering
 class Subprocess(AbstractSubprocess):
     """A class to manage a subprocess."""
@@ -2892,7 +4482,12 @@ class Subprocess(AbstractSubprocess):
     spawn_err = None  # error message attached by spawn() if any
     group = None  # ProcessGroup instance if process is in the group
 
-    def __init__(self, config: ProcessConfig, group: 'ProcessGroup', context: AbstractServerContext) -> None:
+    def __init__(
+            self,
+            config: ProcessConfig,
+            group: 'ProcessGroup',
+            context: AbstractServerContext,
+    ) -> None:
         super().__init__()
         self._config = config
         self.group = group
@@ -3019,7 +4614,7 @@ class Subprocess(AbstractSubprocess):
         event_class = self.event_map.get(new_state)
         if event_class is not None:
             event = event_class(self, old_state, expected)
-            notify_event(event)
+            EVENT_CALLBACKS.notify(event)
 
         return True
 
@@ -3136,7 +4731,10 @@ class Subprocess(AbstractSubprocess):
             os.dup2(self._pipes['child_stdout'], 2)
         else:
             os.dup2(self._pipes['child_stderr'], 2)
+
         for i in range(3, self.context.config.minfds):
+            if i in self.context.inherited_fds:
+                continue
             close_fd(i)
 
     def _spawn_as_child(self, filename: str, argv: ta.Sequence[str]) -> None:
@@ -3171,7 +4769,7 @@ class Subprocess(AbstractSubprocess):
             cwd = self.config.directory
             try:
                 if cwd is not None:
-                    os.chdir(cwd)
+                    os.chdir(os.path.expanduser(cwd))
             except OSError as why:
                 code = errno.errorcode.get(why.args[0], why.args[0])
                 msg = f"couldn't chdir to {cwd}: {code}\n"
@@ -3227,7 +4825,7 @@ class Subprocess(AbstractSubprocess):
         return self.kill(self.config.stopsignal)
 
     def stop_report(self) -> None:
-        """ Log a 'waiting for x to stop' message with throttling. """
+        """Log a 'waiting for x to stop' message with throttling."""
         if self.state == ProcessStates.STOPPING:
             now = time.time()
 
@@ -3357,7 +4955,7 @@ class Subprocess(AbstractSubprocess):
         return None
 
     def finish(self, sts: int) -> None:
-        """ The process was reaped and we need to report and manage its state """
+        """The process was reaped and we need to report and manage its state."""
 
         self.drain()
 
@@ -3438,7 +5036,7 @@ class Subprocess(AbstractSubprocess):
         # system that this event was rejected so it can be processed again.
         if self.event is not None:
             # Note: this should only be true if we were in the BUSY state when finish() was called.
-            notify_event(EventRejectedEvent(self, self.event))  # type: ignore
+            EVENT_CALLBACKS.notify(EventRejectedEvent(self, self.event))  # type: ignore
             self.event = None
 
     def set_uid(self) -> ta.Optional[str]:
@@ -3530,15 +5128,39 @@ class Subprocess(AbstractSubprocess):
         pass
 
 
+##
+
+
+@dc.dataclass(frozen=True)
+class SubprocessFactory:
+    fn: ta.Callable[[ProcessConfig, 'ProcessGroup'], Subprocess]
+
+    def __call__(self, config: ProcessConfig, group: 'ProcessGroup') -> Subprocess:
+        return self.fn(config, group)
+
+
 @functools.total_ordering
 class ProcessGroup:
-    def __init__(self, config: ProcessGroupConfig, context: ServerContext):
+    def __init__(
+            self,
+            config: ProcessGroupConfig,
+            context: ServerContext,
+            *,
+            subprocess_factory: ta.Optional[SubprocessFactory] = None,
+    ):
         super().__init__()
         self.config = config
         self.context = context
+
+        if subprocess_factory is None:
+            def make_subprocess(config: ProcessConfig, group: ProcessGroup) -> Subprocess:
+                return Subprocess(config, group, self.context)
+            subprocess_factory = SubprocessFactory(make_subprocess)
+        self._subprocess_factory = subprocess_factory
+
         self.processes = {}
         for pconfig in self.config.processes or []:
-            process = Subprocess(pconfig, self, self.context)
+            process = self._subprocess_factory(pconfig, self)
             self.processes[pconfig.name] = process
 
     def __lt__(self, other):
@@ -3604,22 +5226,44 @@ class ProcessGroup:
 # ../supervisor.py
 
 
-def timeslice(period, when):
+def timeslice(period: int, when: float) -> int:
     return int(when - (when % period))
 
 
+@dc.dataclass(frozen=True)
+class ProcessGroupFactory:
+    fn: ta.Callable[[ProcessGroupConfig], ProcessGroup]
+
+    def __call__(self, config: ProcessGroupConfig) -> ProcessGroup:
+        return self.fn(config)
+
+
 class Supervisor:
 
-    def __init__(self, context: ServerContext) -> None:
+    def __init__(
+            self,
+            context: ServerContext,
+            *,
+            process_group_factory: ta.Optional[ProcessGroupFactory] = None,
+    ) -> None:
         super().__init__()
 
         self._context = context
+
+        if process_group_factory is None:
+            def make_process_group(config: ProcessGroupConfig) -> ProcessGroup:
+                return ProcessGroup(config, self._context)
+            process_group_factory = ProcessGroupFactory(make_process_group)
+        self._process_group_factory = process_group_factory
+
         self._ticks: ta.Dict[int, float] = {}
         self._process_groups: ta.Dict[str, ProcessGroup] = {}  # map of process group name to process group object
         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) -> ServerContext:
         return self._context
@@ -3627,58 +5271,7 @@ class Supervisor:
     def get_state(self) -> SupervisorState:
         return self._context.state
 
-    def main(self) -> None:
-        self.setup()
-        self.run()
-
-    @cached_nullary
-    def setup(self) -> None:
-        if not self._context.first:
-            # prevent crash on libdispatch-based systems, at least for the first request
-            self._context.cleanup_fds()
-
-        self._context.set_uid_or_exit()
-
-        if self._context.first:
-            self._context.set_rlimits_or_exit()
-
-        # this sets the options.logger object delay logger instantiation until after setuid
-        if not self._context.config.nocleanup:
-            # clean up old automatic logs
-            self._context.clear_auto_child_logdir()
-
-    def run(
-            self,
-            *,
-            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
-    ) -> None:
-        self._process_groups = {}  # clear
-        self._stop_groups = None  # clear
-
-        clear_events()
-
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
-
-            self._context.set_signals()
-
-            if not self._context.config.nodaemon and self._context.first:
-                self._context.daemonize()
-
-            # writing pid file needs to come *after* daemonizing or pid will be wrong
-            self._context.write_pidfile()
-
-            notify_event(SupervisorRunningEvent())
-
-            while True:
-                if callback is not None and not callback(self):
-                    break
-
-                self._run_once()
-
-        finally:
-            self._context.cleanup()
+    #
 
     class DiffToActive(ta.NamedTuple):
         added: ta.List[ProcessGroupConfig]
@@ -3704,10 +5297,10 @@ class Supervisor:
         if name in self._process_groups:
             return False
 
-        group = self._process_groups[name] = ProcessGroup(config, self._context)
+        group = self._process_groups[name] = self._process_group_factory(config)
         group.after_setuid()
 
-        notify_event(ProcessGroupAddedEvent(name))
+        EVENT_CALLBACKS.notify(ProcessGroupAddedEvent(name))
         return True
 
     def remove_process_group(self, name: str) -> bool:
@@ -3718,7 +5311,7 @@ class Supervisor:
 
         del self._process_groups[name]
 
-        notify_event(ProcessGroupRemovedEvent(name))
+        EVENT_CALLBACKS.notify(ProcessGroupRemovedEvent(name))
         return True
 
     def get_process_map(self) -> ta.Dict[int, Dispatcher]:
@@ -3747,6 +5340,72 @@ class Supervisor:
 
         return unstopped
 
+    #
+
+    def main(self) -> None:
+        self.setup()
+        self.run()
+
+    @cached_nullary
+    def setup(self) -> None:
+        if not self._context.first:
+            # prevent crash on libdispatch-based systems, at least for the first request
+            self._context.cleanup_fds()
+
+        self._context.set_uid_or_exit()
+
+        if self._context.first:
+            self._context.set_rlimits_or_exit()
+
+        # this sets the options.logger object delay logger instantiation until after setuid
+        if not self._context.config.nocleanup:
+            # clean up old automatic logs
+            self._context.clear_auto_child_logdir()
+
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups = {}  # clear
+        self._stop_groups = None  # clear
+
+        EVENT_CALLBACKS.clear()
+
+        try:
+            for config in self._context.config.groups or []:
+                self.add_process_group(config)
+
+            self._context.set_signals()
+
+            if not self._context.config.nodaemon and self._context.first:
+                self._context.daemonize()
+
+            # writing pid file needs to come *after* daemonizing or pid will be wrong
+            self._context.write_pidfile()
+
+            EVENT_CALLBACKS.notify(SupervisorRunningEvent())
+
+            while True:
+                if callback is not None and not callback(self):
+                    break
+
+                self._run_once()
+
+        finally:
+            self._context.cleanup()
+
+    #
+
+    def _run_once(self) -> None:
+        self._poll()
+        self._reap()
+        self._handle_signal()
+        self._tick()
+
+        if self._context.state < SupervisorStates.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)
@@ -3763,7 +5422,7 @@ class Supervisor:
                 # down, so push it back on to the end of the stop group queue
                 self._stop_groups.append(group)
 
-    def _run_once(self) -> None:
+    def _poll(self) -> None:
         combined_map = {}
         combined_map.update(self.get_process_map())
 
@@ -3775,7 +5434,7 @@ class Supervisor:
                 # first time, set the stopping flag, do a notification and set stop_groups
                 self._stopping = True
                 self._stop_groups = pgroups[:]
-                notify_event(SupervisorStoppingEvent())
+                EVENT_CALLBACKS.notify(SupervisorStoppingEvent())
 
             self._ordered_stop_groups_phase_1()
 
@@ -3835,33 +5494,6 @@ class Supervisor:
         for group in pgroups:
             group.transition()
 
-        self._reap()
-        self._handle_signal()
-        self._tick()
-
-        if self._context.state < SupervisorStates.RUNNING:
-            self._ordered_stop_groups_phase_2()
-
-    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  # type: ignore
-
-            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
-                notify_event(event(this_tick, self))
-
     def _reap(self, *, once: bool = False, depth: int = 0) -> None:
         if depth >= 100:
             return
@@ -3910,11 +5542,78 @@ class Supervisor:
         else:
             log.debug('received %s indicating nothing', signame(sig))
 
+    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  # type: ignore
+
+            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
+                EVENT_CALLBACKS.notify(event(this_tick, self))
+
 
 ########################################
 # main.py
 
 
+##
+
+
+def build_server_bindings(
+        config: ServerConfig,
+        *,
+        server_epoch: ta.Optional[ServerEpoch] = None,
+        inherited_fds: ta.Optional[InheritedFds] = None,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(config),
+
+        inj.bind(ServerContext, singleton=True),
+        inj.bind(AbstractServerContext, to_key=ServerContext),
+
+        inj.bind(Supervisor, singleton=True),
+    ]
+
+    #
+
+    def make_process_group_factory(injector: Injector) -> ProcessGroupFactory:
+        def inner(group_config: ProcessGroupConfig) -> ProcessGroup:
+            return injector.inject(functools.partial(ProcessGroup, group_config))
+        return ProcessGroupFactory(inner)
+    lst.append(inj.bind(make_process_group_factory))
+
+    def make_subprocess_factory(injector: Injector) -> SubprocessFactory:
+        def inner(process_config: ProcessConfig, group: ProcessGroup) -> Subprocess:
+            return injector.inject(functools.partial(Subprocess, process_config, group))
+        return SubprocessFactory(inner)
+    lst.append(inj.bind(make_subprocess_factory))
+
+    #
+
+    if server_epoch is not None:
+        lst.append(inj.bind(server_epoch, key=ServerEpoch))
+    if inherited_fds is not None:
+        lst.append(inj.bind(inherited_fds, key=InheritedFds))
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+##
+
+
 def main(
         argv: ta.Optional[ta.Sequence[str]] = None,
         *,
@@ -3925,6 +5624,7 @@ def main(
     parser = argparse.ArgumentParser()
     parser.add_argument('config_file', metavar='config-file')
     parser.add_argument('--no-journald', action='store_true')
+    parser.add_argument('--inherit-initial-fds', action='store_true')
     args = parser.parse_args(argv)
 
     #
@@ -3940,20 +5640,27 @@ def main(
 
     #
 
+    initial_fds: ta.Optional[InheritedFds] = None
+    if args.inherit_initial_fds:
+        initial_fds = InheritedFds(get_open_fds(0x10000))
+
     # if we hup, restart by making a new Supervisor()
     for epoch in itertools.count():
-        with open(cf) as f:
-            config_src = f.read()
-
-        config_dct = json.loads(config_src)
-        config: ServerConfig = unmarshal_obj(config_dct, ServerConfig)
+        config = read_config_file(
+            os.path.expanduser(cf),
+            ServerConfig,
+            prepare=prepare_server_config,
+        )
 
-        context = ServerContext(
+        injector = inj.create_injector(build_server_bindings(
             config,
-            epoch=epoch,
-        )
+            server_epoch=ServerEpoch(epoch),
+            inherited_fds=initial_fds,
+        ))
+
+        context = injector.provide(ServerContext)
+        supervisor = injector.provide(Supervisor)
 
-        supervisor = Supervisor(context)
         try:
             supervisor.main()
         except ExitNow: