ominfra 0.0.0.dev192__py3-none-any.whl → 0.0.0.dev194__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -36,6 +36,7 @@ import abc
 import base64
 import collections
 import collections.abc
+import configparser
 import contextlib
 import contextvars
 import ctypes as ct
@@ -79,7 +80,7 @@ import types
 import typing as ta
 import uuid
 import warnings
-import weakref  # noqa
+import weakref
 
 
 ########################################
@@ -92,15 +93,21 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# ../../omdev/toml/parser.py
-TomlParseFloat = ta.Callable[[str], ta.Any]
-TomlKey = ta.Tuple[str, ...]
-TomlPos = int  # ta.TypeAlias
-
 # utils/collections.py
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
+# ../../omlish/configs/types.py
+ConfigMap = ta.Mapping[str, ta.Any]
+
+# ../../omlish/formats/ini/sections.py
+IniSectionSettingsMap = ta.Mapping[str, ta.Mapping[str, ta.Union[str, ta.Sequence[str]]]]  # ta.TypeAlias
+
+# ../../omlish/formats/toml/parser.py
+TomlParseFloat = ta.Callable[[str], ta.Any]
+TomlKey = ta.Tuple[str, ...]
+TomlPos = int  # ta.TypeAlias
+
 # ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -125,6 +132,9 @@ SocketAddress = ta.Any
 EventCallback = ta.Callable[['Event'], None]
 ProcessOutputChannel = ta.Literal['stdout', 'stderr']  # ta.TypeAlias
 
+# ../../omlish/configs/formats.py
+ConfigDataT = ta.TypeVar('ConfigDataT', bound='ConfigData')
+
 # ../../omlish/http/parsing.py
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
@@ -141,10 +151,6 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 # ../../omlish/sockets/handlers.py
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
 
-# ../configs.py
-ConfigMapping = ta.Mapping[str, ta.Any]
-IniConfigSectionSettingsMap = ta.Mapping[str, ta.Mapping[str, ta.Union[str, ta.Sequence[str]]]]  # ta.TypeAlias
-
 # ../../omlish/http/handlers.py
 HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']  # ta.TypeAlias
 
@@ -153,1291 +159,1462 @@ CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
 
 ########################################
-# ../../../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
+# ../exceptions.py
 
 
-##
+class ProcessError(Exception):
+    """Specialized exceptions used when attempting to start a process."""
 
 
-_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]*)?'
+class BadCommandError(ProcessError):
+    """Indicates the command could not be parsed properly."""
 
-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,
-)
 
+class NotExecutableError(ProcessError):
+    """
+    Indicates that the filespec cannot be executed because its path resolves to a file which is not executable, or which
+    is a directory.
+    """
 
-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)
+class NotFoundError(ProcessError):
+    """Indicates that the filespec cannot be executed because it could not be found."""
 
 
-@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),
-        ),
-    )
+class NoPermissionError(ProcessError):
+    """
+    Indicates that the file cannot be executed because the supervisor process does not possess the appropriate UNIX
+    filesystem permission to execute the file.
+    """
 
 
-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)
+########################################
+# ../privileges.py
 
 
-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)
+def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
+    """
+    Drop privileges to become the specified user, which may be a username or uid. Called for supervisord startup and
+    when spawning subprocesses. Returns None on success or a string error message if privileges could not be dropped.
+    """
 
+    if user is None:
+        return 'No user specified to setuid to!'
 
-TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+    # get uid for user, which can be a number or username
+    try:
+        uid = int(user)
+    except ValueError:
+        try:
+            pwrec = pwd.getpwnam(user)  # type: ignore
+        except KeyError:
+            return f"Can't find username {user!r}"
+        uid = pwrec[2]
+    else:
+        try:
+            pwrec = pwd.getpwuid(uid)
+        except KeyError:
+            return f"Can't find uid {uid!r}"
 
-# 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')
+    current_uid = os.getuid()
 
-TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
-TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+    if current_uid == uid:
+        # do nothing and return successfully if the uid is already the current one. this allows a supervisord running as
+        # an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in it.
+        return None
 
-TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+    if current_uid != 0:
+        return "Can't drop privilege as nonroot user"
 
-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)
+    gid = pwrec[3]
+    if hasattr(os, 'setgroups'):
+        user = pwrec[0]
+        groups = [grprec[2] for grprec in grp.getgrall() if user in grprec[3]]
 
-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
-    },
-)
+        # always put our primary gid first in this list, otherwise we can lose group info since sometimes the first
+        # group in the setgroups list gets overwritten on the subsequent setgid call (at least on freebsd 9 with
+        # python 2.7 - this will be safe though for all unix /python version combos)
+        groups.insert(0, gid)
+        try:
+            os.setgroups(groups)
+        except OSError:
+            return 'Could not set groups of effective user'
 
+    try:
+        os.setgid(gid)
+    except OSError:
+        return 'Could not set group id of effective user'
 
-class TomlDecodeError(ValueError):
-    """An error raised if a document is not valid TOML."""
+    os.setuid(uid)
 
+    return None
 
-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)
 
+########################################
+# ../states.py
 
-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')
+class ProcessState(enum.IntEnum):
+    STOPPED = 0
+    STARTING = 10
+    RUNNING = 20
+    BACKOFF = 30
+    STOPPING = 40
+    EXITED = 100
+    FATAL = 200
+    UNKNOWN = 1000
 
-        # 3. Skip comment
-        pos = toml_skip_comment(src, pos)
+    @property
+    def stopped(self) -> bool:
+        return self in STOPPED_STATES
 
-        # 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
+    @property
+    def running(self) -> bool:
+        return self in RUNNING_STATES
 
-    return out.data.dict
+    @property
+    def signalable(self) -> bool:
+        return self in SIGNALABLE_STATES
 
 
-class TomlFlags:
-    """Flags that map to parsed keys/namespaces."""
+# http://supervisord.org/subprocess.html
+STATE_TRANSITIONS = {
+    ProcessState.STOPPED: (ProcessState.STARTING,),
+    ProcessState.STARTING: (ProcessState.RUNNING, ProcessState.BACKOFF, ProcessState.STOPPING),
+    ProcessState.RUNNING: (ProcessState.STOPPING, ProcessState.EXITED),
+    ProcessState.BACKOFF: (ProcessState.STARTING, ProcessState.FATAL),
+    ProcessState.STOPPING: (ProcessState.STOPPED,),
+    ProcessState.EXITED: (ProcessState.STARTING,),
+    ProcessState.FATAL: (ProcessState.STARTING,),
+}
 
-    # 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
+STOPPED_STATES = (
+    ProcessState.STOPPED,
+    ProcessState.EXITED,
+    ProcessState.FATAL,
+    ProcessState.UNKNOWN,
+)
 
-    def __init__(self) -> None:
-        self._flags: ta.Dict[str, dict] = {}
-        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
+RUNNING_STATES = (
+    ProcessState.RUNNING,
+    ProcessState.BACKOFF,
+    ProcessState.STARTING,
+)
 
-    def add_pending(self, key: TomlKey, flag: int) -> None:
-        self._pending_flags.add((key, flag))
+SIGNALABLE_STATES = (
+    ProcessState.RUNNING,
+    ProcessState.STARTING,
+    ProcessState.STOPPING,
+)
 
-    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 SupervisorState(enum.IntEnum):
+    FATAL = 2
+    RUNNING = 1
+    RESTARTING = 0
+    SHUTDOWN = -1
 
 
-class TomlNestedDict:
-    def __init__(self) -> None:
-        # The parsed content of the TOML document
-        self.dict: ta.Dict[str, ta.Any] = {}
+########################################
+# ../utils/collections.py
 
-    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 KeyedCollectionAccessors(abc.ABC, ta.Generic[K, V]):
+    @property
+    @abc.abstractmethod
+    def _by_key(self) -> ta.Mapping[K, V]:
+        raise NotImplementedError
 
+    def __iter__(self) -> ta.Iterator[V]:
+        return iter(self._by_key.values())
 
-class TomlOutput(ta.NamedTuple):
-    data: TomlNestedDict
-    flags: TomlFlags
+    def __len__(self) -> int:
+        return len(self._by_key)
 
+    def __contains__(self, key: K) -> bool:
+        return key in self._by_key
 
-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 __getitem__(self, key: K) -> V:
+        return self._by_key[key]
 
+    def get(self, key: K, default: ta.Optional[V] = None) -> ta.Optional[V]:
+        return self._by_key.get(key, default)
 
-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
+    def items(self) -> ta.Iterator[ta.Tuple[K, V]]:
+        return iter(self._by_key.items())
 
-    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
 
+class KeyedCollection(KeyedCollectionAccessors[K, V]):
+    def __init__(self, items: ta.Iterable[V]) -> None:
+        super().__init__()
 
-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
+        by_key: ta.Dict[K, V] = {}
+        for v in items:
+            if (k := self._key(v)) in by_key:
+                raise KeyError(f'key {k} of {v} already registered by {by_key[k]}')
+            by_key[k] = v
+        self.__by_key = by_key
 
+    @property
+    def _by_key(self) -> ta.Mapping[K, V]:
+        return self.__by_key
 
-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
+    @abc.abstractmethod
+    def _key(self, v: V) -> K:
+        raise NotImplementedError
 
 
-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)
+########################################
+# ../utils/diag.py
 
-    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 compact_traceback() -> ta.Tuple[
+    ta.Tuple[str, str, int],
+    ta.Type[BaseException],
+    BaseException,
+    types.TracebackType,
+]:
+    t, v, tb = sys.exc_info()
+    if not tb:
+        raise RuntimeError('No traceback')
 
+    tbinfo = []
+    while tb:
+        tbinfo.append((
+            tb.tb_frame.f_code.co_filename,
+            tb.tb_frame.f_code.co_name,
+            str(tb.tb_lineno),
+        ))
+        tb = tb.tb_next
 
-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)
+    # just to be safe
+    del tb
 
-    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
+    file, function, line = tbinfo[-1]
+    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])  # noqa
+    return (file, function, line), t, v, info  # type: ignore
 
-    if not src.startswith(']]', pos):
-        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
-    return pos + 2, key
 
