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

ominfra/scripts/manage.py

@@ -16,6 +16,7 @@ import asyncio.subprocess
 import base64
 import collections
 import collections.abc
+import configparser
 import contextlib
 import contextvars
 import ctypes as ct
@@ -73,17 +74,23 @@ VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalTy
 VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # noqa
 VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
 
-# ../../omdev/toml/parser.py
-TomlParseFloat = ta.Callable[[str], ta.Any]
-TomlKey = ta.Tuple[str, ...]
-TomlPos = int  # ta.TypeAlias
-
 # deploy/paths/types.py
 DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
 
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
+# ../../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)
@@ -113,6 +120,9 @@ CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 # ../../omlish/argparse/cli.py
 ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
+# ../../omlish/configs/formats.py
+ConfigDataT = ta.TypeVar('ConfigDataT', bound='ConfigData')
+
 # ../../omlish/lite/contextmanagers.py
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
 
@@ -127,10 +137,6 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 AtomicPathSwapKind = ta.Literal['dir', 'file']
 AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
 
-# ../configs.py
-ConfigMapping = ta.Mapping[str, ta.Any]
-IniConfigSectionSettingsMap = ta.Mapping[str, ta.Mapping[str, ta.Union[str, ta.Sequence[str]]]]  # ta.TypeAlias
-
 # ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
@@ -549,1482 +555,1653 @@ def canonicalize_version(
 
 
 ########################################
-# ../../../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
+# ../config.py
 
 
-##
+@dc.dataclass(frozen=True)
+class MainConfig:
+    log_level: ta.Optional[str] = 'INFO'
 
+    debug: bool = False
 
-_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,
-)
+########################################
+# ../deploy/config.py
 
 
-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)
 
+@dc.dataclass(frozen=True)
+class DeployConfig:
+    pass
 
-@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),
-        ),
-    )
 
+########################################
+# ../deploy/paths/types.py
 
-def toml_match_to_localtime(match: re.Match) -> datetime.time:
-    hour_str, minute_str, sec_str, micros_str = match.groups()
-    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
-    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
 
+##
 
-def toml_match_to_number(match: re.Match, parse_float: TomlParseFloat) -> ta.Any:
-    if match.group('floatpart'):
-        return parse_float(match.group())
-    return int(match.group(), 0)
 
+########################################
+# ../deploy/types.py
 
-TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
 
-# Neither of these sets include quotation mark or backslash. They are currently handled as separate cases in the parser
-# functions.
-TOML_ILLEGAL_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t')
-TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t\n')
+##
 
-TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
-TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
 
-TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+DeployHome = ta.NewType('DeployHome', str)
 
-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)
+DeployRev = ta.NewType('DeployRev', str)
 
-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
-    },
-)
 
+########################################
+# ../../pyremote.py
+"""
+Basically this: https://mitogen.networkgenomics.com/howitworks.html
 
-class TomlDecodeError(ValueError):
-    """An error raised if a document is not valid TOML."""
+TODO:
+ - log: ta.Optional[logging.Logger] = None + log.debug's
+"""
 
 
-def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
-    """Parse TOML from a binary file object."""
-    b = fp.read()
-    try:
-        s = b.decode()
-    except AttributeError:
-        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
-    return toml_loads(s, parse_float=parse_float)
+##
 
 
-def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
-    """Parse TOML from a string."""
+@dc.dataclass(frozen=True)
+class PyremoteBootstrapOptions:
+    debug: bool = False
 
-    # 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)
+    DEFAULT_MAIN_NAME_OVERRIDE: ta.ClassVar[str] = '__pyremote__'
+    main_name_override: ta.Optional[str] = DEFAULT_MAIN_NAME_OVERRIDE
 
-    # 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
+@dc.dataclass(frozen=True)
+class PyremoteEnvInfo:
+    sys_base_prefix: str
+    sys_byteorder: str
+    sys_defaultencoding: str
+    sys_exec_prefix: str
+    sys_executable: str
+    sys_implementation_name: str
+    sys_path: ta.List[str]
+    sys_platform: str
+    sys_prefix: str
+    sys_version: str
+    sys_version_info: ta.List[ta.Union[int, str]]
 
-    return out.data.dict
+    platform_architecture: ta.List[str]
+    platform_machine: str
+    platform_platform: str
+    platform_processor: str
+    platform_system: str
+    platform_release: str
+    platform_version: str
 
+    site_userbase: str
 
-class TomlFlags:
-    """Flags that map to parsed keys/namespaces."""
+    os_cwd: str
+    os_gid: int
+    os_loadavg: ta.List[float]
+    os_login: ta.Optional[str]
+    os_pgrp: int
+    os_pid: int
+    os_ppid: int
+    os_uid: int
 
-    # 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
+    pw_name: str
+    pw_uid: int
+    pw_gid: int
+    pw_gecos: str
+    pw_dir: str
+    pw_shell: str
 
-    def __init__(self) -> None:
-        self._flags: ta.Dict[str, dict] = {}
-        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
+    env_path: ta.Optional[str]
 
-    def add_pending(self, key: TomlKey, flag: int) -> None:
-        self._pending_flags.add((key, flag))
 
-    def finalize_pending(self) -> None:
-        for key, flag in self._pending_flags:
-            self.set(key, flag, recursive=False)
-        self._pending_flags.clear()
+def _get_pyremote_env_info() -> PyremoteEnvInfo:
+    os_uid = os.getuid()
 
-    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)
+    pw = pwd.getpwuid(os_uid)
 
-    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)
+    os_login: ta.Optional[str]
+    try:
+        os_login = os.getlogin()
+    except OSError:
+        os_login = None
 
-    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
+    return PyremoteEnvInfo(
+        sys_base_prefix=sys.base_prefix,
+        sys_byteorder=sys.byteorder,
+        sys_defaultencoding=sys.getdefaultencoding(),
+        sys_exec_prefix=sys.exec_prefix,
+        sys_executable=sys.executable,
+        sys_implementation_name=sys.implementation.name,
+        sys_path=sys.path,
+        sys_platform=sys.platform,
+        sys_prefix=sys.prefix,
+        sys_version=sys.version,
+        sys_version_info=list(sys.version_info),
 
+        platform_architecture=list(platform.architecture()),
+        platform_machine=platform.machine(),
+        platform_platform=platform.platform(),
+        platform_processor=platform.processor(),
+        platform_system=platform.system(),
+        platform_release=platform.release(),
+        platform_version=platform.version(),
 
-class TomlNestedDict:
-    def __init__(self) -> None:
-        # The parsed content of the TOML document
-        self.dict: ta.Dict[str, ta.Any] = {}
+        site_userbase=site.getuserbase(),
 
-    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
+        os_cwd=os.getcwd(),
+        os_gid=os.getgid(),
+        os_loadavg=list(os.getloadavg()),
+        os_login=os_login,
+        os_pgrp=os.getpgrp(),
+        os_pid=os.getpid(),
+        os_ppid=os.getppid(),
+        os_uid=os_uid,
 
-    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] = [{}]
+        pw_name=pw.pw_name,
+        pw_uid=pw.pw_uid,
+        pw_gid=pw.pw_gid,
+        pw_gecos=pw.pw_gecos,
+        pw_dir=pw.pw_dir,
+        pw_shell=pw.pw_shell,
 
+        env_path=os.environ.get('PATH'),
+    )
 
-class TomlOutput(ta.NamedTuple):
-    data: TomlNestedDict
-    flags: TomlFlags
 
+##
 
-def toml_skip_chars(src: str, pos: TomlPos, chars: ta.Iterable[str]) -> TomlPos:
-    try:
-        while src[pos] in chars:
-            pos += 1
-    except IndexError:
-        pass
-    return pos
 
+_PYREMOTE_BOOTSTRAP_INPUT_FD = 100
+_PYREMOTE_BOOTSTRAP_SRC_FD = 101
 
-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
+_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR = '_OPYR_CHILD_PID'
+_PYREMOTE_BOOTSTRAP_ARGV0_VAR = '_OPYR_ARGV0'
+_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR = '_OPYR_CONTEXT_NAME'
+_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR = '_OPYR_SRC_FILE'
+_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR = '_OPYR_OPTIONS_JSON'
 
-    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
+_PYREMOTE_BOOTSTRAP_ACK0 = b'OPYR000\n'
+_PYREMOTE_BOOTSTRAP_ACK1 = b'OPYR001\n'
+_PYREMOTE_BOOTSTRAP_ACK2 = b'OPYR002\n'
+_PYREMOTE_BOOTSTRAP_ACK3 = b'OPYR003\n'
 
+_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT = '(pyremote:%s)'
 
-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
+_PYREMOTE_BOOTSTRAP_IMPORTS = [
+    'base64',
+    'os',
+    'struct',
+    'sys',
+    'zlib',
+]
 
 
-def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
-    while True:
-        pos_before_skip = pos
-        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
-        pos = toml_skip_comment(src, pos)
-        if pos == pos_before_skip:
-            return pos
+def _pyremote_bootstrap_main(context_name: str) -> None:
+    # Get pid
+    pid = os.getpid()
 
+    # Two copies of payload src to be sent to parent
+    r0, w0 = os.pipe()
+    r1, w1 = os.pipe()
 
-def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
-    pos += 1  # Skip "["
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    pos, key = toml_parse_key(src, pos)
+    if (cp := os.fork()):
+        # Parent process
 
-    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
+        # Dup original stdin to comm_fd for use as comm channel
+        os.dup2(0, _PYREMOTE_BOOTSTRAP_INPUT_FD)
 
-    if not src.startswith(']', pos):
-        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
-    return pos + 1, key
+        # Overwrite stdin (fed to python repl) with first copy of src
+        os.dup2(r0, 0)
 
+        # Dup second copy of src to src_fd to recover after launch
+        os.dup2(r1, _PYREMOTE_BOOTSTRAP_SRC_FD)
 
-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)
+        # Close remaining fd's
+        for f in [r0, w0, r1, w1]:
+            os.close(f)
 
-    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
+        # Save vars
+        env = os.environ
+        exe = sys.executable
+        env[_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR] = str(cp)
+        env[_PYREMOTE_BOOTSTRAP_ARGV0_VAR] = exe
+        env[_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR] = context_name
 
-    if not src.startswith(']]', pos):
-        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
-    return pos + 2, key
+        # Start repl reading stdin from r0
+        os.execl(exe, exe + (_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT % (context_name,)))
 
+    else:
+        # Child process
 
-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
+        # Write first ack
+        os.write(1, _PYREMOTE_BOOTSTRAP_ACK0)
 
-    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)
+        # Write pid
+        os.write(1, struct.pack('<Q', pid))
 