+########################################
+# ../utils/fs.py
 
-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)
+def try_unlink(path: str) -> bool:
+    try:
+        os.unlink(path)
+    except OSError:
+        return False
+    return True
 
-    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 mktempfile(suffix: str, prefix: str, dir: str) -> str:  # noqa
+    fd, filename = tempfile.mkstemp(suffix, prefix, dir)
+    os.close(fd)
+    return filename
 
 
-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 get_path() -> ta.Sequence[str]:
+    """Return a list corresponding to $PATH, or a default."""
 
+    path = ['/bin', '/usr/bin', '/usr/local/bin']
+    if 'PATH' in os.environ:
+        p = os.environ['PATH']
+        if p:
+            path = p.split(os.pathsep)
+    return path
 
-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 check_existing_dir(v: str) -> str:
+    nv = os.path.expanduser(v)
+    if os.path.isdir(nv):
+        return nv
+    raise ValueError(f'{v} is not an existing directory')
 
-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 check_path_with_existing_dir(v: str) -> str:
+    nv = os.path.expanduser(v)
+    dir = os.path.dirname(nv)  # noqa
+    if not dir:
+        # relative pathname with no directory component
+        return nv
+    if os.path.isdir(dir):
+        return nv
+    raise ValueError(f'The directory named as part of the path {v} does not exist')
 
-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)
 
+########################################
+# ../utils/ostypes.py
 
-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)
+Fd = ta.NewType('Fd', int)
+Pid = ta.NewType('Pid', int)
+Rc = ta.NewType('Rc', int)
 
-        c = src[pos:pos + 1]
-        if c == ']':
-            return pos + 1, array
-        if c != ',':
-            raise toml_suffixed_err(src, pos, 'Unclosed array')
-        pos += 1
+Uid = ta.NewType('Uid', int)
+Gid = ta.NewType('Gid', int)
 
-        pos = toml_skip_comments_and_array_ws(src, pos)
-        if src.startswith(']', pos):
-            return pos + 1, array
 
+########################################
+# ../utils/signals.py
 
-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)
+_SIGS_BY_NUM: ta.Mapping[int, signal.Signals] = {s.value: s for s in signal.Signals}
+_SIGS_BY_NAME: ta.Mapping[str, signal.Signals] = {s.name: s for s in signal.Signals}
+
+
+def sig_num(value: ta.Union[int, str]) -> int:
     try:
-        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
-    except KeyError:
-        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
+        num = int(value)
 
+    except (ValueError, TypeError):
+        name = value.strip().upper()  # type: ignore
+        if not name.startswith('SIG'):
+            name = f'SIG{name}'
 
-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)
+        if (sn := _SIGS_BY_NAME.get(name)) is None:
+            raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
+        num = sn
 
+    if num not in _SIGS_BY_NUM:
+        raise ValueError(f'value {value!r} is not a valid signal number')
 
-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)
+    return num
 
 
-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 sig_name(num: int) -> str:
+    if (sig := _SIGS_BY_NUM.get(num)) is not None:
+        return sig.name
+    return f'signal {sig}'
 
 
-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)
+class SignalReceiver:
+    def __init__(self) -> None:
+        super().__init__()
 
+        self._signals_recvd: ta.List[int] = []
 
-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
+    def receive(self, sig: int, frame: ta.Any = None) -> None:
+        if sig not in self._signals_recvd:
+            self._signals_recvd.append(sig)
+
+    def install(self, *sigs: int) -> None:
+        for sig in sigs:
+            signal.signal(sig, self.receive)
+
+    def get_signal(self) -> ta.Optional[int]:
+        if self._signals_recvd:
+            sig = self._signals_recvd.pop(0)
+        else:
+            sig = None
+        return sig
+
+
+########################################
+# ../utils/strings.py
+
+
+##
+
+
+def as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
+    if isinstance(s, bytes):
+        return s
     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
+        return s.encode(encoding)
 
 
-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
+@ta.overload
+def find_prefix_at_end(haystack: str, needle: str) -> int:
+    ...
 
-    # 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)
+@ta.overload
+def find_prefix_at_end(haystack: bytes, needle: bytes) -> int:
+    ...
 
-    # 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
+def find_prefix_at_end(haystack, needle):
+    l = len(needle) - 1
+    while l and not haystack.endswith(needle[:l]):
+        l -= 1
+    return l
 
-    # Arrays
-    if char == '[':
-        return toml_parse_array(src, pos, parse_float)
 
-    # Inline tables
-    if char == '{':
-        return toml_parse_inline_table(src, pos, parse_float)
+##
+
+
+ANSI_ESCAPE_BEGIN = b'\x1b['
+ANSI_TERMINATORS = (b'H', b'f', b'A', b'B', b'C', b'D', b'R', b's', b'u', b'J', b'K', b'h', b'l', b'p', b'm')
+
+
+def strip_escapes(s: bytes) -> bytes:
+    """Remove all ANSI color escapes from the given string."""
+
+    result = b''
+    show = 1
+    i = 0
+    l = len(s)
+    while i < l:
+        if show == 0 and s[i:i + 1] in ANSI_TERMINATORS:
+            show = 1
+        elif show:
+            n = s.find(ANSI_ESCAPE_BEGIN, i)
+            if n == -1:
+                return result + s[i:]
+            else:
+                result = result + s[i:n]
+                i = n
+                show = 0
+        i += 1
+    return result
+
+
+##
+
+
+class SuffixMultiplier:
+    # d is a dictionary of suffixes to integer multipliers. If no suffixes match, default is the multiplier. Matches are
+    # case insensitive. Return values are in the fundamental unit.
+    def __init__(self, d, default=1):
+        super().__init__()
+        self._d = d
+        self._default = default
+        # all keys must be the same size
+        self._keysz = None
+        for k in d:
+            if self._keysz is None:
+                self._keysz = len(k)
+            elif self._keysz != len(k):  # type: ignore
+                raise ValueError(k)
+
+    def __call__(self, v: ta.Union[str, int]) -> int:
+        if isinstance(v, int):
+            return v
+        v = v.lower()
+        for s, m in self._d.items():
+            if v[-self._keysz:] == s:  # type: ignore
+                return int(v[:-self._keysz]) * m  # type: ignore
+        return int(v) * self._default
+
+
+parse_bytes_size = SuffixMultiplier({
+    'kb': 1024,
+    'mb': 1024 * 1024,
+    'gb': 1024 * 1024 * 1024,
+})
+
+
+#
+
+
+def parse_octal(arg: ta.Union[str, int]) -> int:
+    if isinstance(arg, int):
+        return arg
+    try:
+        return int(arg, 8)
+    except (TypeError, ValueError):
+        raise ValueError(f'{arg} can not be converted to an octal type')  # noqa
+
+
+########################################
+# ../../../omlish/configs/types.py
 
-    # 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')
+########################################
+# ../../../omlish/formats/ini/sections.py
 
 
-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 extract_ini_sections(cp: configparser.ConfigParser) -> IniSectionSettingsMap:
+    config_dct: ta.Dict[str, ta.Any] = {}
+    for sec in cp.sections():
+        cd = config_dct
+        for k in sec.split('.'):
+            cd = cd.setdefault(k, {})
+        cd.update(cp.items(sec))
+    return config_dct
 
 
-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.
+def render_ini_sections(
+        settings_by_section: IniSectionSettingsMap,
+) -> str:
+    out = io.StringIO()
 
-    `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
+    for i, (section, settings) in enumerate(settings_by_section.items()):
+        if i:
+            out.write('\n')
 
-    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
+        out.write(f'[{section}]\n')
 
-    return safe_parse_float
+        for k, v in settings.items():
+            if isinstance(v, str):
+                out.write(f'{k}={v}\n')
+            else:
+                for vv in v:
+                    out.write(f'{k}={vv}\n')
+
+    return out.getvalue()
 
 
 ########################################
-# ../exceptions.py
+# ../../../omlish/formats/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
 
 
-class ProcessError(Exception):
-    """Specialized exceptions used when attempting to start a process."""
+##
 
 
-class BadCommandError(ProcessError):
-    """Indicates the command could not be parsed properly."""
+_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,
+)
 
 
-class NotExecutableError(ProcessError):
-    """
-    Indicates that the filespec cannot be executed because its path resolves to a file which is not executable, or which
-    is a directory.
+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)
 
 
-class NotFoundError(ProcessError):
-    """Indicates that the filespec cannot be executed because it could not be found."""
+@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),
+        ),
+    )
 
 
-class NoPermissionError(ProcessError):
-    """
-    Indicates that the file cannot be executed because the supervisor process does not possess the appropriate UNIX
-    filesystem permission to execute the file.
-    """
+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)
 
 
-########################################
-# ../privileges.py
+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)
 
 
-def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
-    """
-    Drop privileges to become the specified user, which may be a username or uid. Called for supervisord startup and
-    when spawning subprocesses. Returns None on success or a string error message if privileges could not be dropped.
-    """
+TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
 
-    if user is None:
-        return 'No user specified to setuid to!'
+# 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')
 
-    # get uid for user, which can be a number or username
-    try:
-        uid = int(user)
-    except ValueError:
-        try:
-            pwrec = pwd.getpwnam(user)  # type: ignore
-        except KeyError:
-            return f"Can't find username {user!r}"
-        uid = pwrec[2]
-    else:
-        try:
-            pwrec = pwd.getpwuid(uid)
-        except KeyError:
-            return f"Can't find uid {uid!r}"
+TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
 
-    current_uid = os.getuid()
+TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
 
-    if current_uid == uid:
-        # do nothing and return successfully if the uid is already the current one. this allows a supervisord running as
-        # an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in it.
-        return None
+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)
 
-    if current_uid != 0:
-        return "Can't drop privilege as nonroot user"
+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
+    },
+)
 
-    gid = pwrec[3]
-    if hasattr(os, 'setgroups'):
-        user = pwrec[0]
-        groups = [grprec[2] for grprec in grp.getgrall() if user in grprec[3]]
 
-        # always put our primary gid first in this list, otherwise we can lose group info since sometimes the first
-        # group in the setgroups list gets overwritten on the subsequent setgid call (at least on freebsd 9 with
-        # python 2.7 - this will be safe though for all unix /python version combos)
-        groups.insert(0, gid)
-        try:
-            os.setgroups(groups)
-        except OSError:
-            return 'Could not set groups of effective user'
+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:
-        os.setgid(gid)
-    except OSError:
-        return 'Could not set group id of effective user'
+        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)
 
-    os.setuid(uid)
 
-    return None
+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)
 
-########################################
-# ../states.py
+    # 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
 
-class ProcessState(enum.IntEnum):
-    STOPPED = 0
-    STARTING = 10
-    RUNNING = 20
-    BACKOFF = 30
-    STOPPING = 40
-    EXITED = 100
-    FATAL = 200
-    UNKNOWN = 1000
+    return out.data.dict
 
-    @property
-    def stopped(self) -> bool:
-        return self in STOPPED_STATES
 
-    @property
-    def running(self) -> bool:
-        return self in RUNNING_STATES
+class TomlFlags:
+    """Flags that map to parsed keys/namespaces."""
 
-    @property
-    def signalable(self) -> bool:
-        return self in SIGNALABLE_STATES
+    # 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()
 
-# http://supervisord.org/subprocess.html
-STATE_TRANSITIONS = {
-    ProcessState.STOPPED: (ProcessState.STARTING,),
-    ProcessState.STARTING: (ProcessState.RUNNING, ProcessState.BACKOFF, ProcessState.STOPPING),
-    ProcessState.RUNNING: (ProcessState.STOPPING, ProcessState.EXITED),
-    ProcessState.BACKOFF: (ProcessState.STARTING, ProcessState.FATAL),
-    ProcessState.STOPPING: (ProcessState.STOPPED,),
-    ProcessState.EXITED: (ProcessState.STARTING,),
-    ProcessState.FATAL: (ProcessState.STARTING,),
-}
+    def add_pending(self, key: TomlKey, flag: int) -> None:
+        self._pending_flags.add((key, flag))
 
-STOPPED_STATES = (
-    ProcessState.STOPPED,
-    ProcessState.EXITED,
-    ProcessState.FATAL,
-    ProcessState.UNKNOWN,
-)
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
 
-RUNNING_STATES = (
-    ProcessState.RUNNING,
-    ProcessState.BACKOFF,
-    ProcessState.STARTING,
-)
+    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)
 
-SIGNALABLE_STATES = (
-    ProcessState.RUNNING,
-    ProcessState.STARTING,
-    ProcessState.STOPPING,
-)
+    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] = {}
 
-class SupervisorState(enum.IntEnum):
-    FATAL = 2
-    RUNNING = 1
-    RESTARTING = 0
-    SHUTDOWN = -1
+    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] = [{}]
 
-########################################
-# ../utils/collections.py
 
+class TomlOutput(ta.NamedTuple):
+    data: TomlNestedDict
+    flags: TomlFlags
 
-class KeyedCollectionAccessors(abc.ABC, ta.Generic[K, V]):
-    @property
-    @abc.abstractmethod
-    def _by_key(self) -> ta.Mapping[K, V]:
-        raise NotImplementedError
 
-    def __iter__(self) -> ta.Iterator[V]:
-        return iter(self._by_key.values())
+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 __len__(self) -> int:
-        return len(self._by_key)
 
-    def __contains__(self, key: K) -> bool:
-        return key in self._by_key
+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 __getitem__(self, key: K) -> V:
-        return self._by_key[key]
 
-    def get(self, key: K, default: ta.Optional[V] = None) -> ta.Optional[V]:
-        return self._by_key.get(key, default)
+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 items(self) -> ta.Iterator[ta.Tuple[K, V]]:
-        return iter(self._by_key.items())
 
+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
 
-class KeyedCollection(KeyedCollectionAccessors[K, V]):
-    def __init__(self, items: ta.Iterable[V]) -> None:
-        super().__init__()
 
-        by_key: ta.Dict[K, V] = {}
-        for v in items:
-            if (k := self._key(v)) in by_key:
-                raise KeyError(f'key {k} of {v} already registered by {by_key[k]}')
-            by_key[k] = v
-        self.__by_key = by_key
+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)
 
-    @property
-    def _by_key(self) -> ta.Mapping[K, V]:
-        return self.__by_key
+    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
 
-    @abc.abstractmethod
-    def _key(self, v: V) -> K:
-        raise NotImplementedError
+    if not src.startswith(']', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+    return pos + 1, key
 
 
-########################################
-# ../utils/diag.py
+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
 
-def compact_traceback() -> ta.Tuple[
-    ta.Tuple[str, str, int],
-    ta.Type[BaseException],
-    BaseException,
-    types.TracebackType,
-]:
-    t, v, tb = sys.exc_info()
-    if not tb:
-        raise RuntimeError('No traceback')
+    if not src.startswith(']]', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+    return pos + 2, key
 
-    tbinfo = []
-    while tb:
-        tbinfo.append((
-            tb.tb_frame.f_code.co_filename,
-            tb.tb_frame.f_code.co_name,
-            str(tb.tb_lineno),
-        ))
-        tb = tb.tb_next
 
-    # just to be safe
-    del tb
+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
 
-    file, function, line = tbinfo[-1]
-    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])  # noqa
-    return (file, function, line), t, v, info  # type: ignore
+    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}',
+        )
 
-########################################
-# ../utils/fs.py
+    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 try_unlink(path: str) -> bool:
+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:
-        os.unlink(path)
-    except OSError:
-        return False
-    return True
+        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 mktempfile(suffix: str, prefix: str, dir: str) -> str:  # noqa
-    fd, filename = tempfile.mkstemp(suffix, prefix, dir)
-    os.close(fd)
-    return filename
+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 get_path() -> ta.Sequence[str]:
-    """Return a list corresponding to $PATH, or a default."""
+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')
 
-    path = ['/bin', '/usr/bin', '/usr/local/bin']
-    if 'PATH' in os.environ:
-        p = os.environ['PATH']
-        if p:
-            path = p.split(os.pathsep)
-    return path
 
+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 check_existing_dir(v: str) -> str:
-    nv = os.path.expanduser(v)
-    if os.path.isdir(nv):
-        return nv
-    raise ValueError(f'{v} is not an existing directory')
 
+def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
+    pos += 1
+    array: list = []
 
-def check_path_with_existing_dir(v: str) -> str:
-    nv = os.path.expanduser(v)
-    dir = os.path.dirname(nv)  # noqa
-    if not dir:
-        # relative pathname with no directory component
-        return nv
-    if os.path.isdir(dir):
-        return nv
-    raise ValueError(f'The directory named as part of the path {v} does not exist')
+    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
 
-########################################
-# ../utils/ostypes.py
 
+def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
+    pos += 1
+    nested_dict = TomlNestedDict()
+    flags = TomlFlags()
 
-Fd = ta.NewType('Fd', int)
-Pid = ta.NewType('Pid', int)
-Rc = ta.NewType('Rc', int)
+    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)
 
-Uid = ta.NewType('Uid', int)
-Gid = ta.NewType('Gid', int)
 
+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
 
-########################################
-# ../utils/signals.py
 
+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)
 
-_SIGS_BY_NUM: ta.Mapping[int, signal.Signals] = {s.value: s for s in signal.Signals}
-_SIGS_BY_NAME: ta.Mapping[str, signal.Signals] = {s.name: s for s in signal.Signals}
 
+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 sig_num(value: ta.Union[int, str]) -> int:
-    try:
-        num = int(value)
 
-    except (ValueError, TypeError):
-        name = value.strip().upper()  # type: ignore
-        if not name.startswith('SIG'):
-            name = f'SIG{name}'
+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 (sn := _SIGS_BY_NAME.get(name)) is None:
-            raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
-        num = sn
+    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)
 
-    if num not in _SIGS_BY_NUM:
-        raise ValueError(f'value {value!r} is not a valid signal number')
+    # 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)
 
-    return num
 
+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 sig_name(num: int) -> str:
-    if (sig := _SIGS_BY_NUM.get(num)) is not None:
-        return sig.name
-    return f'signal {sig}'
 
+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)
 
-class SignalReceiver:
-    def __init__(self) -> None:
-        super().__init__()
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return toml_parse_multiline_str(src, pos, literal=True)
+        return toml_parse_literal_str(src, pos)
 
-        self._signals_recvd: ta.List[int] = []
+    # 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
 
-    def receive(self, sig: int, frame: ta.Any = None) -> None:
-        if sig not in self._signals_recvd:
-            self._signals_recvd.append(sig)
+    # Arrays
+    if char == '[':
+        return toml_parse_array(src, pos, parse_float)
 
-    def install(self, *sigs: int) -> None:
-        for sig in sigs:
-            signal.signal(sig, self.receive)
+    # Inline tables
+    if char == '{':
+        return toml_parse_inline_table(src, pos, parse_float)
 
-    def get_signal(self) -> ta.Optional[int]:
-        if self._signals_recvd:
-            sig = self._signals_recvd.pop(0)
-        else:
-            sig = None
-        return sig
+    # 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)
 
-########################################
-# ../utils/strings.py
+    # 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 as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
-    if isinstance(s, bytes):
-        return s
-    else:
-        return s.encode(encoding)
+    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)})')
 
-@ta.overload
-def find_prefix_at_end(haystack: str, needle: str) -> int:
-    ...
 
+def toml_is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
 
-@ta.overload
-def find_prefix_at_end(haystack: bytes, needle: bytes) -> int:
-    ...
 
+def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
+    """A decorator to make `parse_float` safe.
 
-def find_prefix_at_end(haystack, needle):
-    l = len(needle) - 1
-    while l and not haystack.endswith(needle[:l]):
-        l -= 1
-    return l
+    `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
 
 
-ANSI_ESCAPE_BEGIN = b'\x1b['
-ANSI_TERMINATORS = (b'H', b'f', b'A', b'B', b'C', b'D', b'R', b's', b'u', b'J', b'K', b'h', b'l', b'p', b'm')
+########################################
+# ../../../omlish/formats/toml/writer.py
 
 
-def strip_escapes(s: bytes) -> bytes:
-    """Remove all ANSI color escapes from the given string."""
+class TomlWriter:
+    @dc.dataclass(frozen=True)
+    class Literal:
+        s: str
 