-    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
-        raise toml_suffixed_err(
-            src,
-            pos,
-            f'Cannot mutate immutable namespace {abs_key_parent}',
-        )
+        # Read payload src from stdin
+        payload_z_len = struct.unpack('<I', os.read(0, 4))[0]
+        if len(payload_z := os.fdopen(0, 'rb').read(payload_z_len)) != payload_z_len:
+            raise EOFError
+        payload_src = zlib.decompress(payload_z)
 
-    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
+        # Write both copies of payload src. Must write to w0 (parent stdin) before w1 (copy pipe) as pipe will likely
+        # fill and block and need to be drained by pyremote_bootstrap_finalize running in parent.
+        for w in [w0, w1]:
+            fp = os.fdopen(w, 'wb', 0)
+            fp.write(payload_src)
+            fp.close()
 
+        # Write second ack
+        os.write(1, _PYREMOTE_BOOTSTRAP_ACK1)
 
-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
+        # Exit child
+        sys.exit(0)
 
 
-def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
-    pos, key_part = toml_parse_key_part(src, pos)
-    key: TomlKey = (key_part,)
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    while True:
-        try:
-            char: ta.Optional[str] = src[pos]
-        except IndexError:
-            char = None
-        if char != '.':
-            return pos, key
-        pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS)
-        pos, key_part = toml_parse_key_part(src, pos)
-        key += (key_part,)
-        pos = toml_skip_chars(src, pos, TOML_WS)
+##
 
 
-def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
-    try:
-        char: ta.Optional[str] = src[pos]
-    except IndexError:
-        char = None
-    if char in TOML_BARE_KEY_CHARS:
-        start_pos = pos
-        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
-        return pos, src[start_pos:pos]
-    if char == "'":
-        return toml_parse_literal_str(src, pos)
-    if char == '"':
-        return toml_parse_one_line_basic_str(src, pos)
-    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
+def pyremote_build_bootstrap_cmd(context_name: str) -> str:
+    if any(c in context_name for c in '\'"'):
+        raise NameError(context_name)
 
+    import inspect
+    import textwrap
+    bs_src = textwrap.dedent(inspect.getsource(_pyremote_bootstrap_main))
 
-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)
+    for gl in [
+        '_PYREMOTE_BOOTSTRAP_INPUT_FD',
+        '_PYREMOTE_BOOTSTRAP_SRC_FD',
 
+        '_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR',
+        '_PYREMOTE_BOOTSTRAP_ARGV0_VAR',
+        '_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR',
 
-def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
-    pos += 1
-    array: list = []
+        '_PYREMOTE_BOOTSTRAP_ACK0',
+        '_PYREMOTE_BOOTSTRAP_ACK1',
 
-    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)
+        '_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT',
+    ]:
+        bs_src = bs_src.replace(gl, repr(globals()[gl]))
 
-        c = src[pos:pos + 1]
-        if c == ']':
-            return pos + 1, array
-        if c != ',':
-            raise toml_suffixed_err(src, pos, 'Unclosed array')
-        pos += 1
+    bs_src = '\n'.join(
+        cl
+        for l in bs_src.splitlines()
+        if (cl := (l.split('#')[0]).rstrip())
+        if cl.strip()
+    )
 
-        pos = toml_skip_comments_and_array_ws(src, pos)
-        if src.startswith(']', pos):
-            return pos + 1, array
+    bs_z = zlib.compress(bs_src.encode('utf-8'), 9)
+    bs_z85 = base64.b85encode(bs_z).replace(b'\n', b'')
+    if b'"' in bs_z85:
+        raise ValueError(bs_z85)
 
+    stmts = [
+        f'import {", ".join(_PYREMOTE_BOOTSTRAP_IMPORTS)}',
+        f'exec(zlib.decompress(base64.b85decode(b"{bs_z85.decode("ascii")}")))',
+        f'_pyremote_bootstrap_main("{context_name}")',
+    ]
 
-def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
-    pos += 1
-    nested_dict = TomlNestedDict()
-    flags = TomlFlags()
+    cmd = '; '.join(stmts)
+    return cmd
 
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    if src.startswith('}', pos):
-        return pos + 1, nested_dict.dict
-    while True:
-        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
-        key_parent, key_stem = key[:-1], key[-1]
-        if flags.is_(key, TomlFlags.FROZEN):
-            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
-        try:
-            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
-        except KeyError:
-            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
-        if key_stem in nest:
-            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
-        nest[key_stem] = value
-        pos = toml_skip_chars(src, pos, TOML_WS)
-        c = src[pos:pos + 1]
-        if c == '}':
-            return pos + 1, nested_dict.dict
-        if c != ',':
-            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
-        if isinstance(value, (dict, list)):
-            flags.set(key, TomlFlags.FROZEN, recursive=True)
-        pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS)
 
+##
 
-def toml_parse_basic_str_escape(
-        src: str,
-        pos: TomlPos,
-        *,
-        multiline: bool = False,
-) -> ta.Tuple[TomlPos, str]:
-    escape_id = src[pos:pos + 2]
-    pos += 2
-    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
-        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
-        # newline.
-        if escape_id != '\\\n':
-            pos = toml_skip_chars(src, pos, TOML_WS)
-            try:
-                char = src[pos]
-            except IndexError:
-                return pos, ''
-            if char != '\n':
-                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
-            pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
-        return pos, ''
-    if escape_id == '\\u':
-        return toml_parse_hex_char(src, pos, 4)
-    if escape_id == '\\U':
-        return toml_parse_hex_char(src, pos, 8)
-    try:
-        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
-    except KeyError:
-        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
 
+@dc.dataclass(frozen=True)
+class PyremotePayloadRuntime:
+    input: ta.BinaryIO
+    output: ta.BinaryIO
+    context_name: str
+    payload_src: str
+    options: PyremoteBootstrapOptions
+    env_info: PyremoteEnvInfo
 
-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 pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
+    # If src file var is not present we need to do initial finalization
+    if _PYREMOTE_BOOTSTRAP_SRC_FILE_VAR not in os.environ:
+        # Read second copy of payload src
+        r1 = os.fdopen(_PYREMOTE_BOOTSTRAP_SRC_FD, 'rb', 0)
+        payload_src = r1.read().decode('utf-8')
+        r1.close()
 
-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)
+        # Reap boostrap child. Must be done after reading second copy of source because source may be too big to fit in
+        # a pipe at once.
+        os.waitpid(int(os.environ.pop(_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR)), 0)
 
+        # Read options
+        options_json_len = struct.unpack('<I', os.read(_PYREMOTE_BOOTSTRAP_INPUT_FD, 4))[0]
+        if len(options_json := os.read(_PYREMOTE_BOOTSTRAP_INPUT_FD, options_json_len)) != options_json_len:
+            raise EOFError
+        options = PyremoteBootstrapOptions(**json.loads(options_json.decode('utf-8')))
 
-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
+        # If debugging, re-exec as file
+        if options.debug:
+            # Write temp source file
+            import tempfile
+            tfd, tfn = tempfile.mkstemp('-pyremote.py')
+            os.write(tfd, payload_src.encode('utf-8'))
+            os.close(tfd)
 
+            # Set vars
+            os.environ[_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR] = tfn
+            os.environ[_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR] = options_json.decode('utf-8')
 
-def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
-    pos += 3
-    if src.startswith('\n', pos):
-        pos += 1
+            # Re-exec temp file
+            exe = os.environ[_PYREMOTE_BOOTSTRAP_ARGV0_VAR]
+            context_name = os.environ[_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR]
+            os.execl(exe, exe + (_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT % (context_name,)), tfn)
 
-    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)
+        # Load options json var
+        options_json_str = os.environ.pop(_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR)
+        options = PyremoteBootstrapOptions(**json.loads(options_json_str))
 
-    # 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)
+        # Read temp source file
+        with open(os.environ.pop(_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR)) as sf:
+            payload_src = sf.read()
 
+    # Restore vars
+    sys.executable = os.environ.pop(_PYREMOTE_BOOTSTRAP_ARGV0_VAR)
+    context_name = os.environ.pop(_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR)
 
-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
+    # Write third ack
+    os.write(1, _PYREMOTE_BOOTSTRAP_ACK2)
 
+    # Write env info
+    env_info = _get_pyremote_env_info()
+    env_info_json = json.dumps(dc.asdict(env_info), indent=None, separators=(',', ':'))  # noqa
+    os.write(1, struct.pack('<I', len(env_info_json)))
+    os.write(1, env_info_json.encode('utf-8'))
 
-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
+    # Setup IO
+    input = os.fdopen(_PYREMOTE_BOOTSTRAP_INPUT_FD, 'rb', 0)  # noqa
+    output = os.fdopen(os.dup(1), 'wb', 0)  # noqa
+    os.dup2(nfd := os.open('/dev/null', os.O_WRONLY), 1)
+    os.close(nfd)
 
-    # IMPORTANT: order conditions based on speed of checking and likelihood
+    if (mn := options.main_name_override) is not None:
+        # Inspections like typing.get_type_hints need an entry in sys.modules.
+        sys.modules[mn] = sys.modules['__main__']
 
-    # 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)
+    # Write fourth ack
+    output.write(_PYREMOTE_BOOTSTRAP_ACK3)
 
-    # Literal strings
-    if char == "'":
-        if src.startswith("'''", pos):
-            return toml_parse_multiline_str(src, pos, literal=True)
-        return toml_parse_literal_str(src, pos)
+    # Return
+    return PyremotePayloadRuntime(
+        input=input,
+        output=output,
+        context_name=context_name,
+        payload_src=payload_src,
+        options=options,
+        env_info=env_info,
+    )
 
-    # Booleans
-    if char == 't':
-        if src.startswith('true', pos):
-            return pos + 4, True
-    if char == 'f':
-        if src.startswith('false', pos):
-            return pos + 5, False
 
-    # Arrays
-    if char == '[':
-        return toml_parse_array(src, pos, parse_float)
+##
 
-    # Inline tables
-    if char == '{':
-        return toml_parse_inline_table(src, pos, parse_float)
 
-    # Dates and times
-    datetime_match = TOML_RE_DATETIME.match(src, pos)
-    if datetime_match:
-        try:
-            datetime_obj = toml_match_to_datetime(datetime_match)
-        except ValueError as e:
-            raise toml_suffixed_err(src, pos, 'Invalid date or datetime') from e
-        return datetime_match.end(), datetime_obj
-    localtime_match = TOML_RE_LOCALTIME.match(src, pos)
-    if localtime_match:
-        return localtime_match.end(), toml_match_to_localtime(localtime_match)
+class PyremoteBootstrapDriver:
+    def __init__(
+            self,
+            payload_src: ta.Union[str, ta.Sequence[str]],
+            options: PyremoteBootstrapOptions = PyremoteBootstrapOptions(),
+    ) -> None:
+        super().__init__()
 
-    # 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)
+        self._payload_src = payload_src
+        self._options = options
 
-    # 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)
+        self._prepared_payload_src = self._prepare_payload_src(payload_src, options)
+        self._payload_z = zlib.compress(self._prepared_payload_src.encode('utf-8'))
 
-    raise toml_suffixed_err(src, pos, 'Invalid value')
+        self._options_json = json.dumps(dc.asdict(options), indent=None, separators=(',', ':')).encode('utf-8')  # noqa
+    #
 
+    @classmethod
+    def _prepare_payload_src(
+            cls,
+            payload_src: ta.Union[str, ta.Sequence[str]],
+            options: PyremoteBootstrapOptions,
+    ) -> str:
+        parts: ta.List[str]
+        if isinstance(payload_src, str):
+            parts = [payload_src]
+        else:
+            parts = list(payload_src)
 
-def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
-    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
+        if (mn := options.main_name_override) is not None:
+            parts.insert(0, f'__name__ = {mn!r}')
 
-    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
+        if len(parts) == 1:
+            return parts[0]
         else:
-            column = pos - src.rindex('\n', 0, pos)
-        return f'line {line}, column {column}'
+            return '\n\n'.join(parts)
 
-    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
+    #
 
+    @dc.dataclass(frozen=True)
+    class Read:
+        sz: int
 
-def toml_is_unicode_scalar_value(codepoint: int) -> bool:
-    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
+    @dc.dataclass(frozen=True)
+    class Write:
+        d: bytes
 
+    class ProtocolError(Exception):
+        pass
 
-def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
-    """A decorator to make `parse_float` safe.
+    @dc.dataclass(frozen=True)
+    class Result:
+        pid: int
+        env_info: PyremoteEnvInfo
 
-    `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 gen(self) -> ta.Generator[ta.Union[Read, Write], ta.Optional[bytes], Result]:
+        # Read first ack (after fork)
+        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK0)
 
-    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
+        # Read pid
+        d = yield from self._read(8)
+        pid = struct.unpack('<Q', d)[0]
 
-    return safe_parse_float
+        # Write payload src
+        yield from self._write(struct.pack('<I', len(self._payload_z)))
+        yield from self._write(self._payload_z)
 
+        # Read second ack (after writing src copies)
+        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK1)
 
-########################################
-# ../config.py
+        # Write options
+        yield from self._write(struct.pack('<I', len(self._options_json)))
+        yield from self._write(self._options_json)
 
+        # Read third ack (after reaping child process)
+        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK2)
 
-@dc.dataclass(frozen=True)
-class MainConfig:
-    log_level: ta.Optional[str] = 'INFO'
+        # Read env info
+        d = yield from self._read(4)
+        env_info_json_len = struct.unpack('<I', d)[0]
+        d = yield from self._read(env_info_json_len)
+        env_info_json = d.decode('utf-8')
+        env_info = PyremoteEnvInfo(**json.loads(env_info_json))
 
-    debug: bool = False
+        # Read fourth ack (after finalization completed)
+        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK3)
 
+        # Return
+        return self.Result(
+            pid=pid,
+            env_info=env_info,
+        )
 
-########################################
-# ../deploy/config.py
+    def _read(self, sz: int) -> ta.Generator[Read, bytes, bytes]:
+        d = yield self.Read(sz)
+        if not isinstance(d, bytes):
+            raise self.ProtocolError(f'Expected bytes after read, got {d!r}')
+        if len(d) != sz:
+            raise self.ProtocolError(f'Read {len(d)} bytes, expected {sz}')
+        return d
 
+    def _expect(self, e: bytes) -> ta.Generator[Read, bytes, None]:
+        d = yield from self._read(len(e))
+        if d != e:
+            raise self.ProtocolError(f'Read {d!r}, expected {e!r}')
 
-##
+    def _write(self, d: bytes) -> ta.Generator[Write, ta.Optional[bytes], None]:
+        i = yield self.Write(d)
+        if i is not None:
+            raise self.ProtocolError('Unexpected input after write')
 
+    #
 
-@dc.dataclass(frozen=True)
-class DeployConfig:
-    pass
+    def run(self, input: ta.IO, output: ta.IO) -> Result:  # noqa
+        gen = self.gen()
 
+        gi: ta.Optional[bytes] = None
+        while True:
+            try:
+                if gi is not None:
+                    go = gen.send(gi)
+                else:
+                    go = next(gen)
+            except StopIteration as e:
+                return e.value
 
-########################################
-# ../deploy/paths/types.py
+            if isinstance(go, self.Read):
+                if len(gi := input.read(go.sz)) != go.sz:
+                    raise EOFError
+            elif isinstance(go, self.Write):
+                gi = None
+                output.write(go.d)
+                output.flush()
+            else:
+                raise TypeError(go)
 
+    async def async_run(
+            self,
+            input: ta.Any,  # asyncio.StreamWriter  # noqa
+            output: ta.Any,  # asyncio.StreamReader
+    ) -> Result:
+        gen = self.gen()
 
-##
+        gi: ta.Optional[bytes] = None
+        while True:
+            try:
+                if gi is not None:
+                    go = gen.send(gi)
+                else:
+                    go = next(gen)
+            except StopIteration as e:
+                return e.value
+
+            if isinstance(go, self.Read):
+                if len(gi := await input.read(go.sz)) != go.sz:
+                    raise EOFError
+            elif isinstance(go, self.Write):
+                gi = None
+                output.write(go.d)
+                await output.drain()
+            else:
+                raise TypeError(go)
 
 
 ########################################
-# ../deploy/types.py
+# ../../../omlish/asyncs/asyncio/channels.py
 
 
-##
+class AsyncioBytesChannelTransport(asyncio.Transport):
+    def __init__(self, reader: asyncio.StreamReader) -> None:
+        super().__init__()
 
+        self.reader = reader
+        self.closed: asyncio.Future = asyncio.Future()
 
-DeployHome = ta.NewType('DeployHome', str)
+    # @ta.override
+    def write(self, data: bytes) -> None:
+        self.reader.feed_data(data)
 
-DeployRev = ta.NewType('DeployRev', str)
+    # @ta.override
+    def close(self) -> None:
+        self.reader.feed_eof()
+        if not self.closed.done():
+            self.closed.set_result(True)
 
+    # @ta.override
+    def is_closing(self) -> bool:
+        return self.closed.done()
 
-########################################
-# ../../pyremote.py
-"""
-Basically this: https://mitogen.networkgenomics.com/howitworks.html
 