-    result = b''
-    show = 1
-    i = 0
-    l = len(s)
-    while i < l:
-        if show == 0 and s[i:i + 1] in ANSI_TERMINATORS:
-            show = 1
-        elif show:
-            n = s.find(ANSI_ESCAPE_BEGIN, i)
-            if n == -1:
-                return result + s[i:]
-            else:
-                result = result + s[i:n]
-                i = n
-                show = 0
-        i += 1
-    return result
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+        self._out = out
 
+        self._indent = 0
+        self._wrote_indent = False
 
-##
+    #
 
+    def _w(self, s: str) -> None:
+        if not self._wrote_indent:
+            self._out.write('    ' * self._indent)
+            self._wrote_indent = True
+        self._out.write(s)
 
-class SuffixMultiplier:
-    # d is a dictionary of suffixes to integer multipliers. If no suffixes match, default is the multiplier. Matches are
-    # case insensitive. Return values are in the fundamental unit.
-    def __init__(self, d, default=1):
-        super().__init__()
-        self._d = d
-        self._default = default
-        # all keys must be the same size
-        self._keysz = None
-        for k in d:
-            if self._keysz is None:
-                self._keysz = len(k)
-            elif self._keysz != len(k):  # type: ignore
-                raise ValueError(k)
+    def _nl(self) -> None:
+        self._out.write('\n')
+        self._wrote_indent = False
 
-    def __call__(self, v: ta.Union[str, int]) -> int:
-        if isinstance(v, int):
-            return v
-        v = v.lower()
-        for s, m in self._d.items():
-            if v[-self._keysz:] == s:  # type: ignore
-                return int(v[:-self._keysz]) * m  # type: ignore
-        return int(v) * self._default
+    def _needs_quote(self, s: str) -> bool:
+        return (
+            not s or
+            any(c in s for c in '\'"\n') or
+            s[0] not in string.ascii_letters
+        )
 
+    def _maybe_quote(self, s: str) -> str:
+        if self._needs_quote(s):
+            return repr(s)
+        else:
+            return s
 
-parse_bytes_size = SuffixMultiplier({
-    'kb': 1024,
-    'mb': 1024 * 1024,
-    'gb': 1024 * 1024 * 1024,
-})
+    #
 
+    def write_root(self, obj: ta.Mapping) -> None:
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._nl()
+            self._w('[')
+            self._w(self._maybe_quote(k))
+            self._w(']')
+            self._nl()
+            self.write_table_contents(v)
+
+    def write_table_contents(self, obj: ta.Mapping) -> None:
+        for k, v in obj.items():
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+            self._nl()
+
+    def write_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        self._nl()
+        self._indent += 1
+        for e in obj:
+            self.write_value(e)
+            self._w(',')
+            self._nl()
+        self._indent -= 1
+        self._w(']')
+
+    def write_inline_table(self, obj: ta.Mapping) -> None:
+        self._w('{')
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._w(', ')
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+        self._w('}')
+
+    def write_inline_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        for i, e in enumerate(obj):
+            if i:
+                self._w(', ')
+            self.write_value(e)
+        self._w(']')
+
+    def write_key(self, obj: ta.Any) -> None:
+        if isinstance(obj, TomlWriter.Literal):
+            self._w(obj.s)
+        elif isinstance(obj, str):
+            self._w(self._maybe_quote(obj.replace('_', '-')))
+        elif isinstance(obj, int):
+            self._w(repr(str(obj)))
+        else:
+            raise TypeError(obj)
 
-#
+    def write_value(self, obj: ta.Any) -> None:
+        if isinstance(obj, bool):
+            self._w(str(obj).lower())
+        elif isinstance(obj, (str, int, float)):
+            self._w(repr(obj))
+        elif isinstance(obj, ta.Mapping):
+            self.write_inline_table(obj)
+        elif isinstance(obj, ta.Sequence):
+            if not obj:
+                self.write_inline_array(obj)
+            else:
+                self.write_array(obj)
+        else:
+            raise TypeError(obj)
 
+    #
 
-def parse_octal(arg: ta.Union[str, int]) -> int:
-    if isinstance(arg, int):
-        return arg
-    try:
-        return int(arg, 8)
-    except (TypeError, ValueError):
-        raise ValueError(f'{arg} can not be converted to an octal type')  # noqa
+    @classmethod
+    def write_str(cls, obj: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out).write_value(obj)
+        return out.getvalue()
 
 
 ########################################