-TODO:
- - log: ta.Optional[logging.Logger] = None + log.debug's
-"""
+def asyncio_create_bytes_channel(
+        loop: ta.Any = None,
+) -> ta.Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
+    if loop is None:
+        loop = asyncio.get_running_loop()
 
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    transport = AsyncioBytesChannelTransport(reader)
+    writer = asyncio.StreamWriter(transport, protocol, reader, loop)
 
-##
+    return reader, writer
 
 
-@dc.dataclass(frozen=True)
-class PyremoteBootstrapOptions:
-    debug: bool = False
+########################################
+# ../../../omlish/asyncs/asyncio/streams.py
 
-    DEFAULT_MAIN_NAME_OVERRIDE: ta.ClassVar[str] = '__pyremote__'
-    main_name_override: ta.Optional[str] = DEFAULT_MAIN_NAME_OVERRIDE
 
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
 
-##
 
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
 
-@dc.dataclass(frozen=True)
-class PyremoteEnvInfo:
-    sys_base_prefix: str
-    sys_byteorder: str
-    sys_defaultencoding: str
-    sys_exec_prefix: str
-    sys_executable: str
-    sys_implementation_name: str
-    sys_path: ta.List[str]
-    sys_platform: str
-    sys_prefix: str
-    sys_version: str
-    sys_version_info: ta.List[ta.Union[int, str]]
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
 
-    platform_architecture: ta.List[str]
-    platform_machine: str
-    platform_platform: str
-    platform_processor: str
-    platform_system: str
-    platform_release: str
-    platform_version: str
+    return reader
 
-    site_userbase: str
 
-    os_cwd: str
-    os_gid: int
-    os_loadavg: ta.List[float]
-    os_login: ta.Optional[str]
-    os_pgrp: int
-    os_pid: int
-    os_ppid: int
-    os_uid: int
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
 
-    pw_name: str
-    pw_uid: int
-    pw_gid: int
-    pw_gecos: str
-    pw_dir: str
-    pw_shell: str
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
 
-    env_path: ta.Optional[str]
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )
 
 
-def _get_pyremote_env_info() -> PyremoteEnvInfo:
-    os_uid = os.getuid()
+########################################
+# ../../../omlish/asyncs/asyncio/timeouts.py
 
-    pw = pwd.getpwuid(os_uid)
 
-    os_login: ta.Optional[str]
-    try:
-        os_login = os.getlogin()
-    except OSError:
-        os_login = None
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut
 
-    return PyremoteEnvInfo(
-        sys_base_prefix=sys.base_prefix,
-        sys_byteorder=sys.byteorder,
-        sys_defaultencoding=sys.getdefaultencoding(),
-        sys_exec_prefix=sys.exec_prefix,
-        sys_executable=sys.executable,
-        sys_implementation_name=sys.implementation.name,
-        sys_path=sys.path,
-        sys_platform=sys.platform,
-        sys_prefix=sys.prefix,
-        sys_version=sys.version,
-        sys_version_info=list(sys.version_info),
 
-        platform_architecture=list(platform.architecture()),
-        platform_machine=platform.machine(),
-        platform_platform=platform.platform(),
-        platform_processor=platform.processor(),
-        platform_system=platform.system(),
-        platform_release=platform.release(),
-        platform_version=platform.version(),
+########################################
+# ../../../omlish/configs/types.py
 
-        site_userbase=site.getuserbase(),
 
-        os_cwd=os.getcwd(),
-        os_gid=os.getgid(),
-        os_loadavg=list(os.getloadavg()),
-        os_login=os_login,
-        os_pgrp=os.getpgrp(),
-        os_pid=os.getpid(),
-        os_ppid=os.getppid(),
-        os_uid=os_uid,
+#
 
-        pw_name=pw.pw_name,
-        pw_uid=pw.pw_uid,
-        pw_gid=pw.pw_gid,
-        pw_gecos=pw.pw_gecos,
-        pw_dir=pw.pw_dir,
-        pw_shell=pw.pw_shell,
 
-        env_path=os.environ.get('PATH'),
-    )
+########################################
+# ../../../omlish/formats/ini/sections.py
 
 
 ##
 
 
-_PYREMOTE_BOOTSTRAP_INPUT_FD = 100
-_PYREMOTE_BOOTSTRAP_SRC_FD = 101
-
-_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR = '_OPYR_CHILD_PID'
-_PYREMOTE_BOOTSTRAP_ARGV0_VAR = '_OPYR_ARGV0'
-_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR = '_OPYR_CONTEXT_NAME'
-_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR = '_OPYR_SRC_FILE'
-_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR = '_OPYR_OPTIONS_JSON'
+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
 
-_PYREMOTE_BOOTSTRAP_ACK0 = b'OPYR000\n'
-_PYREMOTE_BOOTSTRAP_ACK1 = b'OPYR001\n'
-_PYREMOTE_BOOTSTRAP_ACK2 = b'OPYR002\n'
-_PYREMOTE_BOOTSTRAP_ACK3 = b'OPYR003\n'
 
-_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT = '(pyremote:%s)'
+##
 
-_PYREMOTE_BOOTSTRAP_IMPORTS = [
-    'base64',
-    'os',
-    'struct',
-    'sys',
-    'zlib',
-]
 
+def render_ini_sections(
+        settings_by_section: IniSectionSettingsMap,
+) -> str:
+    out = io.StringIO()
 
-def _pyremote_bootstrap_main(context_name: str) -> None:
-    # Get pid
-    pid = os.getpid()
+    for i, (section, settings) in enumerate(settings_by_section.items()):
+        if i:
+            out.write('\n')
 
-    # Two copies of payload src to be sent to parent
-    r0, w0 = os.pipe()
-    r1, w1 = os.pipe()
+        out.write(f'[{section}]\n')
 
-    if (cp := os.fork()):
-        # Parent process
+        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')
 
-        # Dup original stdin to comm_fd for use as comm channel
-        os.dup2(0, _PYREMOTE_BOOTSTRAP_INPUT_FD)
+    return out.getvalue()
 
-        # Overwrite stdin (fed to python repl) with first copy of src
-        os.dup2(r0, 0)
 
-        # Dup second copy of src to src_fd to recover after launch
-        os.dup2(r1, _PYREMOTE_BOOTSTRAP_SRC_FD)
+########################################
+# ../../../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
 
-        # Close remaining fd's
-        for f in [r0, w0, r1, w1]:
-            os.close(f)
 
-        # Save vars
-        env = os.environ
-        exe = sys.executable
-        env[_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR] = str(cp)
-        env[_PYREMOTE_BOOTSTRAP_ARGV0_VAR] = exe
-        env[_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR] = context_name
+##
 
-        # Start repl reading stdin from r0
-        os.execl(exe, exe + (_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT % (context_name,)))
 
-    else:
-        # Child 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]*)?'
 
-        # Write first ack
-        os.write(1, _PYREMOTE_BOOTSTRAP_ACK0)
+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,
+)
 
-        # Write pid
-        os.write(1, struct.pack('<Q', pid))
 
-        # Read payload src from stdin
-        payload_z_len = struct.unpack('<I', os.read(0, 4))[0]
-        if len(payload_z := os.fdopen(0, 'rb').read(payload_z_len)) != payload_z_len:
-            raise EOFError
-        payload_src = zlib.decompress(payload_z)
+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`.
 
-        # Write both copies of payload src. Must write to w0 (parent stdin) before w1 (copy pipe) as pipe will likely
-        # fill and block and need to be drained by pyremote_bootstrap_finalize running in parent.
-        for w in [w0, w1]:
-            fp = os.fdopen(w, 'wb', 0)
-            fp.write(payload_src)
-            fp.close()
+    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)
 
-        # Write second ack
-        os.write(1, _PYREMOTE_BOOTSTRAP_ACK1)
 
-        # Exit child
-        sys.exit(0)
+@functools.lru_cache()  # noqa
+def toml_cached_tz(hour_str: str, minute_str: str, sign_str: str) -> datetime.timezone:
+    sign = 1 if sign_str == '+' else -1
+    return datetime.timezone(
+        datetime.timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        ),
+    )
 
 
-##
+def toml_match_to_localtime(match: re.Match) -> datetime.time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
 
 
-def pyremote_build_bootstrap_cmd(context_name: str) -> str:
-    if any(c in context_name for c in '\'"'):
-        raise NameError(context_name)
+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)
 
-    import inspect
-    import textwrap
-    bs_src = textwrap.dedent(inspect.getsource(_pyremote_bootstrap_main))
 
-    for gl in [
-        '_PYREMOTE_BOOTSTRAP_INPUT_FD',
-        '_PYREMOTE_BOOTSTRAP_SRC_FD',
+TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
 
-        '_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR',
-        '_PYREMOTE_BOOTSTRAP_ARGV0_VAR',
-        '_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR',
+# 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')
 
-        '_PYREMOTE_BOOTSTRAP_ACK0',
-        '_PYREMOTE_BOOTSTRAP_ACK1',
+TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
 
-        '_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT',
-    ]:
-        bs_src = bs_src.replace(gl, repr(globals()[gl]))
+TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
 
-    bs_src = '\n'.join(
-        cl
-        for l in bs_src.splitlines()
-        if (cl := (l.split('#')[0]).rstrip())
-        if cl.strip()
-    )
-
-    bs_z = zlib.compress(bs_src.encode('utf-8'), 9)
-    bs_z85 = base64.b85encode(bs_z).replace(b'\n', b'')
-    if b'"' in bs_z85:
-        raise ValueError(bs_z85)
-
-    stmts = [
-        f'import {", ".join(_PYREMOTE_BOOTSTRAP_IMPORTS)}',
-        f'exec(zlib.decompress(base64.b85decode(b"{bs_z85.decode("ascii")}")))',
-        f'_pyremote_bootstrap_main("{context_name}")',
-    ]
+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)
 
-    cmd = '; '.join(stmts)
-    return cmd
+TOML_BASIC_STR_ESCAPE_REPLACEMENTS = types.MappingProxyType(
+    {
+        '\\b': '\u0008',  # backspace
+        '\\t': '\u0009',  # tab
+        '\\n': '\u000A',  # linefeed
+        '\\f': '\u000C',  # form feed
+        '\\r': '\u000D',  # carriage return
+        '\\"': '\u0022',  # quote
+        '\\\\': '\u005C',  # backslash
+    },
+)
 
 
-##
+class TomlDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
 
 
-@dc.dataclass(frozen=True)
-class PyremotePayloadRuntime:
-    input: ta.BinaryIO
-    output: ta.BinaryIO
-    context_name: str
-    payload_src: str
-    options: PyremoteBootstrapOptions
-    env_info: PyremoteEnvInfo
+def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
+    """Parse TOML from a binary file object."""
+    b = fp.read()
+    try:
+        s = b.decode()
+    except AttributeError:
+        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
+    return toml_loads(s, parse_float=parse_float)
 
 
-def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
-    # If src file var is not present we need to do initial finalization
-    if _PYREMOTE_BOOTSTRAP_SRC_FILE_VAR not in os.environ:
-        # Read second copy of payload src
-        r1 = os.fdopen(_PYREMOTE_BOOTSTRAP_SRC_FD, 'rb', 0)
-        payload_src = r1.read().decode('utf-8')
-        r1.close()
+def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
+    """Parse TOML from a string."""
 
-        # Reap boostrap child. Must be done after reading second copy of source because source may be too big to fit in
-        # a pipe at once.
-        os.waitpid(int(os.environ.pop(_PYREMOTE_BOOTSTRAP_CHILD_PID_VAR)), 0)
+    # 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)
 
-        # Read options
-        options_json_len = struct.unpack('<I', os.read(_PYREMOTE_BOOTSTRAP_INPUT_FD, 4))[0]
-        if len(options_json := os.read(_PYREMOTE_BOOTSTRAP_INPUT_FD, options_json_len)) != options_json_len:
-            raise EOFError
-        options = PyremoteBootstrapOptions(**json.loads(options_json.decode('utf-8')))
+    # 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)
 
-        # If debugging, re-exec as file
-        if options.debug:
-            # Write temp source file
-            import tempfile
-            tfd, tfn = tempfile.mkstemp('-pyremote.py')
-            os.write(tfd, payload_src.encode('utf-8'))
-            os.close(tfd)
+        # 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')
 
-            # Set vars
-            os.environ[_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR] = tfn
-            os.environ[_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR] = options_json.decode('utf-8')
+        # 3. Skip comment
+        pos = toml_skip_comment(src, pos)
 
-            # Re-exec temp file
-            exe = os.environ[_PYREMOTE_BOOTSTRAP_ARGV0_VAR]
-            context_name = os.environ[_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR]
-            os.execl(exe, exe + (_PYREMOTE_BOOTSTRAP_PROC_TITLE_FMT % (context_name,)), tfn)
+        # 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
 
-    else:
-        # Load options json var
-        options_json_str = os.environ.pop(_PYREMOTE_BOOTSTRAP_OPTIONS_JSON_VAR)
-        options = PyremoteBootstrapOptions(**json.loads(options_json_str))
+    return out.data.dict
 
-        # Read temp source file
-        with open(os.environ.pop(_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR)) as sf:
-            payload_src = sf.read()
 
-    # Restore vars
-    sys.executable = os.environ.pop(_PYREMOTE_BOOTSTRAP_ARGV0_VAR)
-    context_name = os.environ.pop(_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR)
+class TomlFlags:
+    """Flags that map to parsed keys/namespaces."""
 
-    # Write third ack
-    os.write(1, _PYREMOTE_BOOTSTRAP_ACK2)
+    # 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
 
-    # Write env info
-    env_info = _get_pyremote_env_info()
-    env_info_json = json.dumps(dc.asdict(env_info), indent=None, separators=(',', ':'))  # noqa
-    os.write(1, struct.pack('<I', len(env_info_json)))
-    os.write(1, env_info_json.encode('utf-8'))
+    def __init__(self) -> None:
+        self._flags: ta.Dict[str, dict] = {}
+        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
 
-    # Setup IO
-    input = os.fdopen(_PYREMOTE_BOOTSTRAP_INPUT_FD, 'rb', 0)  # noqa
-    output = os.fdopen(os.dup(1), 'wb', 0)  # noqa
-    os.dup2(nfd := os.open('/dev/null', os.O_WRONLY), 1)
-    os.close(nfd)
+    def add_pending(self, key: TomlKey, flag: int) -> None:
+        self._pending_flags.add((key, flag))
 
-    if (mn := options.main_name_override) is not None:
-        # Inspections like typing.get_type_hints need an entry in sys.modules.
-        sys.modules[mn] = sys.modules['__main__']
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
 
-    # Write fourth ack
-    output.write(_PYREMOTE_BOOTSTRAP_ACK3)
+    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)
 
-    # Return
-    return PyremotePayloadRuntime(
-        input=input,
-        output=output,
-        context_name=context_name,
-        payload_src=payload_src,
-        options=options,
-        env_info=env_info,
-    )
+    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 PyremoteBootstrapDriver:
-    def __init__(
+    def get_or_create_nest(
             self,
-            payload_src: ta.Union[str, ta.Sequence[str]],
-            options: PyremoteBootstrapOptions = PyremoteBootstrapOptions(),
-    ) -> None:
-        super().__init__()
-
-        self._payload_src = payload_src
-        self._options = options
+            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
 
-        self._prepared_payload_src = self._prepare_payload_src(payload_src, options)
-        self._payload_z = zlib.compress(self._prepared_payload_src.encode('utf-8'))
+    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] = [{}]
 
-        self._options_json = json.dumps(dc.asdict(options), indent=None, separators=(',', ':')).encode('utf-8')  # noqa
-    #
 
-    @classmethod
-    def _prepare_payload_src(
-            cls,
-            payload_src: ta.Union[str, ta.Sequence[str]],
-            options: PyremoteBootstrapOptions,
-    ) -> str:
-        parts: ta.List[str]
-        if isinstance(payload_src, str):
-            parts = [payload_src]
-        else:
-            parts = list(payload_src)
+class TomlOutput(ta.NamedTuple):
+    data: TomlNestedDict
+    flags: TomlFlags
 
-        if (mn := options.main_name_override) is not None:
-            parts.insert(0, f'__name__ = {mn!r}')
 
-        if len(parts) == 1:
-            return parts[0]
-        else:
-            return '\n\n'.join(parts)
+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
 
-    #
 
-    @dc.dataclass(frozen=True)
-    class Read:
-        sz: int
+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
 
-    @dc.dataclass(frozen=True)
-    class Write:
-        d: bytes
+    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 ProtocolError(Exception):
-        pass
 
-    @dc.dataclass(frozen=True)
-    class Result:
-        pid: int
-        env_info: PyremoteEnvInfo
+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 gen(self) -> ta.Generator[ta.Union[Read, Write], ta.Optional[bytes], Result]:
-        # Read first ack (after fork)
-        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK0)
 
-        # Read pid
-        d = yield from self._read(8)
-        pid = struct.unpack('<Q', d)[0]
+def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
+    while True:
+        pos_before_skip = pos
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = toml_skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 1  # Skip "["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.EXPLICIT_NEST) or out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot declare {key} twice')
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+    return pos + 1, key
+
+
+def toml_create_list_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 2  # Skip "[["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']]', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+    return pos + 2, key
+
+
+def toml_key_value_rule(
+        src: str,
+        pos: TomlPos,
+        out: TomlOutput,
+        header: TomlKey,
+        parse_float: TomlParseFloat,
+) -> TomlPos:
+    pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
+    for cont_key in relative_path_cont_keys:
+        # Check that dotted key syntax does not redefine an existing table
+        if out.flags.is_(cont_key, TomlFlags.EXPLICIT_NEST):
+            raise toml_suffixed_err(src, pos, f'Cannot redefine namespace {cont_key}')
+        # Containers in the relative path can't be opened with the table syntax or dotted key/value syntax in following
+        # table sections.
+        out.flags.add_pending(cont_key, TomlFlags.EXPLICIT_NEST)
+
+    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
+        raise toml_suffixed_err(
+            src,
+            pos,
+            f'Cannot mutate immutable namespace {abs_key_parent}',
+        )
+
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    if key_stem in nest:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value')
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, TomlFlags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def toml_parse_key_value_pair(
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, TomlKey, ta.Any]:
+    pos, key = toml_parse_key(src, pos)
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != '=':
+        raise toml_suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
+    pos += 1
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, value = toml_parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
+    pos, key_part = toml_parse_key_part(src, pos)
+    key: TomlKey = (key_part,)
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: ta.Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != '.':
+            return pos, key
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        pos, key_part = toml_parse_key_part(src, pos)
+        key += (key_part,)
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in TOML_BARE_KEY_CHARS:
+        start_pos = pos
+        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return toml_parse_literal_str(src, pos)
+    if char == '"':
+        return toml_parse_one_line_basic_str(src, pos)
+    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
+
+
+def toml_parse_one_line_basic_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1
+    return toml_parse_basic_str(src, pos, multiline=False)
+
+
+def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
+    pos += 1
+    array: list = []
+
+    pos = toml_skip_comments_and_array_ws(src, pos)
+    if src.startswith(']', pos):
+        return pos + 1, array
+    while True:
+        pos, val = toml_parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = toml_skip_comments_and_array_ws(src, pos)
+
+        c = src[pos:pos + 1]
+        if c == ']':
+            return pos + 1, array
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed array')
+        pos += 1
+
+        pos = toml_skip_comments_and_array_ws(src, pos)
+        if src.startswith(']', pos):
+            return pos + 1, array
+
+
+def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
+    pos += 1
+    nested_dict = TomlNestedDict()
+    flags = TomlFlags()
+
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    if src.startswith('}', pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, TomlFlags.FROZEN):
+            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+        if key_stem in nest:
+            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
+        nest[key_stem] = value
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        c = src[pos:pos + 1]
+        if c == '}':
+            return pos + 1, nested_dict.dict
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
+        if isinstance(value, (dict, list)):
+            flags.set(key, TomlFlags.FROZEN, recursive=True)
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_basic_str_escape(
+        src: str,
+        pos: TomlPos,
+        *,
+        multiline: bool = False,
+) -> ta.Tuple[TomlPos, str]:
+    escape_id = src[pos:pos + 2]
+    pos += 2
+    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
+        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
+        # newline.
+        if escape_id != '\\\n':
+            pos = toml_skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ''
+            if char != '\n':
+                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
+            pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ''
+    if escape_id == '\\u':
+        return toml_parse_hex_char(src, pos, 4)
+    if escape_id == '\\U':
+        return toml_parse_hex_char(src, pos, 8)
+    try:
+        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
+
+
+def toml_parse_basic_str_escape_multiline(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    return toml_parse_basic_str_escape(src, pos, multiline=True)
+
+
+def toml_parse_hex_char(src: str, pos: TomlPos, hex_len: int) -> ta.Tuple[TomlPos, str]:
+    hex_str = src[pos:pos + hex_len]
+    if len(hex_str) != hex_len or not TOML_HEXDIGIT_CHARS.issuperset(hex_str):
+        raise toml_suffixed_err(src, pos, 'Invalid hex value')
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not toml_is_unicode_scalar_value(hex_int):
+        raise toml_suffixed_err(src, pos, 'Escaped character is not a Unicode scalar value')
+    return pos, chr(hex_int)
+
+
+def toml_parse_literal_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = toml_skip_until(
+        src, pos, "'", error_on=TOML_ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True,
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
 
-        # Write payload src
-        yield from self._write(struct.pack('<I', len(self._payload_z)))
-        yield from self._write(self._payload_z)
 
-        # Read second ack (after writing src copies)
-        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK1)
+def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
+    pos += 3
+    if src.startswith('\n', pos):
+        pos += 1
 
-        # Write options
-        yield from self._write(struct.pack('<I', len(self._options_json)))
-        yield from self._write(self._options_json)
+    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)
 
-        # Read third ack (after reaping child process)
-        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK2)
+    # 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)
 
-        # Read env info
-        d = yield from self._read(4)
-        env_info_json_len = struct.unpack('<I', d)[0]
-        d = yield from self._read(env_info_json_len)
-        env_info_json = d.decode('utf-8')
-        env_info = PyremoteEnvInfo(**json.loads(env_info_json))
 
-        # Read fourth ack (after finalization completed)
-        yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK3)
+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
 
-        # Return
-        return self.Result(
-            pid=pid,
-            env_info=env_info,
-        )
 
-    def _read(self, sz: int) -> ta.Generator[Read, bytes, bytes]:
-        d = yield self.Read(sz)
-        if not isinstance(d, bytes):
-            raise self.ProtocolError(f'Expected bytes after read, got {d!r}')
-        if len(d) != sz:
-            raise self.ProtocolError(f'Read {len(d)} bytes, expected {sz}')
-        return d
+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
 
-    def _expect(self, e: bytes) -> ta.Generator[Read, bytes, None]:
-        d = yield from self._read(len(e))
-        if d != e:
-            raise self.ProtocolError(f'Read {d!r}, expected {e!r}')
+    # IMPORTANT: order conditions based on speed of checking and likelihood
 
-    def _write(self, d: bytes) -> ta.Generator[Write, ta.Optional[bytes], None]:
-        i = yield self.Write(d)
-        if i is not None:
-            raise self.ProtocolError('Unexpected input after write')
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return toml_parse_multiline_str(src, pos, literal=False)
+        return toml_parse_one_line_basic_str(src, pos)
 
-    #
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return toml_parse_multiline_str(src, pos, literal=True)
+        return toml_parse_literal_str(src, pos)
 
-    def run(self, input: ta.IO, output: ta.IO) -> Result:  # noqa
-        gen = self.gen()
+    # 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
 
-        gi: ta.Optional[bytes] = None
-        while True:
-            try:
-                if gi is not None:
-                    go = gen.send(gi)
-                else:
-                    go = next(gen)
-            except StopIteration as e:
-                return e.value
+    # Arrays
+    if char == '[':
+        return toml_parse_array(src, pos, parse_float)
 
-            if isinstance(go, self.Read):
-                if len(gi := input.read(go.sz)) != go.sz:
-                    raise EOFError
-            elif isinstance(go, self.Write):
-                gi = None
-                output.write(go.d)
-                output.flush()
-            else:
-                raise TypeError(go)
+    # Inline tables
+    if char == '{':
+        return toml_parse_inline_table(src, pos, parse_float)
 
-    async def async_run(
-            self,
-            input: ta.Any,  # asyncio.StreamWriter  # noqa
-            output: ta.Any,  # asyncio.StreamReader
-    ) -> Result:
-        gen = self.gen()
+    # 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)
 
-        gi: ta.Optional[bytes] = None
-        while True:
-            try:
-                if gi is not None:
-                    go = gen.send(gi)
-                else:
-                    go = next(gen)
-            except StopIteration as e:
-                return e.value
+    # 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)
 
-            if isinstance(go, self.Read):
-                if len(gi := await input.read(go.sz)) != go.sz:
-                    raise EOFError
-            elif isinstance(go, self.Write):
-                gi = None
-                output.write(go.d)
-                await output.drain()
-            else:
-                raise TypeError(go)
+    # 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/asyncs/asyncio/channels.py
 
+def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
+    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
 
-class AsyncioBytesChannelTransport(asyncio.Transport):
-    def __init__(self, reader: asyncio.StreamReader) -> None:
-        super().__init__()
+    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}'
 
-        self.reader = reader
-        self.closed: asyncio.Future = asyncio.Future()
+    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
 
-    # @ta.override
-    def write(self, data: bytes) -> None:
-        self.reader.feed_data(data)
 
-    # @ta.override
-    def close(self) -> None:
-        self.reader.feed_eof()
-        if not self.closed.done():
-            self.closed.set_result(True)
+def toml_is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
 
-    # @ta.override
-    def is_closing(self) -> bool:
-        return self.closed.done()
 
+def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
+    """A decorator to make `parse_float` safe.
 