@@ -3069,61 +3246,338 @@ def waitpid(
 ##
 
 
-def name_to_uid(name: str) -> Uid:
-    try:
-        uid = int(name)
-    except ValueError:
-        try:
-            pwdrec = pwd.getpwnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid user name {name}')  # noqa
-        uid = pwdrec[2]
-    else:
-        try:
-            pwd.getpwuid(uid)  # check if uid is valid
-        except KeyError:
-            raise ValueError(f'Invalid user id {name}')  # noqa
-    return Uid(uid)
+def name_to_uid(name: str) -> Uid:
+    try:
+        uid = int(name)
+    except ValueError:
+        try:
+            pwdrec = pwd.getpwnam(name)
+        except KeyError:
+            raise ValueError(f'Invalid user name {name}')  # noqa
+        uid = pwdrec[2]
+    else:
+        try:
+            pwd.getpwuid(uid)  # check if uid is valid
+        except KeyError:
+            raise ValueError(f'Invalid user id {name}')  # noqa
+    return Uid(uid)
+
+
+def name_to_gid(name: str) -> Gid:
+    try:
+        gid = int(name)
+    except ValueError:
+        try:
+            grprec = grp.getgrnam(name)
+        except KeyError:
+            raise ValueError(f'Invalid group name {name}')  # noqa
+        gid = grprec[2]
+    else:
+        try:
+            grp.getgrgid(gid)  # check if gid is valid
+        except KeyError:
+            raise ValueError(f'Invalid group id {name}')  # noqa
+    return Gid(gid)
+
+
+def gid_for_uid(uid: Uid) -> Gid:
+    pwrec = pwd.getpwuid(uid)
+    return Gid(pwrec[3])
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class User:
+    name: str
+    uid: Uid
+    gid: Gid
+
+
+def get_user(name: str) -> User:
+    return User(
+        name=name,
+        uid=(uid := name_to_uid(name)),
+        gid=gid_for_uid(uid),
+    )
+
+
+########################################
+# ../../../omlish/configs/formats.py
+"""
+Notes:
+ - necessarily string-oriented
+ - single file, as this is intended to be amalg'd and thus all included anyway
+
+TODO:
+ - ConfigDataMapper? to_map -> ConfigMap?
+ - nginx ?
+ - raw ?
+"""
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ConfigData(abc.ABC):  # noqa
+    @abc.abstractmethod
+    def as_map(self) -> ConfigMap:
+        raise NotImplementedError
+
+
+#
+
+
+class ConfigLoader(abc.ABC, ta.Generic[ConfigDataT]):
+    @property
+    def file_exts(self) -> ta.Sequence[str]:
+        return ()
+
+    def match_file(self, n: str) -> bool:
+        return '.' in n and n.split('.')[-1] in check.not_isinstance(self.file_exts, str)
+
+    #
+
+    def load_file(self, p: str) -> ConfigDataT:
+        with open(p) as f:
+            return self.load_str(f.read())
+
+    @abc.abstractmethod
+    def load_str(self, s: str) -> ConfigDataT:
+        raise NotImplementedError
+
+
+#
+
+
+class ConfigRenderer(abc.ABC, ta.Generic[ConfigDataT]):
+    @property
+    @abc.abstractmethod
+    def data_cls(self) -> ta.Type[ConfigDataT]:
+        raise NotImplementedError
+
+    def match_data(self, d: ConfigDataT) -> bool:
+        return isinstance(d, self.data_cls)
+
+    #
+
+    @abc.abstractmethod
+    def render(self, d: ConfigDataT) -> str:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjConfigData(ConfigData, abc.ABC):
+    obj: ta.Any
+
+    def as_map(self) -> ConfigMap:
+        return check.isinstance(self.obj, collections.abc.Mapping)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JsonConfigData(ObjConfigData):
+    pass
+
+
+class JsonConfigLoader(ConfigLoader[JsonConfigData]):
+    file_exts = ('json',)
+
+    def load_str(self, s: str) -> JsonConfigData:
+        return JsonConfigData(json.loads(s))
+
+
+class JsonConfigRenderer(ConfigRenderer[JsonConfigData]):
+    data_cls = JsonConfigData
+
+    def render(self, d: JsonConfigData) -> str:
+        return json_dumps_pretty(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TomlConfigData(ObjConfigData):
+    pass
+
+
+class TomlConfigLoader(ConfigLoader[TomlConfigData]):
+    file_exts = ('toml',)
+
+    def load_str(self, s: str) -> TomlConfigData:
+        return TomlConfigData(toml_loads(s))
+
+
+class TomlConfigRenderer(ConfigRenderer[TomlConfigData]):
+    data_cls = TomlConfigData
+
+    def render(self, d: TomlConfigData) -> str:
+        return TomlWriter.write_str(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class YamlConfigData(ObjConfigData):
+    pass
+
+
+class YamlConfigLoader(ConfigLoader[YamlConfigData]):
+    file_exts = ('yaml', 'yml')
+
+    def load_str(self, s: str) -> YamlConfigData:
+        return YamlConfigData(__import__('yaml').safe_load(s))
+
+
+class YamlConfigRenderer(ConfigRenderer[YamlConfigData]):
+    data_cls = YamlConfigData
+
+    def render(self, d: YamlConfigData) -> str:
+        return __import__('yaml').safe_dump(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class IniConfigData(ConfigData):
+    sections: IniSectionSettingsMap
+
+    def as_map(self) -> ConfigMap:
+        return self.sections
+
+
+class IniConfigLoader(ConfigLoader[IniConfigData]):
+    file_exts = ('ini',)
+
+    def load_str(self, s: str) -> IniConfigData:
+        cp = configparser.ConfigParser()
+        cp.read_string(s)
+        return IniConfigData(extract_ini_sections(cp))
+
+
+class IniConfigRenderer(ConfigRenderer[IniConfigData]):
+    data_cls = IniConfigData
+
+    def render(self, d: IniConfigData) -> str:
+        return render_ini_sections(d.sections)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SwitchedConfigFileLoader:
+    loaders: ta.Sequence[ConfigLoader]
+    default: ta.Optional[ConfigLoader] = None
+
+    def load_file(self, p: str) -> ConfigData:
+        n = os.path.basename(p)
+
+        for l in self.loaders:
+            if l.match_file(n):
+                return l.load_file(p)
+
+        if (d := self.default) is not None:
+            return d.load_file(p)
+
+        raise NameError(n)
+
+
+DEFAULT_CONFIG_LOADERS: ta.Sequence[ConfigLoader] = [
+    JsonConfigLoader(),
+    TomlConfigLoader(),
+    YamlConfigLoader(),
+    IniConfigLoader(),
+]
+
+DEFAULT_CONFIG_LOADER: ConfigLoader = JsonConfigLoader()
+
+DEFAULT_CONFIG_FILE_LOADER = SwitchedConfigFileLoader(
+    loaders=DEFAULT_CONFIG_LOADERS,
+    default=DEFAULT_CONFIG_LOADER,
+)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SwitchedConfigRenderer:
+    renderers: ta.Sequence[ConfigRenderer]
+
+    def render(self, d: ConfigData) -> str:
+        for r in self.renderers:
+            if r.match_data(d):
+                return r.render(d)
+        raise TypeError(d)
+
 
+DEFAULT_CONFIG_RENDERERS: ta.Sequence[ConfigRenderer] = [
+    JsonConfigRenderer(),
+    TomlConfigRenderer(),
+    YamlConfigRenderer(),
+    IniConfigRenderer(),
+]
 
-def name_to_gid(name: str) -> Gid:
-    try:
-        gid = int(name)
-    except ValueError:
-        try:
-            grprec = grp.getgrnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid group name {name}')  # noqa
-        gid = grprec[2]
-    else:
-        try:
-            grp.getgrgid(gid)  # check if gid is valid
-        except KeyError:
-            raise ValueError(f'Invalid group id {name}')  # noqa
-    return Gid(gid)
+DEFAULT_CONFIG_RENDERER = SwitchedConfigRenderer(DEFAULT_CONFIG_RENDERERS)
 
 
-def gid_for_uid(uid: Uid) -> Gid:
-    pwrec = pwd.getpwuid(uid)
-    return Gid(pwrec[3])
+########################################
+# ../../../omlish/configs/processing/names.py
+"""
+usecase: supervisor process groups
+"""
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class User:
-    name: str
-    uid: Uid
-    gid: Gid
+def build_config_named_children(
+        o: ta.Union[
+            ta.Sequence[ConfigMap],
+            ta.Mapping[str, ConfigMap],
+            None,
+        ],
+        *,
+        name_key: str = 'name',
+) -> ta.Optional[ta.Sequence[ConfigMap]]:
+    if o is None:
+        return None
 
+    lst: ta.List[ConfigMap] = []
+    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})
 
-def get_user(name: str) -> User:
-    return User(
-        name=name,
-        uid=(uid := name_to_uid(name)),
-        gid=gid_for_uid(uid),
-    )
+    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
 
 
 ########################################
@@ -5858,119 +6312,303 @@ class SocketHandler(abc.ABC):
         raise NotImplementedError
 
 
-########################################
-# ../../configs.py
+########################################
+# ../configs.py
+
+
+##
+
+
+class RestartWhenExitUnexpected:
+    pass
+
+
+class RestartUnconditionally:
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ProcessConfig:
+    # A Python string expression that is used to compose the supervisor process name for this process. You usually don't
+    # need to worry about setting this unless you change numprocs. The string expression is evaluated against a
+    # dictionary that includes group_name, host_node_name, process_num, program_name, and here (the directory of the
+    # supervisord config file).
+    name: str
+
+    # The command that will be run when this program is started. The command can be either absolute (e.g.
+    # /path/to/programname) or relative (e.g. programname). If it is relative, the supervisord's environment $PATH will
+    # be searched for the executable. Programs can accept arguments, e.g. /path/to/program foo bar. The command line can
+    # use double quotes to group arguments with spaces in them to pass to the program, e.g. /path/to/program/name -p
+    # "foo bar". Note that the value of command may include Python string expressions, e.g. /path/to/programname
+    # --port=80%(process_num)02d might expand to /path/to/programname --port=8000 at runtime. String expressions are
+    # evaluated against a dictionary containing the keys group_name, host_node_name, program_name, process_num,
+    # numprocs, here (the directory of the supervisord config file), and all supervisord's environment variables
+    # prefixed with ENV_. Controlled programs should themselves not be daemons, as supervisord assumes it is responsible
+    # for daemonizing its subprocesses
+    command: str
+
+    #
+
+    # Supervisor will start as many instances of this program as named by numprocs. Note that if numprocs > 1, the
+    # process_name expression must include %(process_num)s (or any other valid Python string expression that includes
+    # process_num) within it.
+    num_procs: int = 1
+
+    # An integer offset that is used to compute the number at which process_num starts.
+    num_procs_start: int = 0
+
+    #
+
+    # Instruct supervisord to use this UNIX user account as the account which runs the program. The user can only be
+    # switched if supervisord is run as the root user. If supervisord can't switch to the specified user, the program
+    # will not be started.
+    #
+    # Note: The user will be changed using setuid only. This does not start a login shell and does not change
+    # environment variables like USER or HOME
+    user: ta.Optional[str] = None
+    uid: ta.Optional[int] = None
+
+    # An octal number (e.g. 002, 022) representing the umask of the process.
+    umask: ta.Optional[int] = None
+
+    #
+
+    # A file path representing a directory to which supervisord should temporarily chdir before exec'ing the child.
+    directory: ta.Optional[str] = None
+
+    # A list of key/value pairs in the form KEY="val",KEY2="val2" that will be placed in the child process' environment.
+    # The environment string may contain Python string expressions that will be evaluated against a dictionary
+    # containing group_name, host_node_name, process_num, program_name, and here (the directory of the supervisord
+    # config file). Values containing non-alphanumeric characters should be quoted (e.g. KEY="val:123",KEY2="val,456").
+    # Otherwise, quoting the values is optional but recommended. Note that the subprocess will inherit the environment
+    # variables of the shell used to start “supervisord” except for the ones overridden here.
+    environment: ta.Optional[ta.Mapping[str, str]] = None
+
+    #
+
+    # The relative priority of the program in the start and shutdown ordering. Lower priorities indicate programs that
+    # start first and shut down last at startup and when aggregate commands are used in various clients (e.g. “start
+    # all”/”stop all”). Higher priorities indicate programs that start last and shut down first.
+    priority: int = 999
+
+    # If true, this program will start automatically when supervisord is started.
+    auto_start: bool = True
+
+    # Specifies if supervisord should automatically restart a process if it exits when it is in the RUNNING state. May
+    # be one of false, unexpected, or true. If false, the process will not be autorestarted. If unexpected, the process
+    # will be restarted when the program exits with an exit code that is not one of the exit codes associated with this
+    # process' configuration (see exitcodes). If true, the process will be unconditionally restarted when it exits,
+    # without regard to its exit code.
+    #
+    # Note: autorestart controls whether supervisord will autorestart a program if it exits after it has successfully
+    # started up (the process is in the RUNNING state). supervisord has a different restart mechanism for when the
+    # process is starting up (the process is in the STARTING state). Retries during process startup are controlled by
+    # startsecs and startretries.
+    auto_restart: str = 'unexpected'
+
+    # The total number of seconds which the program needs to stay running after a startup to consider the start
+    # successful (moving the process from the STARTING state to the RUNNING state). Set to 0 to indicate that the
+    # program needn't stay running for any particular amount of time.
+    #
+    # Note: Even if a process exits with an “expected” exit code (see exitcodes), the start will still be considered a
+    # failure if the process exits quicker than startsecs.
+    start_secs: int = 1
+
+    # The number of serial failure attempts that supervisord will allow when attempting to start the program before
+    # giving up and putting the process into an FATAL state.
+    #
+    # Note: After each failed restart, process will be put in BACKOFF state and each retry attempt will take
+    # increasingly more time.
+    start_retries: int = 3
+
+    # The signal used to kill the program when a stop is requested. This can be specified using the signal's name or its
+    # number. It is normally one of: TERM, HUP, INT, QUIT, KILL, USR1, or USR2.
+    stop_signal: int = signal.SIGTERM
+
+    # The number of seconds to wait for the OS to return a SIGCHLD to supervisord after the program has been sent a
+    # stopsignal. If this number of seconds elapses before supervisord receives a SIGCHLD from the process, supervisord
+    # will attempt to kill it with a final SIGKILL.
+    stop_wait_secs: int = 10
+
+    # If true, the flag causes supervisor to send the stop signal to the whole process group and implies killasgroup is
+    # true. This is useful for programs, such as Flask in debug mode, that do not propagate stop signals to their
+    # children, leaving them orphaned.
+    stop_as_group: bool = False
+
+    # If true, when resorting to send SIGKILL to the program to terminate it send it to its whole process group instead,
+    # taking care of its children as well, useful e.g with Python programs using multiprocessing.
+    kill_as_group: bool = False
+
+    # The list of “expected” exit codes for this program used with autorestart. If the autorestart parameter is set to
+    # unexpected, and the process exits in any other way than as a result of a supervisor stop request, supervisord will
+    # restart the process if it exits with an exit code that is not defined in this list.
+    #
+    # Note: In Supervisor versions prior to 4.0, the default was 0,2. In Supervisor 4.0, the default was changed to 0.
+    exitcodes: ta.Sequence[int] = (0,)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class Log:
+        file: ta.Optional[str] = None
+        capture_max_bytes: ta.Optional[int] = None
+        events_enabled: bool = False
+        syslog: bool = False
+        backups: ta.Optional[int] = None
+        max_bytes: ta.Optional[int] = None
+
+    stdout: Log = Log()
+    stderr: Log = Log()
+
+    # If true, cause the process' stderr output to be sent back to supervisord on its stdout file descriptor (in UNIX
+    # shell terms, this is the equivalent of executing /the/program 2>&1).
+    #
+    # Note: Do not set redirect_stderr=true in an [eventlistener:x] section. Eventlisteners use stdout and stdin to
+    # communicate with supervisord. If stderr is redirected, output from stderr will interfere with the eventlistener
+    # protocol.
+    redirect_stderr: bool = False
+
+
+@dc.dataclass(frozen=True)
+class ProcessGroupConfig:
+    name: str
+
+    priority: int = 999
+
+    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
+
+
+@dc.dataclass(frozen=True)
+class ServerConfig:
+    # Instruct supervisord to switch users to this UNIX user account before doing any meaningful processing. The user
+    # can only be switched if supervisord is started as the root user.
+    user: ta.Optional[str] = None
+
+    # If true, supervisord will start in the foreground instead of daemonizing.
+    nodaemon: bool = False
+
+    # The umask of the supervisord process.
+    umask: int = 0o22
+
+    #
 
+    # When supervisord daemonizes, switch to this directory. This option can include the value %(here)s, which expands
+    # to the directory in which the supervisord configuration file was found.
+    directory: ta.Optional[str] = None
 
-##
+    # The location in which supervisord keeps its pid file. This option can include the value %(here)s, which expands to
+    # the directory in which the supervisord configuration file was found.
+    pidfile: str = 'supervisord.pid'
 
+    # The identifier string for this supervisor process, used by the RPC interface.
+    identifier: str = 'supervisor'
 
-def parse_config_file(
-        name: str,
-        f: ta.TextIO,
-) -> ConfigMapping:
-    if name.endswith('.toml'):
-        return toml_loads(f.read())
+    # The minimum number of file descriptors that must be available before supervisord will start successfully.
+    min_fds: int = 1024
+    # The minimum number of process descriptors that must be available before supervisord will start successfully.
+    min_procs: int = 200
 
-    elif any(name.endswith(e) for e in ('.yml', '.yaml')):
-        yaml = __import__('yaml')
-        return yaml.safe_load(f)
+    # Prevent supervisord from clearing any existing AUTO child log files at startup time. Useful for debugging
+    nocleanup: bool = False
 
-    elif name.endswith('.ini'):
-        import configparser
-        cp = configparser.ConfigParser()
-        cp.read_file(f)
-        config_dct: ta.Dict[str, ta.Any] = {}
-        for sec in cp.sections():
-            cd = config_dct
-            for k in sec.split('.'):
-                cd = cd.setdefault(k, {})
-            cd.update(cp.items(sec))
-        return config_dct
+    # Strip all ANSI escape sequences from child log files.
+    strip_ansi: bool = False
 
-    else:
-        return json.loads(f.read())
+    #
 
+    # The path to the activity log of the supervisord process. This option can include the value %(here)s, which expands
+    # to the directory in which the supervisord configuration file was found.
+    logfile: str = 'supervisord.log'
 
-def read_config_file(
-        path: str,
-        cls: ta.Type[T],
-        *,
-        prepare: ta.Optional[ta.Callable[[ConfigMapping], ConfigMapping]] = None,
-        msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
-) -> T:
-    with open(path) as cf:
-        config_dct = parse_config_file(os.path.basename(path), cf)
+    # The maximum number of bytes that may be consumed by the activity log file before it is rotated (suffix multipliers
+    # like “KB”, “MB”, and “GB” can be used in the value). Set this value to 0 to indicate an unlimited log size.
+    logfile_max_bytes: int = 50 * 1024 * 1024
 
-    if prepare is not None:
-        config_dct = prepare(config_dct)
+    # The number of backups to keep around resulting from activity log file rotation. If set to 0, no backups will be
+    # kept.
+    logfile_backups: int = 10
 
-    return msh.unmarshal_obj(config_dct, cls)
+    # The logging level, dictating what is written to the supervisord activity log. One of critical, error, warn, info,
+    # debug, trace, or blather. Note that at log level debug, the supervisord log file will record the stderr/stdout
+    # output of its child processes and extended info about process state changes, which is useful for debugging a
+    # process which isn't starting properly.
+    loglevel: int = logging.INFO
 
+    # The directory used for AUTO child log files. This option can include the value %(here)s, which expands to the
+    # directory in which the supervisord configuration file was found.
+    child_logdir: str = '/dev/null'
 
-##
+    # If true and not daemonized, logs will not be directed to stdout.
+    silent: bool = False
 
+    #
 
-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
+    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = 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})
+    # TODO: implement - make sure to accept broken symlinks
+    group_config_dirs: ta.Optional[ta.Sequence[str]] = None
 
-    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)
+    http_port: ta.Optional[int] = None
 
-    return lst
+    #
+
+    @classmethod
+    def new(
+            cls,
+            *,
+            umask: ta.Union[int, str] = 0o22,
+            directory: ta.Optional[str] = None,
+            logfile: str = 'supervisord.log',
+            logfile_max_bytes: 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=parse_octal(umask),
+            directory=check_existing_dir(directory) if directory is not None else None,
+            logfile=check_path_with_existing_dir(logfile),
+            logfile_max_bytes=parse_bytes_size(logfile_max_bytes),
+            loglevel=parse_logging_level(loglevel),
+            pidfile=check_path_with_existing_dir(pidfile),
+            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
+            **kwargs,
+        )
 
 
 ##
 
 
-def render_ini_config(
-        settings_by_section: IniConfigSectionSettingsMap,
-) -> str:
-    out = io.StringIO()
+def prepare_process_group_config(dct: ConfigMap) -> ConfigMap:
+    out = dict(dct)
+    out['processes'] = build_config_named_children(out.get('processes'))
+    return out
 
-    for i, (section, settings) in enumerate(settings_by_section.items()):
-        if i:
-            out.write('\n')
 
-        out.write(f'[{section}]\n')
+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
 
-        for k, v in settings.items():
-            if isinstance(v, str):
-                out.write(f'{k}={v}\n')
-            else:
-                for vv in v:
-                    out.write(f'{k}={vv}\n')
 
-    return out.getvalue()
+##
+
+
+def parse_logging_level(value: ta.Union[str, int]) -> int:
+    if isinstance(value, int):
+        return value
+    s = str(value).lower()
+    level = logging.getLevelNamesMapping().get(s.upper())
+    if level is None:
+        raise ValueError(f'bad logging level name {value!r}')
+    return level
 
 
 ########################################
@@ -6120,6 +6758,38 @@ class UnsupportedMethodHttpHandlerError(Exception):
     pass
 
 