-def asyncio_create_bytes_channel(
-        loop: ta.Any = None,
-) -> ta.Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
-    if loop is None:
-        loop = asyncio.get_running_loop()
+    `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
 
-    reader = asyncio.StreamReader()
-    protocol = asyncio.StreamReaderProtocol(reader)
-    transport = AsyncioBytesChannelTransport(reader)
-    writer = asyncio.StreamWriter(transport, protocol, reader, loop)
+    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 reader, writer
+    return safe_parse_float
 
 
 ########################################
-# ../../../omlish/asyncs/asyncio/streams.py
+# ../../../omlish/formats/toml/writer.py
 
 
-ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+class TomlWriter:
+    @dc.dataclass(frozen=True)
+    class Literal:
+        s: str
 
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+        self._out = out
 
-async def asyncio_open_stream_reader(
-        f: ta.IO,
-        loop: ta.Any = None,
-        *,
-        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
-) -> asyncio.StreamReader:
-    if loop is None:
-        loop = asyncio.get_running_loop()
+        self._indent = 0
+        self._wrote_indent = False
 
-    reader = asyncio.StreamReader(limit=limit, loop=loop)
-    await loop.connect_read_pipe(
-        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
-        f,
-    )
+    #
 
-    return reader
+    def _w(self, s: str) -> None:
+        if not self._wrote_indent:
+            self._out.write('    ' * self._indent)
+            self._wrote_indent = True
+        self._out.write(s)
 
+    def _nl(self) -> None:
+        self._out.write('\n')
+        self._wrote_indent = False
 
-async def asyncio_open_stream_writer(
-        f: ta.IO,
-        loop: ta.Any = None,
-) -> asyncio.StreamWriter:
-    if loop is None:
-        loop = asyncio.get_running_loop()
+    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
+        )
 
-    writer_transport, writer_protocol = await loop.connect_write_pipe(
-        lambda: asyncio.streams.FlowControlMixin(loop=loop),
-        f,
-    )
+    def _maybe_quote(self, s: str) -> str:
+        if self._needs_quote(s):
+            return repr(s)
+        else:
+            return s
 
-    return asyncio.streams.StreamWriter(
-        writer_transport,
-        writer_protocol,
-        None,
-        loop,
-    )
+    #
 
+    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)
 
-########################################
-# ../../../omlish/asyncs/asyncio/timeouts.py
+    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 asyncio_maybe_timeout(
-        fut: AwaitableT,
-        timeout: ta.Optional[float] = None,
-) -> AwaitableT:
-    if timeout is not None:
-        fut = asyncio.wait_for(fut, timeout)  # type: ignore
-    return fut
+    @classmethod
+    def write_str(cls, obj: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out).write_value(obj)
+        return out.getvalue()
 
 
 ########################################
@@ -4672,131 +4849,360 @@ class ArgparseCli:
                 elif k in objs:
                     del [k]
 
-        #
+        #
+
+        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
+            **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
+            **ns.get('__annotations__', {}),
+        }), globalns=ns.get('__globals__', {}))
+
+        #
+
+        if '_parser' in ns:
+            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
+        else:
+            parser = argparse.ArgumentParser()
+            setattr(cls, '_parser', parser)
+
+        #
+
+        subparsers = parser.add_subparsers()
+
+        for att, obj in objs.items():
+            if isinstance(obj, ArgparseCmd):
+                if obj.parent is not None:
+                    raise NotImplementedError
+
+                for cn in [obj.name, *(obj.aliases or [])]:
+                    subparser = subparsers.add_parser(cn)
+
+                    for arg in (obj.args or []):
+                        if (
+                                len(arg.args) == 1 and
+                                isinstance(arg.args[0], str) and
+                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
+                                'metavar' not in arg.kwargs
+                        ):
+                            subparser.add_argument(
+                                n.replace('-', '_'),
+                                **arg.kwargs,
+                                metavar=n,
+                            )
+                        else:
+                            subparser.add_argument(*arg.args, **arg.kwargs)
+
+                    subparser.set_defaults(_cmd=obj)
+
+            elif isinstance(obj, ArgparseArg):
+                if att in anns:
+                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
+                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
+
+                if not obj.dest:
+                    if 'dest' in obj.kwargs:
+                        obj.dest = obj.kwargs['dest']
+                    else:
+                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+
+                parser.add_argument(*obj.args, **obj.kwargs)
+
+            else:
+                raise TypeError(obj)
+
+    #
+
+    _parser: ta.ClassVar[argparse.ArgumentParser]
+
+    @classmethod
+    def get_parser(cls) -> argparse.ArgumentParser:
+        return cls._parser
+
+    @property
+    def argv(self) -> ta.Sequence[str]:
+        return self._argv
+
+    @property
+    def args(self) -> argparse.Namespace:
+        return self._args
+
+    @property
+    def unknown_args(self) -> ta.Sequence[str]:
+        return self._unknown_args
+
+    #
+
+    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
+        return cmd.__get__(self, type(self))
+
+    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
+        cmd = getattr(self.args, '_cmd', None)
+
+        if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
+            msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
+            if (parser := self.get_parser()).exit_on_error:  # type: ignore
+                parser.error(msg)
+            else:
+                raise argparse.ArgumentError(None, msg)
+
+        if cmd is None:
+            self.get_parser().print_help()
+            return None
+
+        return self._bind_cli_cmd(cmd)
+
+    #
+
+    def cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        return fn()
+
+    def cli_run_and_exit(self) -> ta.NoReturn:
+        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+
+    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
+        if exit:
+            return self.cli_run_and_exit()
+        else:
+            return self.cli_run()
+
+    #
+
+    async def async_cli_run(self) -> ta.Optional[int]:
+        if (fn := self.prepare_cli_run()) is None:
+            return 0
+
+        return await fn()
+
+
+########################################
+# ../../../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)
+
+
+##
+
 
-        anns = ta.get_type_hints(_ArgparseCliAnnotationBox({
-            **{k: v for bcls in reversed(mro) for k, v in getattr(bcls, '__annotations__', {}).items()},
-            **ns.get('__annotations__', {}),
-        }), globalns=ns.get('__globals__', {}))
+@dc.dataclass(frozen=True)
+class YamlConfigData(ObjConfigData):
+    pass
 
-        #
 
-        if '_parser' in ns:
-            parser = check.isinstance(ns['_parser'], argparse.ArgumentParser)
-        else:
-            parser = argparse.ArgumentParser()
-            setattr(cls, '_parser', parser)
+class YamlConfigLoader(ConfigLoader[YamlConfigData]):
+    file_exts = ('yaml', 'yml')
 
-        #
+    def load_str(self, s: str) -> YamlConfigData:
+        return YamlConfigData(__import__('yaml').safe_load(s))
 
-        subparsers = parser.add_subparsers()
 
-        for att, obj in objs.items():
-            if isinstance(obj, ArgparseCmd):
-                if obj.parent is not None:
-                    raise NotImplementedError
+class YamlConfigRenderer(ConfigRenderer[YamlConfigData]):
+    data_cls = YamlConfigData
 
-                for cn in [obj.name, *(obj.aliases or [])]:
-                    subparser = subparsers.add_parser(cn)
+    def render(self, d: YamlConfigData) -> str:
+        return __import__('yaml').safe_dump(d.obj)
 
-                    for arg in (obj.args or []):
-                        if (
-                                len(arg.args) == 1 and
-                                isinstance(arg.args[0], str) and
-                                not (n := check.isinstance(arg.args[0], str)).startswith('-') and
-                                'metavar' not in arg.kwargs
-                        ):
-                            subparser.add_argument(
-                                n.replace('-', '_'),
-                                **arg.kwargs,
-                                metavar=n,
-                            )
-                        else:
-                            subparser.add_argument(*arg.args, **arg.kwargs)
 
-                    subparser.set_defaults(_cmd=obj)
+##
 
-            elif isinstance(obj, ArgparseArg):
-                if att in anns:
-                    ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
-                    obj.kwargs = {**ann_kwargs, **obj.kwargs}
 
-                if not obj.dest:
-                    if 'dest' in obj.kwargs:
-                        obj.dest = obj.kwargs['dest']
-                    else:
-                        obj.dest = obj.kwargs['dest'] = att  # type: ignore
+@dc.dataclass(frozen=True)
+class IniConfigData(ConfigData):
+    sections: IniSectionSettingsMap
 
-                parser.add_argument(*obj.args, **obj.kwargs)
+    def as_map(self) -> ConfigMap:
+        return self.sections
 
-            else:
-                raise TypeError(obj)
 
-    #
+class IniConfigLoader(ConfigLoader[IniConfigData]):
+    file_exts = ('ini',)
 
-    _parser: ta.ClassVar[argparse.ArgumentParser]
+    def load_str(self, s: str) -> IniConfigData:
+        cp = configparser.ConfigParser()
+        cp.read_string(s)
+        return IniConfigData(extract_ini_sections(cp))
 
-    @classmethod
-    def get_parser(cls) -> argparse.ArgumentParser:
-        return cls._parser
 
-    @property
-    def argv(self) -> ta.Sequence[str]:
-        return self._argv
+class IniConfigRenderer(ConfigRenderer[IniConfigData]):
+    data_cls = IniConfigData
 
-    @property
-    def args(self) -> argparse.Namespace:
-        return self._args
+    def render(self, d: IniConfigData) -> str:
+        return render_ini_sections(d.sections)
 
-    @property
-    def unknown_args(self) -> ta.Sequence[str]:
-        return self._unknown_args
 
-    #
+##
 
-    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
-        return cmd.__get__(self, type(self))
 
-    def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
-        cmd = getattr(self.args, '_cmd', None)
+@dc.dataclass(frozen=True)
+class SwitchedConfigFileLoader:
+    loaders: ta.Sequence[ConfigLoader]
+    default: ta.Optional[ConfigLoader] = None
 
-        if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
-            msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
-            if (parser := self.get_parser()).exit_on_error:  # type: ignore
-                parser.error(msg)
-            else:
-                raise argparse.ArgumentError(None, msg)
+    def load_file(self, p: str) -> ConfigData:
+        n = os.path.basename(p)
 
-        if cmd is None:
-            self.get_parser().print_help()
-            return None
+        for l in self.loaders:
+            if l.match_file(n):
+                return l.load_file(p)
 
-        return self._bind_cli_cmd(cmd)
+        if (d := self.default) is not None:
+            return d.load_file(p)
 
-    #
+        raise NameError(n)
 
-    def cli_run(self) -> ta.Optional[int]:
-        if (fn := self.prepare_cli_run()) is None:
-            return 0
 
-        return fn()
+DEFAULT_CONFIG_LOADERS: ta.Sequence[ConfigLoader] = [
+    JsonConfigLoader(),
+    TomlConfigLoader(),
+    YamlConfigLoader(),
+    IniConfigLoader(),
+]
 
-    def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+DEFAULT_CONFIG_LOADER: ConfigLoader = JsonConfigLoader()
 
-    def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
-        if exit:
-            return self.cli_run_and_exit()
-        else:
-            return self.cli_run()
+DEFAULT_CONFIG_FILE_LOADER = SwitchedConfigFileLoader(
+    loaders=DEFAULT_CONFIG_LOADERS,
+    default=DEFAULT_CONFIG_LOADER,
+)
 
-    #
 
-    async def async_cli_run(self) -> ta.Optional[int]:
-        if (fn := self.prepare_cli_run()) is None:
-            return 0
+##
 
-        return await fn()
+
+@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(),
+]
+
+DEFAULT_CONFIG_RENDERER = SwitchedConfigRenderer(DEFAULT_CONFIG_RENDERERS)
 
 
 ########################################
@@ -6895,121 +7301,6 @@ def bind_interp_uv() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
-########################################
-# ../../configs.py
-
-
-##
-
-
-def parse_config_file(
-        name: str,
-        f: ta.TextIO,
-) -> ConfigMapping:
-    if name.endswith('.toml'):
-        return toml_loads(f.read())
-
-    elif any(name.endswith(e) for e in ('.yml', '.yaml')):
-        yaml = __import__('yaml')
-        return yaml.safe_load(f)
-
-    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
-
-    else:
-        return json.loads(f.read())
-
-
-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)
-
-    if prepare is not None:
-        config_dct = prepare(config_dct)
-
-    return msh.unmarshal_obj(config_dct, cls)
-
-
-##
-
-
-def build_config_named_children(
-        o: ta.Union[
-            ta.Sequence[ConfigMapping],
-            ta.Mapping[str, ConfigMapping],
-            None,
-        ],
-        *,
-        name_key: str = 'name',
-) -> ta.Optional[ta.Sequence[ConfigMapping]]:
-    if o is None:
-        return None
-
-    lst: ta.List[ConfigMapping] = []
-    if isinstance(o, ta.Mapping):
-        for k, v in o.items():
-            check.isinstance(v, ta.Mapping)
-            if name_key in v:
-                n = v[name_key]
-                if k != n:
-                    raise KeyError(f'Given names do not match: {n} != {k}')
-                lst.append(v)
-            else:
-                lst.append({name_key: k, **v})
-
-    else:
-        check.not_isinstance(o, str)
-        lst.extend(o)
-
-    seen = set()
-    for d in lst:
-        n = d['name']
-        if n in d:
-            raise KeyError(f'Duplicate name: {n}')
-        seen.add(n)
-
-    return lst
-
-
-##
-
-
-def render_ini_config(
-        settings_by_section: IniConfigSectionSettingsMap,
-) -> str:
-    out = io.StringIO()
-
-    for i, (section, settings) in enumerate(settings_by_section.items()):
-        if i:
-            out.write('\n')
-
-        out.write(f'[{section}]\n')
-
-        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()
-
-
 ########################################
 # ../commands/marshal.py
 
@@ -7060,7 +7351,105 @@ class PingCommandExecutor(CommandExecutor[PingCommand, PingCommand.Output]):
 # ../commands/types.py
 
 
-CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
+CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
+
+
+########################################
+# ../deploy/conf/specs.py
+
+
+##
+
+
+class DeployAppConfContent(abc.ABC):  # noqa
+    pass
+
+
+#
+
+
+@register_single_field_type_obj_marshaler('body')
+@dc.dataclass(frozen=True)
+class RawDeployAppConfContent(DeployAppConfContent):
+    body: str
+
+
+#
+
+
+@register_single_field_type_obj_marshaler('obj')
+@dc.dataclass(frozen=True)
+class JsonDeployAppConfContent(DeployAppConfContent):
+    obj: ta.Any
+
+
+#
+
+
+@register_single_field_type_obj_marshaler('sections')
+@dc.dataclass(frozen=True)
+class IniDeployAppConfContent(DeployAppConfContent):
+    sections: IniSectionSettingsMap
+
+
+#
+
+
+@register_single_field_type_obj_marshaler('items')
+@dc.dataclass(frozen=True)
+class NginxDeployAppConfContent(DeployAppConfContent):
+    items: ta.Any
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployAppConfFile:
+    path: str
+    content: DeployAppConfContent
+
+    def __post_init__(self) -> None:
+        check_valid_deploy_spec_path(self.path)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployAppConfLink:  # noqa
+    """
+    May be either:
+     - @conf(.ext)* - links a single file in root of app conf dir to conf/@conf/@dst(.ext)*
+     - @conf/file - links a single file in a single subdir to conf/@conf/@dst--file
+     - @conf/ - links a directory in root of app conf dir to conf/@conf/@dst/
+    """
+
+    src: str
+
+    kind: ta.Literal['current_only', 'all_active'] = 'current_only'
+
+    def __post_init__(self) -> None:
+        check_valid_deploy_spec_path(self.src)
+        if '/' in self.src:
+            check.equal(self.src.count('/'), 1)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployAppConfSpec:
+    files: ta.Optional[ta.Sequence[DeployAppConfFile]] = None
+
+    links: ta.Optional[ta.Sequence[DeployAppConfLink]] = None
+
+    def __post_init__(self) -> None:
+        if self.files:
+            seen: ta.Set[str] = set()
+            for f in self.files:
+                check.not_in(f.path, seen)
+                seen.add(f.path)
 
 
 ########################################
@@ -7388,6 +7777,106 @@ class SystemConfig:
     platform: ta.Optional[Platform] = None
 
 
+########################################
+# ../../../omlish/configs/nginx.py
+"""
+See:
+ - https://nginx.org/en/docs/dev/development_guide.html
+ - https://nginx.org/en/docs/dev/development_guide.html#config_directives
+ - https://nginx.org/en/docs/example.html
+"""
+
+
+@dc.dataclass()
+class NginxConfigItems:
+    lst: ta.List['NginxConfigItem']
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItems':
+        if isinstance(obj, NginxConfigItems):
+            return obj
+        return cls([NginxConfigItem.of(e) for e in check.isinstance(obj, list)])
+
+
+@dc.dataclass()
+class NginxConfigItem:
+    name: str
+    args: ta.Optional[ta.List[str]] = None
+    block: ta.Optional[NginxConfigItems] = None
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItem':
+        if isinstance(obj, NginxConfigItem):
+            return obj
+        args = check.isinstance(check.not_isinstance(obj, str), collections.abc.Sequence)
+        name, args = check.isinstance(args[0], str), args[1:]
+        if args and not isinstance(args[-1], str):
+            block, args = NginxConfigItems.of(args[-1]), args[:-1]
+        else:
+            block = None
+        return NginxConfigItem(name, [check.isinstance(e, str) for e in args], block=block)
+
+
+def render_nginx_config(wr: IndentWriter, obj: ta.Any) -> None:
+    if isinstance(obj, NginxConfigItem):
+        wr.write(obj.name)
+        for e in obj.args or ():
+            wr.write(' ')
+            wr.write(e)
+        if obj.block:
+            wr.write(' {\n')
+            with wr.indent():
+                render_nginx_config(wr, obj.block)
+            wr.write('}\n')
+        else:
+            wr.write(';\n')
+
+    elif isinstance(obj, NginxConfigItems):
+        for e2 in obj.lst:
+            render_nginx_config(wr, e2)
+
+    else:
+        raise TypeError(obj)
+
+
+def render_nginx_config_str(obj: ta.Any) -> str:
+    iw = IndentWriter()
+    render_nginx_config(iw, obj)
+    return iw.getvalue()
+
+
+########################################
+# ../../../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
 """
@@ -7838,78 +8327,6 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return ret.decode().strip()
 
 
-########################################
-# ../../../omserv/nginx/configs.py
-"""
-TODO:
- - omnibus/jmespath
-
-https://nginx.org/en/docs/dev/development_guide.html
-https://nginx.org/en/docs/dev/development_guide.html#config_directives
-https://nginx.org/en/docs/example.html
-
-https://github.com/yandex/gixy
-"""
-
-
-@dc.dataclass()
-class NginxConfigItems:
-    lst: ta.List['NginxConfigItem']
-
-    @classmethod
-    def of(cls, obj: ta.Any) -> 'NginxConfigItems':
-        if isinstance(obj, NginxConfigItems):
-            return obj
-        return cls([NginxConfigItem.of(e) for e in check.isinstance(obj, list)])
-
-
-@dc.dataclass()
-class NginxConfigItem:
-    name: str
-    args: ta.Optional[ta.List[str]] = None
-    block: ta.Optional[NginxConfigItems] = None
-
-    @classmethod
-    def of(cls, obj: ta.Any) -> 'NginxConfigItem':
-        if isinstance(obj, NginxConfigItem):
-            return obj
-        args = check.isinstance(check.not_isinstance(obj, str), collections.abc.Sequence)
-        name, args = check.isinstance(args[0], str), args[1:]
-        if args and not isinstance(args[-1], str):
-            block, args = NginxConfigItems.of(args[-1]), args[:-1]
-        else:
-            block = None
-        return NginxConfigItem(name, [check.isinstance(e, str) for e in args], block=block)
-
-
-def render_nginx_config(wr: IndentWriter, obj: ta.Any) -> None:
-    if isinstance(obj, NginxConfigItem):
-        wr.write(obj.name)
-        for e in obj.args or ():
-            wr.write(' ')
-            wr.write(e)
-        if obj.block:
-            wr.write(' {\n')
-            with wr.indent():
-                render_nginx_config(wr, obj.block)
-            wr.write('}\n')
-        else:
-            wr.write(';\n')
-
-    elif isinstance(obj, NginxConfigItems):
-        for e2 in obj.lst:
-            render_nginx_config(wr, e2)
-
-    else:
-        raise TypeError(obj)
-
-
-def render_nginx_config_str(obj: ta.Any) -> str:
-    iw = IndentWriter()
-    render_nginx_config(iw, obj)
-    return iw.getvalue()
-
-
 ########################################
 # ../../../omdev/interp/providers/base.py
 """
@@ -7977,113 +8394,15 @@ class LocalCommandExecutor(CommandExecutor):
     def __init__(
             self,
             *,
-            command_executors: CommandExecutorMap,
-    ) -> None:
-        super().__init__()
-
-        self._command_executors = command_executors
-
-    async def execute(self, cmd: Command) -> Command.Output:
-        ce: CommandExecutor = self._command_executors[type(cmd)]
-        return await ce.execute(cmd)
-
-
-########################################
-# ../deploy/conf/specs.py
-
-
-##
-
-
-class DeployAppConfContent(abc.ABC):  # noqa
-    pass
-
-
-#
-
-
-@register_single_field_type_obj_marshaler('body')
-@dc.dataclass(frozen=True)
-class RawDeployAppConfContent(DeployAppConfContent):
-    body: str
-
-
-#
-
-
-@register_single_field_type_obj_marshaler('obj')
-@dc.dataclass(frozen=True)
-class JsonDeployAppConfContent(DeployAppConfContent):
-    obj: ta.Any
-
-
-#
-
-
-@register_single_field_type_obj_marshaler('sections')
-@dc.dataclass(frozen=True)
-class IniDeployAppConfContent(DeployAppConfContent):
-    sections: IniConfigSectionSettingsMap
-
-
-#
-
-
-@register_single_field_type_obj_marshaler('items')
-@dc.dataclass(frozen=True)
-class NginxDeployAppConfContent(DeployAppConfContent):
-    items: ta.Any
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployAppConfFile:
-    path: str
-    content: DeployAppConfContent
-
-    def __post_init__(self) -> None:
-        check_valid_deploy_spec_path(self.path)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployAppConfLink:  # noqa
-    """
-    May be either:
-     - @conf(.ext)* - links a single file in root of app conf dir to conf/@conf/@dst(.ext)*
-     - @conf/file - links a single file in a single subdir to conf/@conf/@dst--file
-     - @conf/ - links a directory in root of app conf dir to conf/@conf/@dst/
-    """
-
-    src: str
-
-    kind: ta.Literal['current_only', 'all_active'] = 'current_only'
-
-    def __post_init__(self) -> None:
-        check_valid_deploy_spec_path(self.src)
-        if '/' in self.src:
-            check.equal(self.src.count('/'), 1)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployAppConfSpec:
-    files: ta.Optional[ta.Sequence[DeployAppConfFile]] = None
+            command_executors: CommandExecutorMap,
+    ) -> None:
+        super().__init__()
 
-    links: ta.Optional[ta.Sequence[DeployAppConfLink]] = None
+        self._command_executors = command_executors
 
-    def __post_init__(self) -> None:
-        if self.files:
-            seen: ta.Set[str] = set()
-            for f in self.files:
-                check.not_in(f.path, seen)
-                seen.add(f.path)
+    async def execute(self, cmd: Command) -> Command.Output:
+        ce: CommandExecutor = self._command_executors[type(cmd)]
+        return await ce.execute(cmd)
 
 
 ########################################
@@ -8288,6 +8607,127 @@ class DeployPath(DeployPathRenderable):
         return cls(tuple(DeployPathPart.parse(p) for p in ps))
 
 
+########################################
+# ../deploy/specs.py
+
+
+##
+
+
+class DeploySpecKeyed(ta.Generic[KeyDeployTagT]):
+    @cached_nullary
+    def _key_str(self) -> str:
+        return hashlib.sha256(repr(self).encode('utf-8')).hexdigest()[:8]
+
+    @abc.abstractmethod
+    def key(self) -> KeyDeployTagT:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployGitRepo:
+    host: ta.Optional[str] = None
+    username: ta.Optional[str] = None
+    path: ta.Optional[str] = None
+
+    def __post_init__(self) -> None:
+        check.not_in('..', check.non_empty_str(self.host))
+        check.not_in('.', check.non_empty_str(self.path))
+
+
+@dc.dataclass(frozen=True)
+class DeployGitSpec:
+    repo: DeployGitRepo
+    rev: DeployRev
+
+    subtrees: ta.Optional[ta.Sequence[str]] = None
+
+    def __post_init__(self) -> None:
+        check.non_empty_str(self.rev)
+        if self.subtrees is not None:
+            for st in self.subtrees:
+                check.non_empty_str(st)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployVenvSpec:
+    interp: ta.Optional[str] = None
+
+    requirements_files: ta.Optional[ta.Sequence[str]] = None
+    extra_dependencies: ta.Optional[ta.Sequence[str]] = None
+
+    use_uv: bool = False
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
+    app: DeployApp
+
+    git: DeployGitSpec
+
+    venv: ta.Optional[DeployVenvSpec] = None
+
+    conf: ta.Optional[DeployAppConfSpec] = None
+
+    # @ta.override
+    def key(self) -> DeployAppKey:
+        return DeployAppKey(self._key_str())
+
+
+@dc.dataclass(frozen=True)
+class DeployAppLinksSpec:
+    apps: ta.Sequence[DeployApp] = ()
+
+    removed_apps: ta.Sequence[DeployApp] = ()
+
+    exclude_unspecified: bool = False
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeploySystemdSpec:
+    # ~/.config/systemd/user/
+    unit_dir: ta.Optional[str] = None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeploySpec(DeploySpecKeyed[DeployKey]):
+    home: DeployHome
+
+    apps: ta.Sequence[DeployAppSpec] = ()
+
+    app_links: DeployAppLinksSpec = DeployAppLinksSpec()
+
+    systemd: ta.Optional[DeploySystemdSpec] = None
+
+    def __post_init__(self) -> None:
+        check.non_empty_str(self.home)
+
+        seen: ta.Set[DeployApp] = set()
+        for a in self.apps:
+            if a.app in seen:
+                raise KeyError(a.app)
+            seen.add(a.app)
+
+    # @ta.override
+    def key(self) -> DeployKey:
+        return DeployKey(self._key_str())
+
+
 ########################################
 # ../remote/execution.py
 """
@@ -9320,7 +9760,7 @@ class DeployConfManager:
 
         elif isinstance(ac, IniDeployAppConfContent):
             ini_sections = pcc(ac.sections)
-            return strip_with_newline(render_ini_config(ini_sections))
+            return strip_with_newline(render_ini_sections(ini_sections))
 
         elif isinstance(ac, NginxDeployAppConfContent):
             nginx_items = NginxConfigItems.of(pcc(ac.items))
@@ -9534,127 +9974,6 @@ class SingleDirDeployPathOwner(DeployPathOwner, abc.ABC):
         return self._owned_deploy_paths
 
 
-########################################
-# ../deploy/specs.py
-
-
-##
-
-
-class DeploySpecKeyed(ta.Generic[KeyDeployTagT]):
-    @cached_nullary
-    def _key_str(self) -> str:
-        return hashlib.sha256(repr(self).encode('utf-8')).hexdigest()[:8]
-
-    @abc.abstractmethod
-    def key(self) -> KeyDeployTagT:
-        raise NotImplementedError
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployGitRepo:
-    host: ta.Optional[str] = None
-    username: ta.Optional[str] = None
-    path: ta.Optional[str] = None
-
-    def __post_init__(self) -> None:
-        check.not_in('..', check.non_empty_str(self.host))
-        check.not_in('.', check.non_empty_str(self.path))
-
-
-@dc.dataclass(frozen=True)
-class DeployGitSpec:
-    repo: DeployGitRepo
-    rev: DeployRev
-
-    subtrees: ta.Optional[ta.Sequence[str]] = None
-
-    def __post_init__(self) -> None:
-        check.non_empty_str(self.rev)
-        if self.subtrees is not None:
-            for st in self.subtrees:
-                check.non_empty_str(st)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployVenvSpec:
-    interp: ta.Optional[str] = None
-
-    requirements_files: ta.Optional[ta.Sequence[str]] = None
-    extra_dependencies: ta.Optional[ta.Sequence[str]] = None
-
-    use_uv: bool = False
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
-    app: DeployApp
-
-    git: DeployGitSpec
-
-    venv: ta.Optional[DeployVenvSpec] = None
-
-    conf: ta.Optional[DeployAppConfSpec] = None
-
-    # @ta.override
-    def key(self) -> DeployAppKey:
-        return DeployAppKey(self._key_str())
-
-
-@dc.dataclass(frozen=True)
-class DeployAppLinksSpec:
-    apps: ta.Sequence[DeployApp] = ()
-
-    removed_apps: ta.Sequence[DeployApp] = ()
-
-    exclude_unspecified: bool = False
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeploySystemdSpec:
-    # ~/.config/systemd/user/
-    unit_dir: ta.Optional[str] = None
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeploySpec(DeploySpecKeyed[DeployKey]):
-    home: DeployHome
-
-    apps: ta.Sequence[DeployAppSpec] = ()
-
-    app_links: DeployAppLinksSpec = DeployAppLinksSpec()
-
-    systemd: ta.Optional[DeploySystemdSpec] = None
-
-    def __post_init__(self) -> None:
-        check.non_empty_str(self.home)
-
-        seen: ta.Set[DeployApp] = set()
-        for a in self.apps:
-            if a.app in seen:
-                raise KeyError(a.app)
-            seen.add(a.app)
-
-    # @ta.override
-    def key(self) -> DeployKey:
-        return DeployKey(self._key_str())
-
-
 ########################################
 # ../remote/_main.py
 
@@ -12294,7 +12613,7 @@ class MainCli(ArgparseCli):
         if cf is None:
             return ManageConfig()
         else:
-            return read_config_file(cf, ManageConfig)
+            return load_config_file_obj(cf, ManageConfig)
 
     #
 
@@ -12365,7 +12684,7 @@ class MainCli(ArgparseCli):
             cmds.append(cmd)
 
         for cf in self.args.command_file or []:
-            cmd = read_config_file(cf, Command, msh=msh)
+            cmd = load_config_file_obj(cf, Command, msh=msh)
             cmds.append(cmd)
 
         #