+########################################
+# ../../../omlish/lite/configs.py
+
+
+##
+
+
+def load_config_file_obj(
+        f: str,
+        cls: ta.Type[T],
+        *,
+        prepare: ta.Union[
+            ta.Callable[[ConfigMap], ConfigMap],
+            ta.Iterable[ta.Callable[[ConfigMap], ConfigMap]],
+        ] = (),
+        msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
+) -> T:
+    config_data = DEFAULT_CONFIG_FILE_LOADER.load_file(f)
+
+    config_dct = config_data.as_map()
+
+    if prepare is not None:
+        if isinstance(prepare, ta.Iterable):
+            pfs = list(prepare)
+        else:
+            pfs = [prepare]
+        for pf in pfs:
+            config_dct = pf(config_dct)
+
+    return msh.unmarshal_obj(config_dct, cls)
+
+
 ########################################
 # ../../../omlish/logs/standard.py
 """
@@ -6242,303 +6912,184 @@ def configure_standard_logging(
         return StandardConfiguredLogHandler(handler)
 
 
-########################################
-# ../configs.py
-
-
-##
-
-
-class RestartWhenExitUnexpected:
-    pass
-
-
-class RestartUnconditionally:
-    pass
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class ProcessConfig:
-    # A Python string expression that is used to compose the supervisor process name for this process. You usually don't
-    # need to worry about setting this unless you change numprocs. The string expression is evaluated against a
-    # dictionary that includes group_name, host_node_name, process_num, program_name, and here (the directory of the
-    # supervisord config file).
-    name: str
-
-    # The command that will be run when this program is started. The command can be either absolute (e.g.
-    # /path/to/programname) or relative (e.g. programname). If it is relative, the supervisord's environment $PATH will
-    # be searched for the executable. Programs can accept arguments, e.g. /path/to/program foo bar. The command line can
-    # use double quotes to group arguments with spaces in them to pass to the program, e.g. /path/to/program/name -p
-    # "foo bar". Note that the value of command may include Python string expressions, e.g. /path/to/programname
-    # --port=80%(process_num)02d might expand to /path/to/programname --port=8000 at runtime. String expressions are
-    # evaluated against a dictionary containing the keys group_name, host_node_name, program_name, process_num,
-    # numprocs, here (the directory of the supervisord config file), and all supervisord's environment variables
-    # prefixed with ENV_. Controlled programs should themselves not be daemons, as supervisord assumes it is responsible
-    # for daemonizing its subprocesses
-    command: str
-
-    #
-
-    # Supervisor will start as many instances of this program as named by numprocs. Note that if numprocs > 1, the
-    # process_name expression must include %(process_num)s (or any other valid Python string expression that includes
-    # process_num) within it.
-    num_procs: int = 1
-
-    # An integer offset that is used to compute the number at which process_num starts.
-    num_procs_start: int = 0
-
-    #
-
-    # Instruct supervisord to use this UNIX user account as the account which runs the program. The user can only be
-    # switched if supervisord is run as the root user. If supervisord can't switch to the specified user, the program
-    # will not be started.
-    #
-    # Note: The user will be changed using setuid only. This does not start a login shell and does not change
-    # environment variables like USER or HOME
-    user: ta.Optional[str] = None
-    uid: ta.Optional[int] = None
-
-    # An octal number (e.g. 002, 022) representing the umask of the process.
-    umask: ta.Optional[int] = None
-
-    #
-
-    # A file path representing a directory to which supervisord should temporarily chdir before exec'ing the child.
-    directory: ta.Optional[str] = None
-
-    # A list of key/value pairs in the form KEY="val",KEY2="val2" that will be placed in the child process' environment.
-    # The environment string may contain Python string expressions that will be evaluated against a dictionary
-    # containing group_name, host_node_name, process_num, program_name, and here (the directory of the supervisord
-    # config file). Values containing non-alphanumeric characters should be quoted (e.g. KEY="val:123",KEY2="val,456").
-    # Otherwise, quoting the values is optional but recommended. Note that the subprocess will inherit the environment
-    # variables of the shell used to start “supervisord” except for the ones overridden here.
-    environment: ta.Optional[ta.Mapping[str, str]] = None
-
-    #
-
-    # The relative priority of the program in the start and shutdown ordering. Lower priorities indicate programs that
-    # start first and shut down last at startup and when aggregate commands are used in various clients (e.g. “start
-    # all”/”stop all”). Higher priorities indicate programs that start last and shut down first.
-    priority: int = 999
-
-    # If true, this program will start automatically when supervisord is started.
-    auto_start: bool = True
-
-    # Specifies if supervisord should automatically restart a process if it exits when it is in the RUNNING state. May
-    # be one of false, unexpected, or true. If false, the process will not be autorestarted. If unexpected, the process
-    # will be restarted when the program exits with an exit code that is not one of the exit codes associated with this
-    # process' configuration (see exitcodes). If true, the process will be unconditionally restarted when it exits,
-    # without regard to its exit code.
-    #
-    # Note: autorestart controls whether supervisord will autorestart a program if it exits after it has successfully
-    # started up (the process is in the RUNNING state). supervisord has a different restart mechanism for when the
-    # process is starting up (the process is in the STARTING state). Retries during process startup are controlled by
-    # startsecs and startretries.
-    auto_restart: str = 'unexpected'
+########################################
+# ../types.py
 
-    # The total number of seconds which the program needs to stay running after a startup to consider the start
-    # successful (moving the process from the STARTING state to the RUNNING state). Set to 0 to indicate that the
-    # program needn't stay running for any particular amount of time.
-    #
-    # Note: Even if a process exits with an “expected” exit code (see exitcodes), the start will still be considered a
-    # failure if the process exits quicker than startsecs.
-    start_secs: int = 1
 
-    # The number of serial failure attempts that supervisord will allow when attempting to start the program before
-    # giving up and putting the process into an FATAL state.
-    #
-    # Note: After each failed restart, process will be put in BACKOFF state and each retry attempt will take
-    # increasingly more time.
-    start_retries: int = 3
+##
 
-    # The signal used to kill the program when a stop is requested. This can be specified using the signal's name or its
-    # number. It is normally one of: TERM, HUP, INT, QUIT, KILL, USR1, or USR2.
-    stop_signal: int = signal.SIGTERM
 
-    # The number of seconds to wait for the OS to return a SIGCHLD to supervisord after the program has been sent a
-    # stopsignal. If this number of seconds elapses before supervisord receives a SIGCHLD from the process, supervisord
-    # will attempt to kill it with a final SIGKILL.
-    stop_wait_secs: int = 10
+class ExitNow(Exception):  # noqa
+    pass
 
-    # If true, the flag causes supervisor to send the stop signal to the whole process group and implies killasgroup is
-    # true. This is useful for programs, such as Flask in debug mode, that do not propagate stop signals to their
-    # children, leaving them orphaned.
-    stop_as_group: bool = False
 
-    # If true, when resorting to send SIGKILL to the program to terminate it send it to its whole process group instead,
-    # taking care of its children as well, useful e.g with Python programs using multiprocessing.
-    kill_as_group: bool = False
+ServerEpoch = ta.NewType('ServerEpoch', int)
 
-    # The list of “expected” exit codes for this program used with autorestart. If the autorestart parameter is set to
-    # unexpected, and the process exits in any other way than as a result of a supervisor stop request, supervisord will
-    # restart the process if it exits with an exit code that is not defined in this list.
-    #
-    # Note: In Supervisor versions prior to 4.0, the default was 0,2. In Supervisor 4.0, the default was changed to 0.
-    exitcodes: ta.Sequence[int] = (0,)
 
-    #
+##
 
-    @dc.dataclass(frozen=True)
-    class Log:
-        file: ta.Optional[str] = None
-        capture_max_bytes: ta.Optional[int] = None
-        events_enabled: bool = False
-        syslog: bool = False
-        backups: ta.Optional[int] = None
-        max_bytes: ta.Optional[int] = None
 
-    stdout: Log = Log()
-    stderr: Log = Log()
+@functools.total_ordering
+class ConfigPriorityOrdered(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def config(self) -> ta.Any:
+        raise NotImplementedError
 
-    # If true, cause the process' stderr output to be sent back to supervisord on its stdout file descriptor (in UNIX
-    # shell terms, this is the equivalent of executing /the/program 2>&1).
-    #
-    # Note: Do not set redirect_stderr=true in an [eventlistener:x] section. Eventlisteners use stdout and stdin to
-    # communicate with supervisord. If stderr is redirected, output from stderr will interfere with the eventlistener
-    # protocol.
-    redirect_stderr: bool = False
+    def __lt__(self, other):
+        return self.config.priority < other.config.priority
 
+    def __eq__(self, other):
+        return self.config.priority == other.config.priority
 
-@dc.dataclass(frozen=True)
-class ProcessGroupConfig:
-    name: str
 
-    priority: int = 999
+##
 
-    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
 
+class SupervisorStateManager(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def state(self) -> SupervisorState:
+        raise NotImplementedError
 
-@dc.dataclass(frozen=True)
-class ServerConfig:
-    # Instruct supervisord to switch users to this UNIX user account before doing any meaningful processing. The user
-    # can only be switched if supervisord is started as the root user.
-    user: ta.Optional[str] = None
+    @abc.abstractmethod
+    def set_state(self, state: SupervisorState) -> None:
+        raise NotImplementedError
 
-    # If true, supervisord will start in the foreground instead of daemonizing.
-    nodaemon: bool = False
 
-    # The umask of the supervisord process.
-    umask: int = 0o22
+##
 
-    #
 
-    # When supervisord daemonizes, switch to this directory. This option can include the value %(here)s, which expands
-    # to the directory in which the supervisord configuration file was found.
-    directory: ta.Optional[str] = None
+class HasDispatchers(abc.ABC):
+    @abc.abstractmethod
+    def get_dispatchers(self) -> 'Dispatchers':
+        raise NotImplementedError
 
-    # The location in which supervisord keeps its pid file. This option can include the value %(here)s, which expands to
-    # the directory in which the supervisord configuration file was found.
-    pidfile: str = 'supervisord.pid'
 
-    # The identifier string for this supervisor process, used by the RPC interface.
-    identifier: str = 'supervisor'
+class ProcessDispatcher(FdioHandler, abc.ABC):
+    @property
+    @abc.abstractmethod
+    def channel(self) -> ProcessOutputChannel:
+        raise NotImplementedError
 
-    # The minimum number of file descriptors that must be available before supervisord will start successfully.
-    min_fds: int = 1024
-    # The minimum number of process descriptors that must be available before supervisord will start successfully.
-    min_procs: int = 200
+    @property
+    @abc.abstractmethod
+    def process(self) -> 'Process':
+        raise NotImplementedError
 
-    # Prevent supervisord from clearing any existing AUTO child log files at startup time. Useful for debugging
-    nocleanup: bool = False
 
-    # Strip all ANSI escape sequences from child log files.
-    strip_ansi: bool = False
+class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
+    @abc.abstractmethod
+    def remove_logs(self) -> None:
+        raise NotImplementedError
 
-    #
+    @abc.abstractmethod
+    def reopen_logs(self) -> None:
+        raise NotImplementedError
 
-    # The path to the activity log of the supervisord process. This option can include the value %(here)s, which expands
-    # to the directory in which the supervisord configuration file was found.
-    logfile: str = 'supervisord.log'
 
-    # The maximum number of bytes that may be consumed by the activity log file before it is rotated (suffix multipliers
-    # like “KB”, “MB”, and “GB” can be used in the value). Set this value to 0 to indicate an unlimited log size.
-    logfile_max_bytes: int = 50 * 1024 * 1024
+class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
+    @abc.abstractmethod
+    def write(self, chars: ta.Union[bytes, str]) -> None:
+        raise NotImplementedError
 
-    # The number of backups to keep around resulting from activity log file rotation. If set to 0, no backups will be
-    # kept.
-    logfile_backups: int = 10
+    @abc.abstractmethod
+    def flush(self) -> None:
+        raise NotImplementedError
 
-    # The logging level, dictating what is written to the supervisord activity log. One of critical, error, warn, info,
-    # debug, trace, or blather. Note that at log level debug, the supervisord log file will record the stderr/stdout
-    # output of its child processes and extended info about process state changes, which is useful for debugging a
-    # process which isn't starting properly.
-    loglevel: int = logging.INFO
 
-    # The directory used for AUTO child log files. This option can include the value %(here)s, which expands to the
-    # directory in which the supervisord configuration file was found.
-    child_logdir: str = '/dev/null'
+##
 
-    # If true and not daemonized, logs will not be directed to stdout.
-    silent: bool = False
 
-    #
+class Process(
+    ConfigPriorityOrdered,
+    HasDispatchers,
+    abc.ABC,
+):
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
 
-    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
+    @property
+    @abc.abstractmethod
+    def config(self) -> ProcessConfig:
+        raise NotImplementedError
 
-    # TODO: implement - make sure to accept broken symlinks
-    group_config_dirs: ta.Optional[ta.Sequence[str]] = None
+    @property
+    @abc.abstractmethod
+    def group(self) -> 'ProcessGroup':
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def pid(self) -> Pid:
+        raise NotImplementedError
 
     #
 
-    http_port: ta.Optional[int] = None
+    @abc.abstractmethod
+    def finish(self, sts: Rc) -> None:
+        raise NotImplementedError
 
-    #
+    @abc.abstractmethod
+    def stop(self) -> ta.Optional[str]:
+        raise NotImplementedError
 
-    @classmethod
-    def new(
-            cls,
-            *,
-            umask: ta.Union[int, str] = 0o22,
-            directory: ta.Optional[str] = None,
-            logfile: str = 'supervisord.log',
-            logfile_max_bytes: 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=parse_octal(umask),
-            directory=check_existing_dir(directory) if directory is not None else None,
-            logfile=check_path_with_existing_dir(logfile),
-            logfile_max_bytes=parse_bytes_size(logfile_max_bytes),
-            loglevel=parse_logging_level(loglevel),
-            pidfile=check_path_with_existing_dir(pidfile),
-            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
-            **kwargs,
-        )
+    @abc.abstractmethod
+    def give_up(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def transition(self) -> None:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def state(self) -> ProcessState:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def after_setuid(self) -> None:
+        raise NotImplementedError
 
 
 ##
 
 
-def prepare_process_group_config(dct: ConfigMapping) -> ConfigMapping:
-    out = dict(dct)
-    out['processes'] = build_config_named_children(out.get('processes'))
-    return out
+class ProcessGroup(
+    ConfigPriorityOrdered,
+    KeyedCollectionAccessors[str, Process],
+    abc.ABC,
+):
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
 
+    @property
+    @abc.abstractmethod
+    def config(self) -> ProcessGroupConfig:
+        raise NotImplementedError
 
-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
+    @property
+    @abc.abstractmethod
+    def by_name(self) -> ta.Mapping[str, Process]:
+        raise NotImplementedError
 
+    #
 
-##
+    @abc.abstractmethod
+    def stop_all(self) -> None:
+        raise NotImplementedError
 
+    @abc.abstractmethod
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        raise NotImplementedError
 
-def parse_logging_level(value: ta.Union[str, int]) -> int:
-    if isinstance(value, int):
-        return value
-    s = str(value).lower()
-    level = logging.getLevelNamesMapping().get(s.upper())
-    if level is None:
-        raise ValueError(f'bad logging level name {value!r}')
-    return level
+    @abc.abstractmethod
+    def before_remove(self) -> None:
+        raise NotImplementedError
 
 
 ########################################
@@ -7047,368 +7598,59 @@ class CoroHttpServer:
 ##
 
 
-class CoroHttpServerSocketHandler(SocketHandler):
-    def __init__(
-            self,
-            client_address: SocketAddress,
-            rfile: ta.BinaryIO,
-            wfile: ta.BinaryIO,
-            *,
-            server_factory: CoroHttpServerFactory,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
-    ) -> None:
-        super().__init__(
-            client_address,
-            rfile,
-            wfile,
-        )
-
-        self._server_factory = server_factory
-        self._log_handler = log_handler
-
-    def handle(self) -> None:
-        server = self._server_factory(self._client_address)
-
-        gen = server.coro_handle()
-
-        o = next(gen)
-        while True:
-            if isinstance(o, CoroHttpServer.AnyLogIo):
-                i = None
-                if self._log_handler is not None:
-                    self._log_handler(server, o)
-
-            elif isinstance(o, CoroHttpServer.ReadIo):
-                i = self._rfile.read(o.sz)
-
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
-                i = self._rfile.readline(o.sz)
-
-            elif isinstance(o, CoroHttpServer.WriteIo):
-                i = None
-                self._wfile.write(o.data)
-                self._wfile.flush()
-
-            else:
-                raise TypeError(o)
-
-            try:
-                if i is not None:
-                    o = gen.send(i)
-                else:
-                    o = next(gen)
-            except StopIteration:
-                break
-
-
-########################################
-# ../types.py
-
-
-##
-
-
-class ExitNow(Exception):  # noqa
-    pass
-
-
-ServerEpoch = ta.NewType('ServerEpoch', int)
-
-
-##
-
-
-@functools.total_ordering
-class ConfigPriorityOrdered(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def config(self) -> ta.Any:
-        raise NotImplementedError
-
-    def __lt__(self, other):
-        return self.config.priority < other.config.priority
-
-    def __eq__(self, other):
-        return self.config.priority == other.config.priority
-
-
-##
-
-
-class SupervisorStateManager(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def state(self) -> SupervisorState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def set_state(self, state: SupervisorState) -> None:
-        raise NotImplementedError
-
-
-##
-
-
-class HasDispatchers(abc.ABC):
-    @abc.abstractmethod
-    def get_dispatchers(self) -> 'Dispatchers':
-        raise NotImplementedError
-
-
-class ProcessDispatcher(FdioHandler, abc.ABC):
-    @property
-    @abc.abstractmethod
-    def channel(self) -> ProcessOutputChannel:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def process(self) -> 'Process':
-        raise NotImplementedError
-
-
-class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
-    @abc.abstractmethod
-    def remove_logs(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def reopen_logs(self) -> None:
-        raise NotImplementedError
-
-
-class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
-    @abc.abstractmethod
-    def write(self, chars: ta.Union[bytes, str]) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def flush(self) -> None:
-        raise NotImplementedError
-
-
-##
-
-
-class Process(
-    ConfigPriorityOrdered,
-    HasDispatchers,
-    abc.ABC,
-):
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def config(self) -> ProcessConfig:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def group(self) -> 'ProcessGroup':
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def pid(self) -> Pid:
-        raise NotImplementedError
-
-    #
-
-    @abc.abstractmethod
-    def finish(self, sts: Rc) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def stop(self) -> ta.Optional[str]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def give_up(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def transition(self) -> None:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def state(self) -> ProcessState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def after_setuid(self) -> None:
-        raise NotImplementedError
-
-
-##
-
-
-class ProcessGroup(
-    ConfigPriorityOrdered,
-    KeyedCollectionAccessors[str, Process],
-    abc.ABC,
-):
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def config(self) -> ProcessGroupConfig:
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def by_name(self) -> ta.Mapping[str, Process]:
-        raise NotImplementedError
-
-    #
-
-    @abc.abstractmethod
-    def stop_all(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def get_unstopped_processes(self) -> ta.List[Process]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def before_remove(self) -> None:
-        raise NotImplementedError
-
-
-########################################
-# ../../../omlish/http/coro/fdio.py
-
-
-class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
+class CoroHttpServerSocketHandler(SocketHandler):
     def __init__(
             self,
-            addr: SocketAddress,
-            sock: socket.socket,
-            handler: HttpHandler,
+            client_address: SocketAddress,
+            rfile: ta.BinaryIO,
+            wfile: ta.BinaryIO,
             *,
-            read_size: int = 0x10000,
-            write_size: int = 0x10000,
+            server_factory: CoroHttpServerFactory,
             log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
     ) -> None:
-        check.state(not sock.getblocking())
-
-        super().__init__(addr, sock)
-
-        self._handler = handler
-        self._read_size = read_size
-        self._write_size = write_size
-        self._log_handler = log_handler
-
-        self._read_buf = ReadableListBuffer()
-        self._write_buf: IncrementalWriteBuffer | None = None
-
-        self._coro_srv = CoroHttpServer(
-            addr,
-            handler=self._handler,
+        super().__init__(
+            client_address,
+            rfile,
+            wfile,
         )
-        self._srv_coro: ta.Optional[ta.Generator[CoroHttpServer.Io, ta.Optional[bytes], None]] = self._coro_srv.coro_handle()  # noqa
 
-        self._cur_io: CoroHttpServer.Io | None = None
-        self._next_io()
+        self._server_factory = server_factory
+        self._log_handler = log_handler
 
-    #
+    def handle(self) -> None:
+        server = self._server_factory(self._client_address)
 
-    def _next_io(self) -> None:  # noqa
-        coro = check.not_none(self._srv_coro)
+        gen = server.coro_handle()
 
-        d: bytes | None = None
-        o = self._cur_io
+        o = next(gen)
         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):
+                i = None
                 if self._log_handler is not None:
-                    self._log_handler(self._coro_srv, o)
-                o = None
+                    self._log_handler(server, o)
 
             elif isinstance(o, CoroHttpServer.ReadIo):
-                if (d := self._read_buf.read(o.sz)) is None:
-                    break
-                o = None
+                i = self._rfile.read(o.sz)
 
             elif isinstance(o, CoroHttpServer.ReadLineIo):
-                if (d := self._read_buf.read_until(b'\n')) is None:
-                    break
-                o = None
+                i = self._rfile.readline(o.sz)
 
             elif isinstance(o, CoroHttpServer.WriteIo):
-                check.none(self._write_buf)
-                self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
-                break
+                i = None
+                self._wfile.write(o.data)
+                self._wfile.flush()
 
             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 on_readable(self) -> None:
-        try:
-            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):
+            try:
+                if i is not None:
+                    o = gen.send(i)
+                else:
+                    o = next(gen)
+            except StopIteration:
                 break
 
-        if wb.rem < 1:
-            self._write_buf = None
-            self._cur_io = None
-            self._next_io()
-
 
 ########################################
 # ../dispatchers.py
@@ -8110,6 +8352,135 @@ class SupervisorSetupImpl(SupervisorSetup):
         os.umask(self._config.umask)
 
 
+########################################
+# ../../../omlish/http/coro/fdio.py
+
+
+class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+            handler: HttpHandler,
+            *,
+            read_size: int = 0x10000,
+            write_size: int = 0x10000,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+    ) -> None:
+        check.state(not sock.getblocking())
+
+        super().__init__(addr, sock)
+
+        self._handler = handler
+        self._read_size = read_size
+        self._write_size = write_size
+        self._log_handler = log_handler
+
+        self._read_buf = ReadableListBuffer()
+        self._write_buf: IncrementalWriteBuffer | None = None
+
+        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
+
+        self._cur_io: CoroHttpServer.Io | None = None
+        self._next_io()
+
+    #
+
+    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):
+                if self._log_handler is not None:
+                    self._log_handler(self._coro_srv, 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 on_readable(self) -> None:
+        try:
+            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()
+
+
 ########################################
 # ../groups.py
 
@@ -9685,7 +10056,7 @@ def main(
 
     # if we hup, restart by making a new Supervisor()
     for epoch in itertools.count():
-        config = read_config_file(
+        config = load_config_file_obj(
             os.path.expanduser(cf),
             ServerConfig,
             prepare=prepare_server_config,