ominfra 0.0.0.dev156__py3-none-any.whl → 0.0.0.dev158__py3-none-any.whl

ominfra/scripts/manage.py

@@ -37,6 +37,7 @@ import shlex
 import shutil
 import signal
 import site
+import string
 import struct
 import subprocess
 import sys
@@ -68,6 +69,11 @@ 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
+
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
@@ -94,7 +100,7 @@ CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 
 # deploy/paths.py
 DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
-DeployPathSpec = ta.Literal['app', 'tag']  # ta.TypeAlias
+DeployPathPlaceholder = ta.Literal['app', 'tag']  # ta.TypeAlias
 
 # ../../omlish/argparse/cli.py
 ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
@@ -109,7 +115,10 @@ InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
 InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
-# ../../omlish/lite/subprocesses.py
+# ../configs.py
+ConfigMapping = ta.Mapping[str, ta.Any]
+
+# ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
 # system/packages.py
@@ -523,6 +532,824 @@ def canonicalize_version(
     return ''.join(parts)
 
 
+########################################
+# ../../../omdev/toml/parser.py
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+#
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; All
+# Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+#
+# https://github.com/python/cpython/blob/9ce90206b7a4649600218cf0bd4826db79c9a312/Lib/tomllib/_parser.py
+
+
+##
+
+
+_TOML_TIME_RE_STR = r'([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?'
+
+TOML_RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+TOML_RE_LOCALTIME = re.compile(_TOML_TIME_RE_STR)
+TOML_RE_DATETIME = re.compile(
+    rf"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TOML_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def toml_match_to_datetime(match: re.Match) -> ta.Union[datetime.datetime, datetime.date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return datetime.date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    if offset_sign_str:
+        tz: ta.Optional[datetime.tzinfo] = toml_cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str,
+        )
+    elif zulu_time:
+        tz = datetime.UTC
+    else:  # local date-time
+        tz = None
+    return datetime.datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+@functools.lru_cache()  # noqa
+def toml_cached_tz(hour_str: str, minute_str: str, sign_str: str) -> datetime.timezone:
+    sign = 1 if sign_str == '+' else -1
+    return datetime.timezone(
+        datetime.timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        ),
+    )
+
+
+def toml_match_to_localtime(match: re.Match) -> datetime.time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
+
+
+def toml_match_to_number(match: re.Match, parse_float: TomlParseFloat) -> ta.Any:
+    if match.group('floatpart'):
+        return parse_float(match.group())
+    return int(match.group(), 0)
+
+
+TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are currently handled as separate cases in the parser
+# functions.
+TOML_ILLEGAL_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t')
+TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t\n')
+
+TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+
+TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS = frozenset(' \t')
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset('\n')
+TOML_BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + '-_')
+TOML_KEY_INITIAL_CHARS = TOML_BARE_KEY_CHARS | frozenset("\"'")
+TOML_HEXDIGIT_CHARS = frozenset(string.hexdigits)
+
+TOML_BASIC_STR_ESCAPE_REPLACEMENTS = types.MappingProxyType(
+    {
+        '\\b': '\u0008',  # backspace
+        '\\t': '\u0009',  # tab
+        '\\n': '\u000A',  # linefeed
+        '\\f': '\u000C',  # form feed
+        '\\r': '\u000D',  # carriage return
+        '\\"': '\u0022',  # quote
+        '\\\\': '\u005C',  # backslash
+    },
+)
+
+
+class TomlDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
+
+
+def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
+    """Parse TOML from a binary file object."""
+    b = fp.read()
+    try:
+        s = b.decode()
+    except AttributeError:
+        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
+    return toml_loads(s, parse_float=parse_float)
+
+
+def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string literals. Let's do so to simplify parsing.
+    try:
+        src = s.replace('\r\n', '\n')
+    except (AttributeError, TypeError):
+        raise TypeError(f"Expected str object, not '{type(s).__qualname__}'") from None
+    pos = 0
+    out = TomlOutput(TomlNestedDict(), TomlFlags())
+    header: TomlKey = ()
+    parse_float = toml_make_safe_parse_float(parse_float)
+
+    # Parse one statement at a time (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == '\n':
+            pos += 1
+            continue
+        if char in TOML_KEY_INITIAL_CHARS:
+            pos = toml_key_value_rule(src, pos, out, header, parse_float)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char == '[':
+            try:
+                second_char: ta.Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            out.flags.finalize_pending()
+            if second_char == '[':
+                pos, header = toml_create_list_rule(src, pos, out)
+            else:
+                pos, header = toml_create_dict_rule(src, pos, out)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char != '#':
+            raise toml_suffixed_err(src, pos, 'Invalid statement')
+
+        # 3. Skip comment
+        pos = toml_skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != '\n':
+            raise toml_suffixed_err(
+                src, pos, 'Expected newline or end of document after a statement',
+            )
+        pos += 1
+
+    return out.data.dict
+
+
+class TomlFlags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
+
+    def __init__(self) -> None:
+        self._flags: ta.Dict[str, dict] = {}
+        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
+
+    def add_pending(self, key: TomlKey, flag: int) -> None:
+        self._pending_flags.add((key, flag))
+
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
+
+    def unset_all(self, key: TomlKey) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]['nested']
+        cont.pop(key[-1], None)
+
+    def set(self, key: TomlKey, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+            cont = cont[k]['nested']
+        if key_stem not in cont:
+            cont[key_stem] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+        cont[key_stem]['recursive_flags' if recursive else 'flags'].add(flag)
+
+    def is_(self, key: TomlKey, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont['recursive_flags']:
+                return True
+            cont = inner_cont['nested']
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont['flags'] or flag in cont['recursive_flags']
+        return False
+
+
+class TomlNestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: ta.Dict[str, ta.Any] = {}
+
+    def get_or_create_nest(
+            self,
+            key: TomlKey,
+            *,
+            access_lists: bool = True,
+    ) -> dict:
+        cont: ta.Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError('There is no nest behind this key')
+        return cont
+
+    def append_nest_to_list(self, key: TomlKey) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            if not isinstance(list_, list):
+                raise KeyError('An object other than list found behind this key')
+            list_.append({})
+        else:
+            cont[last_key] = [{}]
+
+
+class TomlOutput(ta.NamedTuple):
+    data: TomlNestedDict
+    flags: TomlFlags
+
+
+def toml_skip_chars(src: str, pos: TomlPos, chars: ta.Iterable[str]) -> TomlPos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def toml_skip_until(
+        src: str,
+        pos: TomlPos,
+        expect: str,
+        *,
+        error_on: ta.FrozenSet[str],
+        error_on_eof: bool,
+) -> TomlPos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise toml_suffixed_err(src, new_pos, f'Expected {expect!r}') from None
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise toml_suffixed_err(src, pos, f'Found invalid character {src[pos]!r}')
+    return new_pos
+
+
+def toml_skip_comment(src: str, pos: TomlPos) -> TomlPos:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == '#':
+        return toml_skip_until(
+            src, pos + 1, '\n', error_on=TOML_ILLEGAL_COMMENT_CHARS, error_on_eof=False,
+        )
+    return pos
+
+
+def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
+    while True:
+        pos_before_skip = pos
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = toml_skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 1  # Skip "["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.EXPLICIT_NEST) or out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot declare {key} twice')
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+    return pos + 1, key
+
+
+def toml_create_list_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 2  # Skip "[["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
+
+    if out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+
+    if not src.startswith(']]', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+    return pos + 2, key
+
+
+def toml_key_value_rule(
+        src: str,
+        pos: TomlPos,
+        out: TomlOutput,
+        header: TomlKey,
+        parse_float: TomlParseFloat,
+) -> TomlPos:
+    pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
+    for cont_key in relative_path_cont_keys:
+        # Check that dotted key syntax does not redefine an existing table
+        if out.flags.is_(cont_key, TomlFlags.EXPLICIT_NEST):
+            raise toml_suffixed_err(src, pos, f'Cannot redefine namespace {cont_key}')
+        # Containers in the relative path can't be opened with the table syntax or dotted key/value syntax in following
+        # table sections.
+        out.flags.add_pending(cont_key, TomlFlags.EXPLICIT_NEST)
+
+    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
+        raise toml_suffixed_err(
+            src,
+            pos,
+            f'Cannot mutate immutable namespace {abs_key_parent}',
+        )
+
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    if key_stem in nest:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value')
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, TomlFlags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def toml_parse_key_value_pair(
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, TomlKey, ta.Any]:
+    pos, key = toml_parse_key(src, pos)
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != '=':
+        raise toml_suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
+    pos += 1
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, value = toml_parse_value(src, pos, parse_float)
+    return pos, key, value
+
+
+def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
+    pos, key_part = toml_parse_key_part(src, pos)
+    key: TomlKey = (key_part,)
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: ta.Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != '.':
+            return pos, key
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        pos, key_part = toml_parse_key_part(src, pos)
+        key += (key_part,)
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in TOML_BARE_KEY_CHARS:
+        start_pos = pos
+        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return toml_parse_literal_str(src, pos)
+    if char == '"':
+        return toml_parse_one_line_basic_str(src, pos)
+    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
+
+
+def toml_parse_one_line_basic_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1
+    return toml_parse_basic_str(src, pos, multiline=False)
+
+
+def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
+    pos += 1
+    array: list = []
+
+    pos = toml_skip_comments_and_array_ws(src, pos)
+    if src.startswith(']', pos):
+        return pos + 1, array
+    while True:
+        pos, val = toml_parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = toml_skip_comments_and_array_ws(src, pos)
+
+        c = src[pos:pos + 1]
+        if c == ']':
+            return pos + 1, array
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed array')
+        pos += 1
+
+        pos = toml_skip_comments_and_array_ws(src, pos)
+        if src.startswith(']', pos):
+            return pos + 1, array
+
+
+def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
+    pos += 1
+    nested_dict = TomlNestedDict()
+    flags = TomlFlags()
+
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    if src.startswith('}', pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, TomlFlags.FROZEN):
+            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+        if key_stem in nest:
+            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
+        nest[key_stem] = value
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        c = src[pos:pos + 1]
+        if c == '}':
+            return pos + 1, nested_dict.dict
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
+        if isinstance(value, (dict, list)):
+            flags.set(key, TomlFlags.FROZEN, recursive=True)
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+
+
+def toml_parse_basic_str_escape(
+        src: str,
+        pos: TomlPos,
+        *,
+        multiline: bool = False,
+) -> ta.Tuple[TomlPos, str]:
+    escape_id = src[pos:pos + 2]
+    pos += 2
+    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
+        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
+        # newline.
+        if escape_id != '\\\n':
+            pos = toml_skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ''
+            if char != '\n':
+                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
+            pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ''
+    if escape_id == '\\u':
+        return toml_parse_hex_char(src, pos, 4)
+    if escape_id == '\\U':
+        return toml_parse_hex_char(src, pos, 8)
+    try:
+        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
+
+
+def toml_parse_basic_str_escape_multiline(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    return toml_parse_basic_str_escape(src, pos, multiline=True)
+
+
+def toml_parse_hex_char(src: str, pos: TomlPos, hex_len: int) -> ta.Tuple[TomlPos, str]:
+    hex_str = src[pos:pos + hex_len]
+    if len(hex_str) != hex_len or not TOML_HEXDIGIT_CHARS.issuperset(hex_str):
+        raise toml_suffixed_err(src, pos, 'Invalid hex value')
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not toml_is_unicode_scalar_value(hex_int):
+        raise toml_suffixed_err(src, pos, 'Escaped character is not a Unicode scalar value')
+    return pos, chr(hex_int)
+
+
+def toml_parse_literal_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = toml_skip_until(
+        src, pos, "'", error_on=TOML_ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True,
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
+    pos += 3
+    if src.startswith('\n', pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = toml_skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = toml_parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def toml_parse_basic_str(src: str, pos: TomlPos, *, multiline: bool) -> ta.Tuple[TomlPos, str]:
+    if multiline:
+        error_on = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape_multiline
+    else:
+        error_on = TOML_ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape
+    result = ''
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise toml_suffixed_err(src, pos, 'Unterminated string') from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == '\\':
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise toml_suffixed_err(src, pos, f'Illegal character {char!r}')
+        pos += 1
+
+
+def toml_parse_value(  # noqa: C901
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, ta.Any]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+
+    # IMPORTANT: order conditions based on speed of checking and likelihood
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return toml_parse_multiline_str(src, pos, literal=False)
+        return toml_parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return toml_parse_multiline_str(src, pos, literal=True)
+        return toml_parse_literal_str(src, pos)
+
+    # Booleans
+    if char == 't':
+        if src.startswith('true', pos):
+            return pos + 4, True
+    if char == 'f':
+        if src.startswith('false', pos):
+            return pos + 5, False
+
+    # Arrays
+    if char == '[':
+        return toml_parse_array(src, pos, parse_float)
+
+    # Inline tables
+    if char == '{':
+        return toml_parse_inline_table(src, pos, parse_float)
+
+    # Dates and times
+    datetime_match = TOML_RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = toml_match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise toml_suffixed_err(src, pos, 'Invalid date or datetime') from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = TOML_RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), toml_match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats. The regex will greedily match any type starting with a decimal char, so needs to be
+    # located after handling of dates and times.
+    number_match = TOML_RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), toml_match_to_number(number_match, parse_float)
+
+    # Special floats
+    first_three = src[pos:pos + 3]
+    if first_three in {'inf', 'nan'}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos:pos + 4]
+    if first_four in {'-inf', '+inf', '-nan', '+nan'}:
+        return pos + 4, parse_float(first_four)
+
+    raise toml_suffixed_err(src, pos, 'Invalid value')
+
+
+def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
+    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
+
+    def coord_repr(src: str, pos: TomlPos) -> str:
+        if pos >= len(src):
+            return 'end of document'
+        line = src.count('\n', 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex('\n', 0, pos)
+        return f'line {line}, column {column}'
+
+    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
+
+
+def toml_is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
+
+
+def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
+    """A decorator to make `parse_float` safe.
+
+    `parse_float` must not return dicts or lists, because these types would be mixed with parsed TOML tables and arrays,
+    thus confusing the parser. The returned decorated callable raises `ValueError` instead of returning illegal types.
+    """
+    # The default `float` callable never returns illegal types. Optimize it.
+    if parse_float is float:
+        return float
+
+    def safe_parse_float(float_str: str) -> ta.Any:
+        float_value = parse_float(float_str)
+        if isinstance(float_value, (dict, list)):
+            raise ValueError('parse_float must not return dicts or lists')  # noqa
+        return float_value
+
+    return safe_parse_float
+
+
 ########################################
 # ../config.py
 
@@ -538,6 +1365,9 @@ class MainConfig:
 # ../deploy/config.py
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class DeployConfig:
     deploy_home: ta.Optional[str] = None
@@ -712,7 +1542,7 @@ def _pyremote_bootstrap_main(context_name: str) -> None:
     # Get pid
     pid = os.getpid()
 
-    # Two copies of main src to be sent to parent
+    # Two copies of payload src to be sent to parent
     r0, w0 = os.pipe()
     r1, w1 = os.pipe()
 
@@ -751,17 +1581,17 @@ def _pyremote_bootstrap_main(context_name: str) -> None:
         # Write pid
         os.write(1, struct.pack('<Q', pid))
 
-        # Read main src from stdin
-        main_z_len = struct.unpack('<I', os.read(0, 4))[0]
-        if len(main_z := os.fdopen(0, 'rb').read(main_z_len)) != main_z_len:
+        # 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
-        main_src = zlib.decompress(main_z)
+        payload_src = zlib.decompress(payload_z)
 
-        # Write both copies of main 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.
+        # 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(main_src)
+            fp.write(payload_src)
             fp.close()
 
         # Write second ack
@@ -825,7 +1655,7 @@ class PyremotePayloadRuntime:
     input: ta.BinaryIO
     output: ta.BinaryIO
     context_name: str
-    main_src: str
+    payload_src: str
     options: PyremoteBootstrapOptions
     env_info: PyremoteEnvInfo
 
@@ -833,9 +1663,9 @@ class PyremotePayloadRuntime:
 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 main src
+        # Read second copy of payload src
         r1 = os.fdopen(_PYREMOTE_BOOTSTRAP_SRC_FD, 'rb', 0)
-        main_src = r1.read().decode('utf-8')
+        payload_src = r1.read().decode('utf-8')
         r1.close()
 
         # Reap boostrap child. Must be done after reading second copy of source because source may be too big to fit in
@@ -853,7 +1683,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
             # Write temp source file
             import tempfile
             tfd, tfn = tempfile.mkstemp('-pyremote.py')
-            os.write(tfd, main_src.encode('utf-8'))
+            os.write(tfd, payload_src.encode('utf-8'))
             os.close(tfd)
 
             # Set vars
@@ -872,7 +1702,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
 
         # Read temp source file
         with open(os.environ.pop(_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR)) as sf:
-            main_src = sf.read()
+            payload_src = sf.read()
 
     # Restore vars
     sys.executable = os.environ.pop(_PYREMOTE_BOOTSTRAP_ARGV0_VAR)
@@ -905,7 +1735,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
         input=input,
         output=output,
         context_name=context_name,
-        main_src=main_src,
+        payload_src=payload_src,
         options=options,
         env_info=env_info,
     )
@@ -917,31 +1747,31 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
 class PyremoteBootstrapDriver:
     def __init__(
             self,
-            main_src: ta.Union[str, ta.Sequence[str]],
+            payload_src: ta.Union[str, ta.Sequence[str]],
             options: PyremoteBootstrapOptions = PyremoteBootstrapOptions(),
     ) -> None:
         super().__init__()
 
-        self._main_src = main_src
+        self._payload_src = payload_src
         self._options = options
 
-        self._prepared_main_src = self._prepare_main_src(main_src, options)
-        self._main_z = zlib.compress(self._prepared_main_src.encode('utf-8'))
+        self._prepared_payload_src = self._prepare_payload_src(payload_src, options)
+        self._payload_z = zlib.compress(self._prepared_payload_src.encode('utf-8'))
 
         self._options_json = json.dumps(dc.asdict(options), indent=None, separators=(',', ':')).encode('utf-8')  # noqa
     #
 
     @classmethod
-    def _prepare_main_src(
+    def _prepare_payload_src(
             cls,
-            main_src: ta.Union[str, ta.Sequence[str]],
+            payload_src: ta.Union[str, ta.Sequence[str]],
             options: PyremoteBootstrapOptions,
     ) -> str:
         parts: ta.List[str]
-        if isinstance(main_src, str):
-            parts = [main_src]
+        if isinstance(payload_src, str):
+            parts = [payload_src]
         else:
-            parts = list(main_src)
+            parts = list(payload_src)
 
         if (mn := options.main_name_override) is not None:
             parts.insert(0, f'__name__ = {mn!r}')
@@ -977,9 +1807,9 @@ class PyremoteBootstrapDriver:
         d = yield from self._read(8)
         pid = struct.unpack('<Q', d)[0]
 
-        # Write main src
-        yield from self._write(struct.pack('<I', len(self._main_z)))
-        yield from self._write(self._main_z)
+        # 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)
@@ -1208,8 +2038,8 @@ class _CachedNullary(_AbstractCachedNullary):
         return self._value
 
 
-def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _CachedNullary(fn)
+def cached_nullary(fn: CallableT) -> CallableT:
+    return _CachedNullary(fn)  # type: ignore
 
 
 def static_init(fn: CallableT) -> CallableT:
@@ -1713,6 +2543,13 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/logs.py
+
+
+log = logging.getLogger(__name__)
+
+
 ########################################
 # ../../../omlish/lite/maybes.py
 
@@ -1928,83 +2765,193 @@ def format_num_bytes(num_bytes: int) -> str:
 
 
 ########################################
-# ../../../omlish/os/deathsig.py
+# ../../../omlish/logs/filters.py
 
 
-LINUX_PR_SET_PDEATHSIG = 1  # Second arg is a signal
-LINUX_PR_GET_PDEATHSIG = 2  # Second arg is a ptr to return the signal
-
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        record.tid = threading.get_native_id()
+        return True
 
-def set_process_deathsig(sig: int) -> bool:
-    if sys.platform == 'linux':
-        libc = ct.CDLL('libc.so.6')
 
-        # int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
-        libc.prctl.restype = ct.c_int
-        libc.prctl.argtypes = [ct.c_int, ct.c_ulong, ct.c_ulong, ct.c_ulong, ct.c_ulong]
+########################################
+# ../../../omlish/logs/proxy.py
 
-        libc.prctl(LINUX_PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
 
-        return True
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
 
-    else:
-        return False
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
 
+    @property
+    def filters(self):
+        return self._underlying.filters
 
-########################################
-# ../../../omlish/os/linux.py
-"""
-➜  ~ cat /etc/os-release
-NAME="Amazon Linux"
-VERSION="2"
-ID="amzn"
-ID_LIKE="centos rhel fedora"
-VERSION_ID="2"
-PRETTY_NAME="Amazon Linux 2"
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
 
-➜  ~ cat /etc/os-release
-PRETTY_NAME="Ubuntu 22.04.5 LTS"
-NAME="Ubuntu"
-VERSION_ID="22.04"
-VERSION="22.04.5 LTS (Jammy Jellyfish)"
-VERSION_CODENAME=jammy
-ID=ubuntu
-ID_LIKE=debian
-UBUNTU_CODENAME=jammy
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
 
-➜  omlish git:(master) docker run -i python:3.12 cat /etc/os-release
-PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
-NAME="Debian GNU/Linux"
-VERSION_ID="12"
-VERSION="12 (bookworm)"
-VERSION_CODENAME=bookworm
-ID=debian
-"""
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
 
+    def filter(self, record):
+        return self._underlying.filter(record)
 
-@dc.dataclass(frozen=True)
-class LinuxOsRelease:
-    """
-    https://man7.org/linux/man-pages/man5/os-release.5.html
-    """
 
-    raw: ta.Mapping[str, str]
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
 
-    # General information identifying the operating system
+    _underlying: logging.Handler
 
     @property
-    def name(self) -> str:
-        """
-        A string identifying the operating system, without a version component, and suitable for presentation to the
-        user. If not set, a default of "NAME=Linux" may be used.
+    def underlying(self) -> logging.Handler:
+        return self._underlying
 
-        Examples: "NAME=Fedora", "NAME="Debian GNU/Linux"".
-        """
+    def get_name(self):
+        return self._underlying.get_name()
 
-        return self.raw['NAME']
+    def set_name(self, name):
+        self._underlying.set_name(name)
 
     @property
-    def id(self) -> str:
+    def name(self):
+        return self._underlying.name
+
+    @property
+    def level(self):
+        return self._underlying.level
+
+    @level.setter
+    def level(self, level):
+        self._underlying.level = level
+
+    @property
+    def formatter(self):
+        return self._underlying.formatter
+
+    @formatter.setter
+    def formatter(self, formatter):
+        self._underlying.formatter = formatter
+
+    def createLock(self):
+        self._underlying.createLock()
+
+    def acquire(self):
+        self._underlying.acquire()
+
+    def release(self):
+        self._underlying.release()
+
+    def setLevel(self, level):
+        self._underlying.setLevel(level)
+
+    def format(self, record):
+        return self._underlying.format(record)
+
+    def emit(self, record):
+        self._underlying.emit(record)
+
+    def handle(self, record):
+        return self._underlying.handle(record)
+
+    def setFormatter(self, fmt):
+        self._underlying.setFormatter(fmt)
+
+    def flush(self):
+        self._underlying.flush()
+
+    def close(self):
+        self._underlying.close()
+
+    def handleError(self, record):
+        self._underlying.handleError(record)
+
+
+########################################
+# ../../../omlish/os/deathsig.py
+
+
+LINUX_PR_SET_PDEATHSIG = 1  # Second arg is a signal
+LINUX_PR_GET_PDEATHSIG = 2  # Second arg is a ptr to return the signal
+
+
+def set_process_deathsig(sig: int) -> bool:
+    if sys.platform == 'linux':
+        libc = ct.CDLL('libc.so.6')
+
+        # int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
+        libc.prctl.restype = ct.c_int
+        libc.prctl.argtypes = [ct.c_int, ct.c_ulong, ct.c_ulong, ct.c_ulong, ct.c_ulong]
+
+        libc.prctl(LINUX_PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
+
+        return True
+
+    else:
+        return False
+
+
+########################################
+# ../../../omlish/os/linux.py
+"""
+➜  ~ cat /etc/os-release
+NAME="Amazon Linux"
+VERSION="2"
+ID="amzn"
+ID_LIKE="centos rhel fedora"
+VERSION_ID="2"
+PRETTY_NAME="Amazon Linux 2"
+
+➜  ~ cat /etc/os-release
+PRETTY_NAME="Ubuntu 22.04.5 LTS"
+NAME="Ubuntu"
+VERSION_ID="22.04"
+VERSION="22.04.5 LTS (Jammy Jellyfish)"
+VERSION_CODENAME=jammy
+ID=ubuntu
+ID_LIKE=debian
+UBUNTU_CODENAME=jammy
+
+➜  omlish git:(master) docker run -i python:3.12 cat /etc/os-release
+PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
+NAME="Debian GNU/Linux"
+VERSION_ID="12"
+VERSION="12 (bookworm)"
+VERSION_CODENAME=bookworm
+ID=debian
+"""
+
+
+@dc.dataclass(frozen=True)
+class LinuxOsRelease:
+    """
+    https://man7.org/linux/man-pages/man5/os-release.5.html
+    """
+
+    raw: ta.Mapping[str, str]
+
+    # General information identifying the operating system
+
+    @property
+    def name(self) -> str:
+        """
+        A string identifying the operating system, without a version component, and suitable for presentation to the
+        user. If not set, a default of "NAME=Linux" may be used.
+
+        Examples: "NAME=Fedora", "NAME="Debian GNU/Linux"".
+        """
+
+        return self.raw['NAME']
+
+    @property
+    def id(self) -> str:
         """
         A lower-case string (no spaces or other characters outside of 0-9, a-z, ".", "_" and "-") identifying the
         operating system, excluding any version information and suitable for processing by scripts or usage in generated
@@ -3112,22 +4059,22 @@ def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
 ~deploy
   deploy.pid (flock)
   /app
-    /<appspec> - shallow clone
+    /<appplaceholder> - shallow clone
   /conf
     /env
-      <appspec>.env
+      <appplaceholder>.env
     /nginx
-      <appspec>.conf
+      <appplaceholder>.conf
     /supervisor
-      <appspec>.conf
+      <appplaceholder>.conf
   /venv
-    /<appspec>
+    /<appplaceholder>
 
 ?
   /logs
-    /wrmsr--omlish--<spec>
+    /wrmsr--omlish--<placeholder>
 
-spec = <name>--<rev>--<when>
+placeholder = <name>--<rev>--<when>
 
 ==
 
@@ -3148,10 +4095,10 @@ for dn in [
 ##
 
 
-DEPLOY_PATH_SPEC_PLACEHOLDER = '@'
-DEPLOY_PATH_SPEC_SEPARATORS = '-.'
+DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER = '@'
+DEPLOY_PATH_PLACEHOLDER_SEPARATORS = '-.'
 
-DEPLOY_PATH_SPECS: ta.FrozenSet[str] = frozenset([
+DEPLOY_PATH_PLACEHOLDERS: ta.FrozenSet[str] = frozenset([
     'app',
     'tag',  # <rev>-<dt>
 ])
@@ -3169,7 +4116,7 @@ class DeployPathPart(abc.ABC):  # noqa
         raise NotImplementedError
 
     @abc.abstractmethod
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         raise NotImplementedError
 
 
@@ -3183,9 +4130,9 @@ class DirDeployPathPart(DeployPathPart, abc.ABC):
 
     @classmethod
     def parse(cls, s: str) -> 'DirDeployPathPart':
-        if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check.equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
-            return SpecDirDeployPathPart(s[1:])
+        if DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER in s:
+            check.equal(s[0], DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER)
+            return PlaceholderDirDeployPathPart(s[1:])
         else:
             return ConstDirDeployPathPart(s)
 
@@ -3197,13 +4144,13 @@ class FileDeployPathPart(DeployPathPart, abc.ABC):
 
     @classmethod
     def parse(cls, s: str) -> 'FileDeployPathPart':
-        if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check.equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
-            if not any(c in s for c in DEPLOY_PATH_SPEC_SEPARATORS):
-                return SpecFileDeployPathPart(s[1:], '')
+        if DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER in s:
+            check.equal(s[0], DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER)
+            if not any(c in s for c in DEPLOY_PATH_PLACEHOLDER_SEPARATORS):
+                return PlaceholderFileDeployPathPart(s[1:], '')
             else:
-                p = min(f for c in DEPLOY_PATH_SPEC_SEPARATORS if (f := s.find(c)) > 0)
-                return SpecFileDeployPathPart(s[1:p], s[p:])
+                p = min(f for c in DEPLOY_PATH_PLACEHOLDER_SEPARATORS if (f := s.find(c)) > 0)
+                return PlaceholderFileDeployPathPart(s[1:p], s[p:])
         else:
             return ConstFileDeployPathPart(s)
 
@@ -3218,9 +4165,9 @@ class ConstDeployPathPart(DeployPathPart, abc.ABC):
     def __post_init__(self) -> None:
         check.non_empty_str(self.name)
         check.not_in('/', self.name)
-        check.not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.name)
+        check.not_in(DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, self.name)
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         return self.name
 
 
@@ -3236,40 +4183,40 @@ class ConstFileDeployPathPart(ConstDeployPathPart, FileDeployPathPart):
 
 
 @dc.dataclass(frozen=True)
-class SpecDeployPathPart(DeployPathPart, abc.ABC):
-    spec: str  # DeployPathSpec
+class PlaceholderDeployPathPart(DeployPathPart, abc.ABC):
+    placeholder: str  # DeployPathPlaceholder
 
     def __post_init__(self) -> None:
-        check.non_empty_str(self.spec)
-        for c in [*DEPLOY_PATH_SPEC_SEPARATORS, DEPLOY_PATH_SPEC_PLACEHOLDER, '/']:
-            check.not_in(c, self.spec)
-        check.in_(self.spec, DEPLOY_PATH_SPECS)
-
-    def _render_spec(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        if specs is not None:
-            return specs[self.spec]  # type: ignore
+        check.non_empty_str(self.placeholder)
+        for c in [*DEPLOY_PATH_PLACEHOLDER_SEPARATORS, DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, '/']:
+            check.not_in(c, self.placeholder)
+        check.in_(self.placeholder, DEPLOY_PATH_PLACEHOLDERS)
+
+    def _render_placeholder(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        if placeholders is not None:
+            return placeholders[self.placeholder]  # type: ignore
         else:
-            return DEPLOY_PATH_SPEC_PLACEHOLDER + self.spec
+            return DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER + self.placeholder
 
 
 @dc.dataclass(frozen=True)
-class SpecDirDeployPathPart(SpecDeployPathPart, DirDeployPathPart):
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        return self._render_spec(specs)
+class PlaceholderDirDeployPathPart(PlaceholderDeployPathPart, DirDeployPathPart):
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        return self._render_placeholder(placeholders)
 
 
 @dc.dataclass(frozen=True)
-class SpecFileDeployPathPart(SpecDeployPathPart, FileDeployPathPart):
+class PlaceholderFileDeployPathPart(PlaceholderDeployPathPart, FileDeployPathPart):
     suffix: str
 
     def __post_init__(self) -> None:
         super().__post_init__()
         if self.suffix:
-            for c in [DEPLOY_PATH_SPEC_PLACEHOLDER, '/']:
+            for c in [DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, '/']:
                 check.not_in(c, self.suffix)
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        return self._render_spec(specs) + self.suffix
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        return self._render_placeholder(placeholders) + self.suffix
 
 
 ##
@@ -3286,22 +4233,22 @@ class DeployPath:
 
         pd = {}
         for i, p in enumerate(self.parts):
-            if isinstance(p, SpecDeployPathPart):
-                if p.spec in pd:
-                    raise DeployPathError('Duplicate specs in path', self)
-                pd[p.spec] = i
+            if isinstance(p, PlaceholderDeployPathPart):
+                if p.placeholder in pd:
+                    raise DeployPathError('Duplicate placeholders in path', self)
+                pd[p.placeholder] = i
 
         if 'tag' in pd:
             if 'app' not in pd or pd['app'] >= pd['tag']:
-                raise DeployPathError('Tag spec in path without preceding app', self)
+                raise DeployPathError('Tag placeholder in path without preceding app', self)
 
     @property
     def kind(self) -> ta.Literal['file', 'dir']:
         return self.parts[-1].kind
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         return os.path.join(  # noqa
-            *[p.render(specs) for p in self.parts],
+            *[p.render(placeholders) for p in self.parts],
             *([''] if self.kind == 'dir' else []),
         )
 
@@ -3329,6 +4276,34 @@ class DeployPathOwner(abc.ABC):
         raise NotImplementedError
 
 
+########################################
+# ../deploy/specs.py
+
+
+##
+
+
+@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 DeploySpec:
+    app: DeployApp
+    repo: DeployGitRepo
+    rev: DeployRev
+
+
 ########################################
 # ../remote/config.py
 
@@ -3389,6 +4364,75 @@ def get_remote_payload_src(
     return importlib.resources.files(__package__.split('.')[0] + '.scripts').joinpath('manage.py').read_text()
 
 
+########################################
+# ../system/platforms.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Platform(abc.ABC):  # noqa
+    pass
+
+
+class LinuxPlatform(Platform, abc.ABC):
+    pass
+
+
+class UbuntuPlatform(LinuxPlatform):
+    pass
+
+
+class AmazonLinuxPlatform(LinuxPlatform):
+    pass
+
+
+class GenericLinuxPlatform(LinuxPlatform):
+    pass
+
+
+class DarwinPlatform(Platform):
+    pass
+
+
+class UnknownPlatform(Platform):
+    pass
+
+
+##
+
+
+def _detect_system_platform() -> Platform:
+    plat = sys.platform
+
+    if plat == 'linux':
+        if (osr := LinuxOsRelease.read()) is None:
+            return GenericLinuxPlatform()
+
+        if osr.id == 'amzn':
+            return AmazonLinuxPlatform()
+
+        elif osr.id == 'ubuntu':
+            return UbuntuPlatform()
+
+        else:
+            return GenericLinuxPlatform()
+
+    elif plat == 'darwin':
+        return DarwinPlatform()
+
+    else:
+        return UnknownPlatform()
+
+
+@cached_nullary
+def detect_system_platform() -> Platform:
+    platform = _detect_system_platform()
+    log.info('Detected platform: %r', platform)
+    return platform
+
+
 ########################################
 # ../targets/targets.py
 """
@@ -3582,6 +4626,8 @@ def _get_argparse_arg_ann_kwargs(ann: ta.Any) -> ta.Mapping[str, ta.Any]:
         return {'action': 'store_true'}
     elif ann is list:
         return {'action': 'append'}
+    elif is_optional_alias(ann):
+        return _get_argparse_arg_ann_kwargs(get_optional_alias_arg(ann))
     else:
         raise TypeError(ann)
 
@@ -4711,936 +5757,805 @@ inj = Injection
 
 
 ########################################
-# ../../../omlish/lite/logs.py
+# ../../../omlish/lite/marshal.py
 """
 TODO:
- - translate json keys
- - debug
+ - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
+ - namedtuple
+ - literals
+ - newtypes?
 """
 
 
-log = logging.getLogger(__name__)
-
-
 ##
 
 
-class TidLogFilter(logging.Filter):
+@dc.dataclass(frozen=True)
+class ObjMarshalOptions:
+    raw_bytes: bool = False
+    nonstrict_dataclasses: bool = False
 
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
 
+class ObjMarshaler(abc.ABC):
+    @abc.abstractmethod
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
-##
+    @abc.abstractmethod
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
 
-class JsonLogFormatter(logging.Formatter):
+class NopObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return json_dumps_compact(dct)
 
+@dc.dataclass()
+class ProxyObjMarshaler(ObjMarshaler):
+    m: ta.Optional[ObjMarshaler] = None
 
-##
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).marshal(o, ctx)
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).unmarshal(o, ctx)
 
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)-6s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
 
+@dc.dataclass(frozen=True)
+class CastObjMarshaler(ObjMarshaler):
+    ty: type
 
-class StandardLogFormatter(logging.Formatter):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(o)
 
-    converter = datetime.datetime.fromtimestamp  # type: ignore
 
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)  # type: ignore
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
+class DynamicObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return ctx.manager.marshal_obj(o, opts=ctx.options)
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-##
 
+@dc.dataclass(frozen=True)
+class Base64ObjMarshaler(ObjMarshaler):
+    ty: type
 
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return base64.b64encode(o).decode('ascii')
 
-    @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(base64.b64decode(o))
 
-    @property
-    def filters(self):
-        return self._underlying.filters
 
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
+@dc.dataclass(frozen=True)
+class BytesSwitchedObjMarshaler(ObjMarshaler):
+    m: ObjMarshaler
 
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
+            return o
+        return self.m.marshal(o, ctx)
 
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
+            return o
+        return self.m.unmarshal(o, ctx)
 
-    def filter(self, record):
-        return self._underlying.filter(record)
 
+@dc.dataclass(frozen=True)
+class EnumObjMarshaler(ObjMarshaler):
+    ty: type
 
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o.name
 
-    _underlying: logging.Handler
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty.__members__[o]  # type: ignore
 
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
 
-    def get_name(self):
-        return self._underlying.get_name()
+@dc.dataclass(frozen=True)
+class OptionalObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
 
-    def set_name(self, name):
-        self._underlying.set_name(name)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if o is None:
+            return None
+        return self.item.marshal(o, ctx)
 
-    @property
-    def name(self):
-        return self._underlying.name
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if o is None:
+            return None
+        return self.item.unmarshal(o, ctx)
 
-    @property
-    def level(self):
-        return self._underlying.level
 
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
+@dc.dataclass(frozen=True)
+class MappingObjMarshaler(ObjMarshaler):
+    ty: type
+    km: ObjMarshaler
+    vm: ObjMarshaler
 
-    @property
-    def formatter(self):
-        return self._underlying.formatter
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
 
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
 
-    def createLock(self):
-        self._underlying.createLock()
 
-    def acquire(self):
-        self._underlying.acquire()
+@dc.dataclass(frozen=True)
+class IterableObjMarshaler(ObjMarshaler):
+    ty: type
+    item: ObjMarshaler
 
-    def release(self):
-        self._underlying.release()
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return [self.item.marshal(e, ctx) for e in o]
 
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(self.item.unmarshal(e, ctx) for e in o)
 
-    def format(self, record):
-        return self._underlying.format(record)
 
-    def emit(self, record):
-        self._underlying.emit(record)
+@dc.dataclass(frozen=True)
+class DataclassObjMarshaler(ObjMarshaler):
+    ty: type
+    fs: ta.Mapping[str, ObjMarshaler]
+    nonstrict: bool = False
 
-    def handle(self, record):
-        return self._underlying.handle(record)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {
+            k: m.marshal(getattr(o, k), ctx)
+            for k, m in self.fs.items()
+        }
 
-    def setFormatter(self, fmt):
-        self._underlying.setFormatter(fmt)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(**{
+            k: self.fs[k].unmarshal(v, ctx)
+            for k, v in o.items()
+            if not (self.nonstrict or ctx.options.nonstrict_dataclasses) or k in self.fs
+        })
 
-    def flush(self):
-        self._underlying.flush()
 
-    def close(self):
-        self._underlying.close()
+@dc.dataclass(frozen=True)
+class PolymorphicObjMarshaler(ObjMarshaler):
+    class Impl(ta.NamedTuple):
+        ty: type
+        tag: str
+        m: ObjMarshaler
 
-    def handleError(self, record):
-        self._underlying.handleError(record)
+    impls_by_ty: ta.Mapping[type, Impl]
+    impls_by_tag: ta.Mapping[str, Impl]
 
+    @classmethod
+    def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
+        return cls(
+            {i.ty: i for i in impls},
+            {i.tag: i for i in impls},
+        )
 
-##
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        impl = self.impls_by_ty[type(o)]
+        return {impl.tag: impl.m.marshal(o, ctx)}
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        [(t, v)] = o.items()
+        impl = self.impls_by_tag[t]
+        return impl.m.unmarshal(v, ctx)
 
-class StandardLogHandler(ProxyLogHandler):
-    pass
 
+@dc.dataclass(frozen=True)
+class DatetimeObjMarshaler(ObjMarshaler):
+    ty: type
 
-##
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o.isoformat()
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty.fromisoformat(o)  # type: ignore
 
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
 
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
+class DecimalObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return str(check.isinstance(o, decimal.Decimal))
 
-    else:
-        raise Exception("Can't find lock in logging module")
-
-
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
-
-        #
-
-        if not force:
-            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
-                return None
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return decimal.Decimal(check.isinstance(v, str))
 
-        #
 
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
+class FractionObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        fr = check.isinstance(o, fractions.Fraction)
+        return [fr.numerator, fr.denominator]
 
-        #
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        num, denom = check.isinstance(v, list)
+        return fractions.Fraction(num, denom)
 
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLogFormatter()
-        else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
 
-        #
+class UuidObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return str(o)
 
-        handler.addFilter(TidLogFilter())
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return uuid.UUID(o)
 
-        #
 
-        target.addHandler(handler)
+##
 
-        #
 
-        if level is not None:
-            target.setLevel(level)
+_DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
+    **{t: NopObjMarshaler() for t in (type(None),)},
+    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
+    **{t: BytesSwitchedObjMarshaler(Base64ObjMarshaler(t)) for t in (bytes, bytearray)},
+    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
+    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
 
-        #
+    ta.Any: DynamicObjMarshaler(),
 
-        return StandardLogHandler(handler)
+    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
+    decimal.Decimal: DecimalObjMarshaler(),
+    fractions.Fraction: FractionObjMarshaler(),
+    uuid.UUID: UuidObjMarshaler(),
+}
 
+_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (dict,)},
+    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
+}
 
-########################################
-# ../../../omlish/lite/marshal.py
-"""
-TODO:
- - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
- - namedtuple
- - literals
-"""
+_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (list, tuple, set, frozenset)},
+    collections.abc.Set: frozenset,
+    collections.abc.MutableSet: set,
+    collections.abc.Sequence: tuple,
+    collections.abc.MutableSequence: list,
+}
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class ObjMarshalOptions:
-    raw_bytes: bool = False
-    nonstrict_dataclasses: bool = False
-
-
-class ObjMarshaler(abc.ABC):
-    @abc.abstractmethod
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
+class ObjMarshalerManager:
+    def __init__(
+            self,
+            *,
+            default_options: ObjMarshalOptions = ObjMarshalOptions(),
 
-    @abc.abstractmethod
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
+            default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
+            generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
+            generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
+    ) -> None:
+        super().__init__()
 
+        self._default_options = default_options
 
-class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+        self._obj_marshalers = dict(default_obj_marshalers)
+        self._generic_mapping_types = generic_mapping_types
+        self._generic_iterable_types = generic_iterable_types
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+        self._lock = threading.RLock()
+        self._marshalers: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
+        self._proxies: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
 
+    #
 
-@dc.dataclass()
-class ProxyObjMarshaler(ObjMarshaler):
-    m: ta.Optional[ObjMarshaler] = None
+    def make_obj_marshaler(
+            self,
+            ty: ta.Any,
+            rec: ta.Callable[[ta.Any], ObjMarshaler],
+            *,
+            nonstrict_dataclasses: bool = False,
+    ) -> ObjMarshaler:
+        if isinstance(ty, type):
+            if abc.ABC in ty.__bases__:
+                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
+                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
+                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
+                else:
+                    ins = {ity: ity.__qualname__ for ity in impls}
+                return PolymorphicObjMarshaler.of([
+                    PolymorphicObjMarshaler.Impl(
+                        ity,
+                        itn,
+                        rec(ity),
+                    )
+                    for ity, itn in ins.items()
+                ])
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).marshal(o, ctx)
+            if issubclass(ty, enum.Enum):
+                return EnumObjMarshaler(ty)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).unmarshal(o, ctx)
+            if dc.is_dataclass(ty):
+                return DataclassObjMarshaler(
+                    ty,
+                    {f.name: rec(f.type) for f in dc.fields(ty)},
+                    nonstrict=nonstrict_dataclasses,
+                )
 
+        if is_generic_alias(ty):
+            try:
+                mt = self._generic_mapping_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                k, v = ta.get_args(ty)
+                return MappingObjMarshaler(mt, rec(k), rec(v))
 
-@dc.dataclass(frozen=True)
-class CastObjMarshaler(ObjMarshaler):
-    ty: type
+            try:
+                st = self._generic_iterable_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                [e] = ta.get_args(ty)
+                return IterableObjMarshaler(st, rec(e))
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+            if is_union_alias(ty):
+                return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(o)
+        raise TypeError(ty)
 
+    #
 
-class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return ctx.manager.marshal_obj(o, opts=ctx.options)
+    def register_opj_marshaler(self, ty: ta.Any, m: ObjMarshaler) -> None:
+        with self._lock:
+            if ty in self._obj_marshalers:
+                raise KeyError(ty)
+            self._obj_marshalers[ty] = m
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+    def get_obj_marshaler(
+            self,
+            ty: ta.Any,
+            *,
+            no_cache: bool = False,
+            **kwargs: ta.Any,
+    ) -> ObjMarshaler:
+        with self._lock:
+            if not no_cache:
+                try:
+                    return self._obj_marshalers[ty]
+                except KeyError:
+                    pass
 
+            try:
+                return self._proxies[ty]
+            except KeyError:
+                pass
 
-@dc.dataclass(frozen=True)
-class Base64ObjMarshaler(ObjMarshaler):
-    ty: type
+            rec = functools.partial(
+                self.get_obj_marshaler,
+                no_cache=no_cache,
+                **kwargs,
+            )
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return base64.b64encode(o).decode('ascii')
+            p = ProxyObjMarshaler()
+            self._proxies[ty] = p
+            try:
+                m = self.make_obj_marshaler(ty, rec, **kwargs)
+            finally:
+                del self._proxies[ty]
+            p.m = m
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(base64.b64decode(o))
+            if not no_cache:
+                self._obj_marshalers[ty] = m
+            return m
 
+    #
 
-@dc.dataclass(frozen=True)
-class BytesSwitchedObjMarshaler(ObjMarshaler):
-    m: ObjMarshaler
+    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+        return ObjMarshalContext(
+            options=opts or self._default_options,
+            manager=self,
+        )
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if ctx.options.raw_bytes:
-            return o
-        return self.m.marshal(o, ctx)
+    def marshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        m = self.get_obj_marshaler(ty if ty is not None else type(o))
+        return m.marshal(o, self._make_context(opts))
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if ctx.options.raw_bytes:
-            return o
-        return self.m.unmarshal(o, ctx)
+    def unmarshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Union[ta.Type[T], ta.Any],
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> T:
+        m = self.get_obj_marshaler(ty)
+        return m.unmarshal(o, self._make_context(opts))
+
+    def roundtrip_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        if ty is None:
+            ty = type(o)
+        m: ta.Any = self.marshal_obj(o, ty, opts)
+        u: ta.Any = self.unmarshal_obj(m, ty, opts)
+        return u
 
 
 @dc.dataclass(frozen=True)
-class EnumObjMarshaler(ObjMarshaler):
-    ty: type
+class ObjMarshalContext:
+    options: ObjMarshalOptions
+    manager: ObjMarshalerManager
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o.name
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.__members__[o]  # type: ignore
+##
 
 
-@dc.dataclass(frozen=True)
-class OptionalObjMarshaler(ObjMarshaler):
-    item: ObjMarshaler
+OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if o is None:
-            return None
-        return self.item.marshal(o, ctx)
+register_opj_marshaler = OBJ_MARSHALER_MANAGER.register_opj_marshaler
+get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if o is None:
-            return None
-        return self.item.unmarshal(o, ctx)
+marshal_obj = OBJ_MARSHALER_MANAGER.marshal_obj
+unmarshal_obj = OBJ_MARSHALER_MANAGER.unmarshal_obj
 
 
-@dc.dataclass(frozen=True)
-class MappingObjMarshaler(ObjMarshaler):
-    ty: type
-    km: ObjMarshaler
-    vm: ObjMarshaler
+########################################
+# ../../../omlish/lite/runtime.py
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
 
 
-@dc.dataclass(frozen=True)
-class IterableObjMarshaler(ObjMarshaler):
-    ty: type
-    item: ObjMarshaler
+REQUIRED_PYTHON_VERSION = (3, 8)
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return [self.item.marshal(e, ctx) for e in o]
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(self.item.unmarshal(e, ctx) for e in o)
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
 
 
-@dc.dataclass(frozen=True)
-class DataclassObjMarshaler(ObjMarshaler):
-    ty: type
-    fs: ta.Mapping[str, ObjMarshaler]
-    nonstrict: bool = False
+########################################
+# ../../../omlish/logs/json.py
+"""
+TODO:
+ - translate json keys
+"""
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {
-            k: m.marshal(getattr(o, k), ctx)
-            for k, m in self.fs.items()
+
+class JsonLogFormatter(logging.Formatter):
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
+
+    def __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
+
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
         }
+        return self._json_dumps(dct)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(**{
-            k: self.fs[k].unmarshal(v, ctx)
-            for k, v in o.items()
-            if not (self.nonstrict or ctx.options.nonstrict_dataclasses) or k in self.fs
-        })
+
+########################################
+# ../../../omdev/interp/types.py
+
+
+# See https://peps.python.org/pep-3149/
+INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
+    ('debug', 'd'),
+    ('threaded', 't'),
+])
+
+INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
+    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
+)
 
 
 @dc.dataclass(frozen=True)
-class PolymorphicObjMarshaler(ObjMarshaler):
-    class Impl(ta.NamedTuple):
-        ty: type
-        tag: str
-        m: ObjMarshaler
+class InterpOpts:
+    threaded: bool = False
+    debug: bool = False
 
-    impls_by_ty: ta.Mapping[type, Impl]
-    impls_by_tag: ta.Mapping[str, Impl]
+    def __str__(self) -> str:
+        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
 
     @classmethod
-    def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
+    def parse(cls, s: str) -> 'InterpOpts':
+        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+
+    @classmethod
+    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
+        kw = {}
+        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
+            s, kw[a] = s[:-1], True
+        return s, cls(**kw)
+
+
+@dc.dataclass(frozen=True)
+class InterpVersion:
+    version: Version
+    opts: InterpOpts
+
+    def __str__(self) -> str:
+        return str(self.version) + str(self.opts)
+
+    @classmethod
+    def parse(cls, s: str) -> 'InterpVersion':
+        s, o = InterpOpts.parse_suffix(s)
+        v = Version(s)
         return cls(
-            {i.ty: i for i in impls},
-            {i.tag: i for i in impls},
+            version=v,
+            opts=o,
         )
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o, ctx)}
-
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        [(t, v)] = o.items()
-        impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v, ctx)
+    @classmethod
+    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
+        try:
+            return cls.parse(s)
+        except (KeyError, InvalidVersion):
+            return None
 
 
 @dc.dataclass(frozen=True)
-class DatetimeObjMarshaler(ObjMarshaler):
-    ty: type
+class InterpSpecifier:
+    specifier: Specifier
+    opts: InterpOpts
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o.isoformat()
+    def __str__(self) -> str:
+        return str(self.specifier) + str(self.opts)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.fromisoformat(o)  # type: ignore
+    @classmethod
+    def parse(cls, s: str) -> 'InterpSpecifier':
+        s, o = InterpOpts.parse_suffix(s)
+        if not any(s.startswith(o) for o in Specifier.OPERATORS):
+            s = '~=' + s
+            if s.count('.') < 2:
+                s += '.0'
+        return cls(
+            specifier=Specifier(s),
+            opts=o,
+        )
 
+    def contains(self, iv: InterpVersion) -> bool:
+        return self.specifier.contains(iv.version) and self.opts == iv.opts
 
-class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(check.isinstance(o, decimal.Decimal))
+    def __contains__(self, iv: InterpVersion) -> bool:
+        return self.contains(iv)
 
-    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return decimal.Decimal(check.isinstance(v, str))
 
+@dc.dataclass(frozen=True)
+class Interp:
+    exe: str
+    version: InterpVersion
 
-class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        fr = check.isinstance(o, fractions.Fraction)
-        return [fr.numerator, fr.denominator]
 
-    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        num, denom = check.isinstance(v, list)
-        return fractions.Fraction(num, denom)
+########################################
+# ../../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())
 
-class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(o)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return uuid.UUID(o)
+def read_config_file(
+        path: str,
+        cls: ta.Type[T],
+        *,
+        prepare: ta.Optional[ta.Callable[[ConfigMapping], ConfigMapping]] = None,
+) -> 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 unmarshal_obj(config_dct, cls)
 
 
-_DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
-    **{t: NopObjMarshaler() for t in (type(None),)},
-    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
-    **{t: BytesSwitchedObjMarshaler(Base64ObjMarshaler(t)) for t in (bytes, bytearray)},
-    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
-    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
+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
 
-    ta.Any: DynamicObjMarshaler(),
+    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})
 
-    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
-    decimal.Decimal: DecimalObjMarshaler(),
-    fractions.Fraction: FractionObjMarshaler(),
-    uuid.UUID: UuidObjMarshaler(),
-}
+    else:
+        check.not_isinstance(o, str)
+        lst.extend(o)
 
-_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (dict,)},
-    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
-}
+    seen = set()
+    for d in lst:
+        n = d['name']
+        if n in d:
+            raise KeyError(f'Duplicate name: {n}')
+        seen.add(n)
 
-_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (list, tuple, set, frozenset)},
-    collections.abc.Set: frozenset,
-    collections.abc.MutableSet: set,
-    collections.abc.Sequence: tuple,
-    collections.abc.MutableSequence: list,
-}
+    return lst
 
 
-##
+########################################
+# ../commands/marshal.py
 
 
-class ObjMarshalerManager:
-    def __init__(
-            self,
-            *,
-            default_options: ObjMarshalOptions = ObjMarshalOptions(),
+def install_command_marshaling(
+        cmds: CommandNameMap,
+        msh: ObjMarshalerManager,
+) -> None:
+    for fn in [
+        lambda c: c,
+        lambda c: c.Output,
+    ]:
+        msh.register_opj_marshaler(
+            fn(Command),
+            PolymorphicObjMarshaler.of([
+                PolymorphicObjMarshaler.Impl(
+                    fn(cmd),
+                    name,
+                    msh.get_obj_marshaler(fn(cmd)),
+                )
+                for name, cmd in cmds.items()
+            ]),
+        )
 
-            default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
-            generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
-            generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
-    ) -> None:
-        super().__init__()
 
-        self._default_options = default_options
+########################################
+# ../commands/ping.py
 
-        self._obj_marshalers = dict(default_obj_marshalers)
-        self._generic_mapping_types = generic_mapping_types
-        self._generic_iterable_types = generic_iterable_types
 
-        self._lock = threading.RLock()
-        self._marshalers: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
-        self._proxies: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
+##
 
-    #
 
-    def make_obj_marshaler(
-            self,
-            ty: ta.Any,
-            rec: ta.Callable[[ta.Any], ObjMarshaler],
-            *,
-            nonstrict_dataclasses: bool = False,
-    ) -> ObjMarshaler:
-        if isinstance(ty, type):
-            if abc.ABC in ty.__bases__:
-                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
-                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
-                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
-                else:
-                    ins = {ity: ity.__qualname__ for ity in impls}
-                return PolymorphicObjMarshaler.of([
-                    PolymorphicObjMarshaler.Impl(
-                        ity,
-                        itn,
-                        rec(ity),
-                    )
-                    for ity, itn in ins.items()
-                ])
+@dc.dataclass(frozen=True)
+class PingCommand(Command['PingCommand.Output']):
+    time: float = dc.field(default_factory=time.time)
 
-            if issubclass(ty, enum.Enum):
-                return EnumObjMarshaler(ty)
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        time: float
 
-            if dc.is_dataclass(ty):
-                return DataclassObjMarshaler(
-                    ty,
-                    {f.name: rec(f.type) for f in dc.fields(ty)},
-                    nonstrict=nonstrict_dataclasses,
-                )
 
-        if is_generic_alias(ty):
-            try:
-                mt = self._generic_mapping_types[ta.get_origin(ty)]
-            except KeyError:
-                pass
-            else:
-                k, v = ta.get_args(ty)
-                return MappingObjMarshaler(mt, rec(k), rec(v))
+class PingCommandExecutor(CommandExecutor[PingCommand, PingCommand.Output]):
+    async def execute(self, cmd: PingCommand) -> PingCommand.Output:
+        return PingCommand.Output(cmd.time)
 
-            try:
-                st = self._generic_iterable_types[ta.get_origin(ty)]
-            except KeyError:
-                pass
-            else:
-                [e] = ta.get_args(ty)
-                return IterableObjMarshaler(st, rec(e))
 
-            if is_union_alias(ty):
-                return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
+########################################
+# ../commands/types.py
 
-        raise TypeError(ty)
 
-    #
+CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
 
-    def register_opj_marshaler(self, ty: ta.Any, m: ObjMarshaler) -> None:
-        with self._lock:
-            if ty in self._obj_marshalers:
-                raise KeyError(ty)
-            self._obj_marshalers[ty] = m
 
-    def get_obj_marshaler(
-            self,
-            ty: ta.Any,
-            *,
-            no_cache: bool = False,
-            **kwargs: ta.Any,
-    ) -> ObjMarshaler:
-        with self._lock:
-            if not no_cache:
-                try:
-                    return self._obj_marshalers[ty]
-                except KeyError:
-                    pass
+########################################
+# ../deploy/commands.py
 
-            try:
-                return self._proxies[ty]
-            except KeyError:
-                pass
 
-            rec = functools.partial(
-                self.get_obj_marshaler,
-                no_cache=no_cache,
-                **kwargs,
-            )
+##
 
-            p = ProxyObjMarshaler()
-            self._proxies[ty] = p
-            try:
-                m = self.make_obj_marshaler(ty, rec, **kwargs)
-            finally:
-                del self._proxies[ty]
-            p.m = m
 
-            if not no_cache:
-                self._obj_marshalers[ty] = m
-            return m
+@dc.dataclass(frozen=True)
+class DeployCommand(Command['DeployCommand.Output']):
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pass
 
-    #
 
-    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
-        return ObjMarshalContext(
-            options=opts or self._default_options,
-            manager=self,
-        )
+class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
+    async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
+        log.info('Deploying!')
 
-    def marshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        m = self.get_obj_marshaler(ty if ty is not None else type(o))
-        return m.marshal(o, self._make_context(opts))
+        return DeployCommand.Output()
 
-    def unmarshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Union[ta.Type[T], ta.Any],
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> T:
-        m = self.get_obj_marshaler(ty)
-        return m.unmarshal(o, self._make_context(opts))
 
-    def roundtrip_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        if ty is None:
-            ty = type(o)
-        m: ta.Any = self.marshal_obj(o, ty, opts)
-        u: ta.Any = self.unmarshal_obj(m, ty, opts)
-        return u
+########################################
+# ../marshal.py
 
 
 @dc.dataclass(frozen=True)
-class ObjMarshalContext:
-    options: ObjMarshalOptions
-    manager: ObjMarshalerManager
-
-
-##
-
-
-OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
+class ObjMarshalerInstaller:
+    fn: ta.Callable[[ObjMarshalerManager], None]
 
-register_opj_marshaler = OBJ_MARSHALER_MANAGER.register_opj_marshaler
-get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler
 
-marshal_obj = OBJ_MARSHALER_MANAGER.marshal_obj
-unmarshal_obj = OBJ_MARSHALER_MANAGER.unmarshal_obj
+ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])
 
 
 ########################################
-# ../../../omlish/lite/runtime.py
-
+# ../remote/channel.py
 
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
 
+##
 
-REQUIRED_PYTHON_VERSION = (3, 8)
 
+class RemoteChannel(abc.ABC):
+    @abc.abstractmethod
+    def send_obj(self, o: ta.Any, ty: ta.Any = None) -> ta.Awaitable[None]:
+        raise NotImplementedError
 
-def check_runtime_version() -> None:
-    if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+    @abc.abstractmethod
+    def recv_obj(self, ty: ta.Type[T]) -> ta.Awaitable[ta.Optional[T]]:
+        raise NotImplementedError
 
+    def set_marshaler(self, msh: ObjMarshalerManager) -> None:  # noqa
+        pass
 
-########################################
-# ../../../omdev/interp/types.py
 
-
-# See https://peps.python.org/pep-3149/
-INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
-    ('debug', 'd'),
-    ('threaded', 't'),
-])
-
-INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
-    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
-)
-
-
-@dc.dataclass(frozen=True)
-class InterpOpts:
-    threaded: bool = False
-    debug: bool = False
-
-    def __str__(self) -> str:
-        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpOpts':
-        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
-
-    @classmethod
-    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
-        kw = {}
-        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
-            s, kw[a] = s[:-1], True
-        return s, cls(**kw)
-
-
-@dc.dataclass(frozen=True)
-class InterpVersion:
-    version: Version
-    opts: InterpOpts
-
-    def __str__(self) -> str:
-        return str(self.version) + str(self.opts)
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpVersion':
-        s, o = InterpOpts.parse_suffix(s)
-        v = Version(s)
-        return cls(
-            version=v,
-            opts=o,
-        )
-
-    @classmethod
-    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
-        try:
-            return cls.parse(s)
-        except (KeyError, InvalidVersion):
-            return None
-
-
-@dc.dataclass(frozen=True)
-class InterpSpecifier:
-    specifier: Specifier
-    opts: InterpOpts
-
-    def __str__(self) -> str:
-        return str(self.specifier) + str(self.opts)
-
-    @classmethod
-    def parse(cls, s: str) -> 'InterpSpecifier':
-        s, o = InterpOpts.parse_suffix(s)
-        if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
-            if s.count('.') < 2:
-                s += '.0'
-        return cls(
-            specifier=Specifier(s),
-            opts=o,
-        )
-
-    def contains(self, iv: InterpVersion) -> bool:
-        return self.specifier.contains(iv.version) and self.opts == iv.opts
-
-    def __contains__(self, iv: InterpVersion) -> bool:
-        return self.contains(iv)
-
-
-@dc.dataclass(frozen=True)
-class Interp:
-    exe: str
-    version: InterpVersion
-
-
-########################################
-# ../commands/marshal.py
-
-
-def install_command_marshaling(
-        cmds: CommandNameMap,
-        msh: ObjMarshalerManager,
-) -> None:
-    for fn in [
-        lambda c: c,
-        lambda c: c.Output,
-    ]:
-        msh.register_opj_marshaler(
-            fn(Command),
-            PolymorphicObjMarshaler.of([
-                PolymorphicObjMarshaler.Impl(
-                    fn(cmd),
-                    name,
-                    msh.get_obj_marshaler(fn(cmd)),
-                )
-                for name, cmd in cmds.items()
-            ]),
-        )
-
-
-########################################
-# ../commands/ping.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class PingCommand(Command['PingCommand.Output']):
-    time: float = dc.field(default_factory=time.time)
-
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        time: float
-
-
-class PingCommandExecutor(CommandExecutor[PingCommand, PingCommand.Output]):
-    async def execute(self, cmd: PingCommand) -> PingCommand.Output:
-        return PingCommand.Output(cmd.time)
-
-
-########################################
-# ../commands/types.py
-
-
-CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
-
-
-########################################
-# ../deploy/commands.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployCommand(Command['DeployCommand.Output']):
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        pass
-
-
-class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
-        log.info('Deploying!')
-
-        return DeployCommand.Output()
-
-
-########################################
-# ../marshal.py
-
-
-@dc.dataclass(frozen=True)
-class ObjMarshalerInstaller:
-    fn: ta.Callable[[ObjMarshalerManager], None]
-
-
-ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])
-
-
-########################################
-# ../remote/channel.py
-
-
-##
-
-
-class RemoteChannel(abc.ABC):
-    @abc.abstractmethod
-    def send_obj(self, o: ta.Any, ty: ta.Any = None) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def recv_obj(self, ty: ta.Type[T]) -> ta.Awaitable[ta.Optional[T]]:
-        raise NotImplementedError
-
-    def set_marshaler(self, msh: ObjMarshalerManager) -> None:  # noqa
-        pass
-
-
-##
+##
 
 
 class RemoteChannelImpl(RemoteChannel):
@@ -5700,76 +6615,136 @@ class RemoteChannelImpl(RemoteChannel):
 
 
 ########################################
-# ../system/platforms.py
+# ../system/config.py
 
 
-##
+@dc.dataclass(frozen=True)
+class SystemConfig:
+    platform: ta.Optional[Platform] = None
 
 
-@dc.dataclass(frozen=True)
-class Platform(abc.ABC):  # noqa
-    pass
+########################################
+# ../../../omlish/logs/standard.py
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+"""
 
 
-class LinuxPlatform(Platform, abc.ABC):
-    pass
+##
 
 
-class UbuntuPlatform(LinuxPlatform):
-    pass
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)-6s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
 
 
-class AmazonLinuxPlatform(LinuxPlatform):
-    pass
+class StandardLogFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
 
+    converter = datetime.datetime.fromtimestamp  # type: ignore
 
-class GenericLinuxPlatform(LinuxPlatform):
-    pass
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)  # type: ignore
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
 
-class DarwinPlatform(Platform):
-    pass
+##
 
 
-class UnknownPlatform(Platform):
+class StandardLogHandler(ProxyLogHandler):
     pass
 
 
 ##
 
 
-def _detect_system_platform() -> Platform:
-    plat = sys.platform
-
-    if plat == 'linux':
-        if (osr := LinuxOsRelease.read()) is None:
-            return GenericLinuxPlatform()
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
 
-        if osr.id == 'amzn':
-            return AmazonLinuxPlatform()
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
 
-        elif osr.id == 'ubuntu':
-            return UbuntuPlatform()
+    else:
+        raise Exception("Can't find lock in logging module")
+
+
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
+                return None
+
+        #
+
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
 
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLogFormatter()
         else:
-            return GenericLinuxPlatform()
+            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
 
-    elif plat == 'darwin':
-        return DarwinPlatform()
+        #
 
-    else:
-        return UnknownPlatform()
+        handler.addFilter(TidLogFilter())
 
+        #
 
-@cached_nullary
-def detect_system_platform() -> Platform:
-    platform = _detect_system_platform()
-    log.info('Detected platform: %r', platform)
-    return platform
+        target.addHandler(handler)
+
+        #
+
+        if level is not None:
+            target.setLevel(level)
+
+        #
+
+        return StandardLogHandler(handler)
 
 
 ########################################
-# ../../../omlish/lite/subprocesses.py
+# ../../../omlish/subprocesses.py
 
 
 ##
@@ -5820,8 +6795,8 @@ def subprocess_close(
 ##
 
 
-class AbstractSubprocesses(abc.ABC):  # noqa
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = log
+class BaseSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
 
     def __init__(
             self,
@@ -5834,6 +6809,9 @@ class AbstractSubprocesses(abc.ABC):  # noqa
         self._log = log if log is not None else self.DEFAULT_LOGGER
         self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
 
+    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+        self._log = log
+
     #
 
     def prepare_args(
@@ -5945,23 +6923,25 @@ class AbstractSubprocesses(abc.ABC):  # noqa
 ##
 
 
-class Subprocesses(AbstractSubprocesses):
+class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
     def check_call(
             self,
             *cmd: str,
             stdout: ta.Any = sys.stderr,
             **kwargs: ta.Any,
     ) -> None:
-        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
-            subprocess.check_call(cmd, **kwargs)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def check_output(
             self,
             *cmd: str,
             **kwargs: ta.Any,
     ) -> bytes:
-        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
-            return subprocess.check_output(cmd, **kwargs)
+        raise NotImplementedError
+
+    #
 
     def check_output_str(
             self,
@@ -6003,9 +6983,109 @@ class Subprocesses(AbstractSubprocesses):
             return ret.decode().strip()
 
 
+##
+
+
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+
 subprocesses = Subprocesses()
 
 
+##
+
+
+class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+
+    #
+
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+########################################
+# ../bootstrap.py
+
+
+@dc.dataclass(frozen=True)
+class MainBootstrap:
+    main_config: MainConfig = MainConfig()
+
+    deploy_config: DeployConfig = DeployConfig()
+
+    remote_config: RemoteConfig = RemoteConfig()
+
+    system_config: SystemConfig = SystemConfig()
+
+
 ########################################
 # ../commands/local.py
 
@@ -6423,16 +7503,7 @@ class RemoteCommandExecutor(CommandExecutor):
 
 
 ########################################
-# ../system/config.py
-
-
-@dc.dataclass(frozen=True)
-class SystemConfig:
-    platform: ta.Optional[Platform] = None
-
-
-########################################
-# ../../../omlish/lite/asyncio/subprocesses.py
+# ../../../omlish/asyncs/asyncio/subprocesses.py
 
 
 ##
@@ -6443,6 +7514,8 @@ class AsyncioProcessCommunicator:
             self,
             proc: asyncio.subprocess.Process,
             loop: ta.Optional[ta.Any] = None,
+            *,
+            log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
 
@@ -6451,6 +7524,7 @@ class AsyncioProcessCommunicator:
 
         self._proc = proc
         self._loop = loop
+        self._log = log
 
         self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
@@ -6466,19 +7540,19 @@ class AsyncioProcessCommunicator:
         try:
             if input is not None:
                 stdin.write(input)
-                if self._debug:
-                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+                if self._debug and self._log is not None:
+                    self._log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
 
             await stdin.drain()
 
         except (BrokenPipeError, ConnectionResetError) as exc:
             # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
             # exceptions.
-            if self._debug:
-                log.debug('%r communicate: stdin got %r', self, exc)
+            if self._debug and self._log is not None:
+                self._log.debug('%r communicate: stdin got %r', self, exc)
 
-        if self._debug:
-            log.debug('%r communicate: close stdin', self)
+        if self._debug and self._log is not None:
+            self._log.debug('%r communicate: close stdin', self)
 
         stdin.close()
 
@@ -6494,15 +7568,15 @@ class AsyncioProcessCommunicator:
             check.equal(fd, 1)
             stream = check.not_none(self._proc.stdout)
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: read %s', self, name)
+            self._log.debug('%r communicate: read %s', self, name)
 
         output = await stream.read()
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: close %s', self, name)
+            self._log.debug('%r communicate: close %s', self, name)
 
         transport.close()
 
@@ -6551,7 +7625,7 @@ class AsyncioProcessCommunicator:
 ##
 
 
-class AsyncioSubprocesses(AbstractSubprocesses):
+class AsyncioSubprocesses(AbstractAsyncSubprocesses):
     async def communicate(
             self,
             proc: asyncio.subprocess.Process,
@@ -6648,45 +7722,6 @@ class AsyncioSubprocesses(AbstractSubprocesses):
         with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
             return check.not_none((await self.run(*cmd, **kwargs)).stdout)
 
-    async def check_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> str:
-        return (await self.check_output(*cmd, **kwargs)).decode().strip()
-
-    #
-
-    async def try_call(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bool:
-        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
-            return False
-        else:
-            return True
-
-    async def try_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[bytes]:
-        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
-            return None
-        else:
-            return ret
-
-    async def try_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[str]:
-        if (ret := await self.try_output(*cmd, **kwargs)) is None:
-            return None
-        else:
-            return ret.decode().strip()
-
 
 asyncio_subprocesses = AsyncioSubprocesses()
 
@@ -6786,21 +7821,6 @@ class InterpInspector:
 INTERP_INSPECTOR = InterpInspector()
 
 
-########################################
-# ../bootstrap.py
-
-
-@dc.dataclass(frozen=True)
-class MainBootstrap:
-    main_config: MainConfig = MainConfig()
-
-    deploy_config: DeployConfig = DeployConfig()
-
-    remote_config: RemoteConfig = RemoteConfig()
-
-    system_config: SystemConfig = SystemConfig()
-
-
 ########################################
 # ../commands/subprocess.py
 
@@ -6887,39 +7907,22 @@ github.com/wrmsr/omlish@rev
 ##
 
 
-@dc.dataclass(frozen=True)
-class DeployGitRepo:
-    host: ta.Optional[str] = None
-    username: ta.Optional[str] = None
-    path: ta.Optional[str] = None
+class DeployGitManager(DeployPathOwner):
+    def __init__(
+            self,
+            *,
+            deploy_home: ta.Optional[DeployHome] = None,
+    ) -> None:
+        super().__init__()
 
-    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
-
-
-##
-
-
-class DeployGitManager(DeployPathOwner):
-    def __init__(
-            self,
-            *,
-            deploy_home: DeployHome,
-    ) -> None:
-        super().__init__()
-
-        self._deploy_home = deploy_home
-        self._dir = os.path.join(deploy_home, 'git')
+        self._deploy_home = deploy_home
 
         self._repo_dirs: ta.Dict[DeployGitRepo, DeployGitManager.RepoDir] = {}
 
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'git')
+
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
             DeployPath.parse('git'),
@@ -6936,7 +7939,7 @@ class DeployGitManager(DeployPathOwner):
             self._git = git
             self._repo = repo
             self._dir = os.path.join(
-                self._git._dir,  # noqa
+                self._git._dir(),  # noqa
                 check.non_empty_str(repo.host),
                 check.non_empty_str(repo.path),
             )
@@ -6993,8 +7996,8 @@ class DeployGitManager(DeployPathOwner):
             repo_dir = self._repo_dirs[repo] = DeployGitManager.RepoDir(self, repo)
             return repo_dir
 
-    async def checkout(self, spec: DeployGitSpec, dst_dir: str) -> None:
-        await self.get_repo_dir(spec.repo).checkout(spec.rev, dst_dir)
+    async def checkout(self, repo: DeployGitRepo, rev: DeployRev, dst_dir: str) -> None:
+        await self.get_repo_dir(repo).checkout(rev, dst_dir)
 
 
 ########################################
@@ -7010,12 +8013,15 @@ class DeployVenvManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: DeployHome,
+            deploy_home: ta.Optional[DeployHome] = None,
     ) -> None:
         super().__init__()
 
         self._deploy_home = deploy_home
-        self._dir = os.path.join(deploy_home, 'venvs')
+
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'venvs')
 
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
@@ -7052,10 +8058,152 @@ class DeployVenvManager(DeployPathOwner):
 
     async def setup_app_venv(self, app_tag: DeployAppTag) -> None:
         await self.setup_venv(
-            os.path.join(self._deploy_home, 'apps', app_tag.app, app_tag.tag),
-            os.path.join(self._deploy_home, 'venvs', app_tag.app, app_tag.tag),
+            os.path.join(check.non_empty_str(self._deploy_home), 'apps', app_tag.app, app_tag.tag),
+            os.path.join(self._dir(), app_tag.app, app_tag.tag),
+        )
+
+
+########################################
+# ../remote/_main.py
+
+
+##
+
+
+class _RemoteExecutionLogHandler(logging.Handler):
+    def __init__(self, fn: ta.Callable[[str], None]) -> None:
+        super().__init__()
+        self._fn = fn
+
+    def emit(self, record):
+        msg = self.format(record)
+        self._fn(msg)
+
+
+##
+
+
+class _RemoteExecutionMain:
+    def __init__(
+            self,
+            chan: RemoteChannel,
+    ) -> None:
+        super().__init__()
+
+        self._chan = chan
+
+        self.__bootstrap: ta.Optional[MainBootstrap] = None
+        self.__injector: ta.Optional[Injector] = None
+
+    @property
+    def _bootstrap(self) -> MainBootstrap:
+        return check.not_none(self.__bootstrap)
+
+    @property
+    def _injector(self) -> Injector:
+        return check.not_none(self.__injector)
+
+    #
+
+    def _timebomb_main(
+            self,
+            delay_s: float,
+            *,
+            sig: int = signal.SIGINT,
+            code: int = 1,
+    ) -> None:
+        time.sleep(delay_s)
+
+        if (pgid := os.getpgid(0)) == os.getpid():
+            os.killpg(pgid, sig)
+
+        os._exit(code)  # noqa
+
+    @cached_nullary
+    def _timebomb_thread(self) -> ta.Optional[threading.Thread]:
+        if (tbd := self._bootstrap.remote_config.timebomb_delay_s) is None:
+            return None
+
+        thr = threading.Thread(
+            target=functools.partial(self._timebomb_main, tbd),
+            name=f'{self.__class__.__name__}.timebomb',
+            daemon=True,
+        )
+
+        thr.start()
+
+        log.debug('Started timebomb thread: %r', thr)
+
+        return thr
+
+    #
+
+    @cached_nullary
+    def _log_handler(self) -> _RemoteLogHandler:
+        return _RemoteLogHandler(self._chan)
+
+    #
+
+    async def _setup(self) -> None:
+        check.none(self.__bootstrap)
+        check.none(self.__injector)
+
+        # Bootstrap
+
+        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
+
+        if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
+            pycharm_debug_connect(prd)
+
+        self.__injector = main_bootstrap(self._bootstrap)
+
+        self._chan.set_marshaler(self._injector[ObjMarshalerManager])
+
+        # Post-bootstrap
+
+        if self._bootstrap.remote_config.set_pgid:
+            if os.getpgid(0) != os.getpid():
+                log.debug('Setting pgid')
+                os.setpgid(0, 0)
+
+        if (ds := self._bootstrap.remote_config.deathsig) is not None:
+            log.debug('Setting deathsig: %s', ds)
+            set_process_deathsig(int(signal.Signals[f'SIG{ds.upper()}']))
+
+        self._timebomb_thread()
+
+        if self._bootstrap.remote_config.forward_logging:
+            log.debug('Installing log forwarder')
+            logging.root.addHandler(self._log_handler())
+
+    #
+
+    async def run(self) -> None:
+        await self._setup()
+
+        executor = self._injector[LocalCommandExecutor]
+
+        handler = _RemoteCommandHandler(self._chan, executor)
+
+        await handler.run()
+
+
+def _remote_execution_main() -> None:
+    rt = pyremote_bootstrap_finalize()  # noqa
+
+    async def inner() -> None:
+        input = await asyncio_open_stream_reader(rt.input)  # noqa
+        output = await asyncio_open_stream_writer(rt.output)
+
+        chan = RemoteChannelImpl(
+            input,
+            output,
         )
 
+        await _RemoteExecutionMain(chan).run()
+
+    asyncio.run(inner())
+
 
 ########################################
 # ../remote/spawning.py
@@ -7129,12 +8277,8 @@ class SubprocessRemoteSpawning(RemoteSpawning):
     ) -> ta.AsyncGenerator[RemoteSpawning.Spawned, None]:
         pc = self._prepare_cmd(tgt, src)
 
-        cmd = pc.cmd
-        if not debug:
-            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
-
         async with asyncio_subprocesses.popen(
-                *cmd,
+                *pc.cmd,
                 shell=pc.shell,
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
@@ -7456,14 +8600,14 @@ def make_deploy_tag(
         now = datetime.datetime.utcnow()  # noqa
     now_fmt = '%Y%m%dT%H%M%S'
     now_str = now.strftime(now_fmt)
-    return DeployTag('-'.join([rev, now_str]))
+    return DeployTag('-'.join([now_str, rev]))
 
 
 class DeployAppManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: DeployHome,
+            deploy_home: ta.Optional[DeployHome] = None,
             git: DeployGitManager,
             venvs: DeployVenvManager,
     ) -> None:
@@ -7473,7 +8617,9 @@ class DeployAppManager(DeployPathOwner):
         self._git = git
         self._venvs = venvs
 
-        self._dir = os.path.join(deploy_home, 'apps')
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'apps')
 
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
@@ -7482,20 +8628,16 @@ class DeployAppManager(DeployPathOwner):
 
     async def prepare_app(
             self,
-            app: DeployApp,
-            rev: DeployRev,
-            repo: DeployGitRepo,
+            spec: DeploySpec,
     ):
-        app_tag = DeployAppTag(app, make_deploy_tag(rev))
-        app_dir = os.path.join(self._dir, app, app_tag.tag)
+        app_tag = DeployAppTag(spec.app, make_deploy_tag(spec.rev))
+        app_dir = os.path.join(self._dir(), spec.app, app_tag.tag)
 
         #
 
         await self._git.checkout(
-            DeployGitSpec(
-                repo=repo,
-                rev=rev,
-            ),
+            spec.repo,
+            spec.rev,
             app_dir,
         )
 
@@ -7505,145 +8647,122 @@ class DeployAppManager(DeployPathOwner):
 
 
 ########################################
-# ../remote/_main.py
-
-
-##
-
-
-class _RemoteExecutionLogHandler(logging.Handler):
-    def __init__(self, fn: ta.Callable[[str], None]) -> None:
-        super().__init__()
-        self._fn = fn
-
-    def emit(self, record):
-        msg = self.format(record)
-        self._fn(msg)
+# ../remote/connection.py
 
 
 ##
 
 
-class _RemoteExecutionMain:
+class PyremoteRemoteExecutionConnector:
     def __init__(
             self,
-            chan: RemoteChannel,
+            *,
+            spawning: RemoteSpawning,
+            msh: ObjMarshalerManager,
+            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
     ) -> None:
         super().__init__()
 
-        self._chan = chan
-
-        self.__bootstrap: ta.Optional[MainBootstrap] = None
-        self.__injector: ta.Optional[Injector] = None
-
-    @property
-    def _bootstrap(self) -> MainBootstrap:
-        return check.not_none(self.__bootstrap)
-
-    @property
-    def _injector(self) -> Injector:
-        return check.not_none(self.__injector)
+        self._spawning = spawning
+        self._msh = msh
+        self._payload_file = payload_file
 
     #
 
-    def _timebomb_main(
-            self,
-            delay_s: float,
-            *,
-            sig: int = signal.SIGINT,
-            code: int = 1,
-    ) -> None:
-        time.sleep(delay_s)
-
-        if (pgid := os.getpgid(0)) == os.getpid():
-            os.killpg(pgid, sig)
-
-        os._exit(code)  # noqa
-
     @cached_nullary
-    def _timebomb_thread(self) -> ta.Optional[threading.Thread]:
-        if (tbd := self._bootstrap.remote_config.timebomb_delay_s) is None:
-            return None
-
-        thr = threading.Thread(
-            target=functools.partial(self._timebomb_main, tbd),
-            name=f'{self.__class__.__name__}.timebomb',
-            daemon=True,
-        )
-
-        thr.start()
-
-        log.debug('Started timebomb thread: %r', thr)
-
-        return thr
+    def _payload_src(self) -> str:
+        return get_remote_payload_src(file=self._payload_file)
 
-    #
+    @cached_nullary
+    def _remote_src(self) -> ta.Sequence[str]:
+        return [
+            self._payload_src(),
+            '_remote_execution_main()',
+        ]
 
     @cached_nullary
-    def _log_handler(self) -> _RemoteLogHandler:
-        return _RemoteLogHandler(self._chan)
+    def _spawn_src(self) -> str:
+        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
 
     #
 
-    async def _setup(self) -> None:
-        check.none(self.__bootstrap)
-        check.none(self.__injector)
-
-        # Bootstrap
-
-        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
-
-        if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
-            pycharm_debug_connect(prd)
-
-        self.__injector = main_bootstrap(self._bootstrap)
-
-        self._chan.set_marshaler(self._injector[ObjMarshalerManager])
-
-        # Post-bootstrap
+    @contextlib.asynccontextmanager
+    async def connect(
+            self,
+            tgt: RemoteSpawning.Target,
+            bs: MainBootstrap,
+    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        spawn_src = self._spawn_src()
+        remote_src = self._remote_src()
 
-        if self._bootstrap.remote_config.set_pgid:
-            if os.getpgid(0) != os.getpid():
-                log.debug('Setting pgid')
-                os.setpgid(0, 0)
+        async with self._spawning.spawn(
+                tgt,
+                spawn_src,
+                debug=bs.main_config.debug,
+        ) as proc:
+            res = await PyremoteBootstrapDriver(  # noqa
+                remote_src,
+                PyremoteBootstrapOptions(
+                    debug=bs.main_config.debug,
+                ),
+            ).async_run(
+                proc.stdout,
+                proc.stdin,
+            )
 
-        if (ds := self._bootstrap.remote_config.deathsig) is not None:
-            log.debug('Setting deathsig: %s', ds)
-            set_process_deathsig(int(signal.Signals[f'SIG{ds.upper()}']))
+            chan = RemoteChannelImpl(
+                proc.stdout,
+                proc.stdin,
+                msh=self._msh,
+            )
 
-        self._timebomb_thread()
+            await chan.send_obj(bs)
 
-        if self._bootstrap.remote_config.forward_logging:
-            log.debug('Installing log forwarder')
-            logging.root.addHandler(self._log_handler())
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(chan)) as rce:
+                await rce.start()
 
-    #
+                yield rce
 
-    async def run(self) -> None:
-        await self._setup()
 
-        executor = self._injector[LocalCommandExecutor]
+##
 
-        handler = _RemoteCommandHandler(self._chan, executor)
 
-        await handler.run()
+class InProcessRemoteExecutionConnector:
+    def __init__(
+            self,
+            *,
+            msh: ObjMarshalerManager,
+            local_executor: LocalCommandExecutor,
+    ) -> None:
+        super().__init__()
 
+        self._msh = msh
+        self._local_executor = local_executor
 
-def _remote_execution_main() -> None:
-    rt = pyremote_bootstrap_finalize()  # noqa
+    @contextlib.asynccontextmanager
+    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        r0, w0 = asyncio_create_bytes_channel()
+        r1, w1 = asyncio_create_bytes_channel()
 
-    async def inner() -> None:
-        input = await asyncio_open_stream_reader(rt.input)  # noqa
-        output = await asyncio_open_stream_writer(rt.output)
+        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
+        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
 
-        chan = RemoteChannelImpl(
-            input,
-            output,
+        rch = _RemoteCommandHandler(
+            remote_chan,
+            self._local_executor,
         )
+        rch_task = asyncio.create_task(rch.run())  # noqa
+        try:
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
+                await rce.start()
 
-        await _RemoteExecutionMain(chan).run()
+                yield rce
 
-    asyncio.run(inner())
+        finally:
+            rch.stop()
+            await rch_task
 
 
 ########################################
@@ -7977,6 +9096,7 @@ class PyenvVersionInstaller:
             self._version,
         ]
 
+        full_args: ta.List[str]
         if self._given_install_name is not None:
             full_args = [
                 os.path.join(check.not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
@@ -8191,318 +9311,53 @@ class SystemInterpProvider(InterpProvider):
                         continue
                     out.append(name)
 
-        return out
-
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
-
-    #
-
-    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
-        if not self.inspect:
-            s = os.path.basename(exe)
-            if s.startswith('python'):
-                s = s[len('python'):]
-            if '.' in s:
-                try:
-                    return InterpVersion.parse(s)
-                except InvalidVersion:
-                    pass
-        ii = await self.inspector.inspect(exe)
-        return ii.iv if ii is not None else None
-
-    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
-        lst = []
-        for e in self.exes():
-            if (ev := await self.get_exe_version(e)) is None:
-                log.debug('Invalid system version: %s', e)
-                continue
-            lst.append((e, ev))
-        return lst
-
-    #
-
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in await self.exe_versions()]
-
-    async def get_installed_version(self, version: InterpVersion) -> Interp:
-        for e, ev in await self.exe_versions():
-            if ev != version:
-                continue
-            return Interp(
-                exe=e,
-                version=ev,
-            )
-        raise KeyError(version)
-
-
-########################################
-# ../remote/connection.py
-
-
-##
-
-
-class PyremoteRemoteExecutionConnector:
-    def __init__(
-            self,
-            *,
-            spawning: RemoteSpawning,
-            msh: ObjMarshalerManager,
-            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
-    ) -> None:
-        super().__init__()
-
-        self._spawning = spawning
-        self._msh = msh
-        self._payload_file = payload_file
-
-    #
-
-    @cached_nullary
-    def _payload_src(self) -> str:
-        return get_remote_payload_src(file=self._payload_file)
-
-    @cached_nullary
-    def _remote_src(self) -> ta.Sequence[str]:
-        return [
-            self._payload_src(),
-            '_remote_execution_main()',
-        ]
-
-    @cached_nullary
-    def _spawn_src(self) -> str:
-        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
-
-    #
-
-    @contextlib.asynccontextmanager
-    async def connect(
-            self,
-            tgt: RemoteSpawning.Target,
-            bs: MainBootstrap,
-    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        spawn_src = self._spawn_src()
-        remote_src = self._remote_src()
-
-        async with self._spawning.spawn(
-                tgt,
-                spawn_src,
-                debug=bs.main_config.debug,
-        ) as proc:
-            res = await PyremoteBootstrapDriver(  # noqa
-                remote_src,
-                PyremoteBootstrapOptions(
-                    debug=bs.main_config.debug,
-                ),
-            ).async_run(
-                proc.stdout,
-                proc.stdin,
-            )
-
-            chan = RemoteChannelImpl(
-                proc.stdout,
-                proc.stdin,
-                msh=self._msh,
-            )
-
-            await chan.send_obj(bs)
-
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(chan)) as rce:
-                await rce.start()
-
-                yield rce
-
-
-##
-
-
-class InProcessRemoteExecutionConnector:
-    def __init__(
-            self,
-            *,
-            msh: ObjMarshalerManager,
-            local_executor: LocalCommandExecutor,
-    ) -> None:
-        super().__init__()
-
-        self._msh = msh
-        self._local_executor = local_executor
-
-    @contextlib.asynccontextmanager
-    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        r0, w0 = asyncio_create_bytes_channel()
-        r1, w1 = asyncio_create_bytes_channel()
-
-        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
-        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
-
-        rch = _RemoteCommandHandler(
-            remote_chan,
-            self._local_executor,
-        )
-        rch_task = asyncio.create_task(rch.run())  # noqa
-        try:
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
-                await rce.start()
-
-                yield rce
-
-        finally:
-            rch.stop()
-            await rch_task
-
-
-########################################
-# ../system/inject.py
-
-
-def bind_system(
-        *,
-        system_config: SystemConfig,
-) -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind(system_config),
-    ]
-
-    #
-
-    platform = system_config.platform or detect_system_platform()
-    lst.append(inj.bind(platform, key=Platform))
-
-    #
-
-    if isinstance(platform, AmazonLinuxPlatform):
-        lst.extend([
-            inj.bind(YumSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=YumSystemPackageManager),
-        ])
-
-    elif isinstance(platform, LinuxPlatform):
-        lst.extend([
-            inj.bind(AptSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=AptSystemPackageManager),
-        ])
-
-    elif isinstance(platform, DarwinPlatform):
-        lst.extend([
-            inj.bind(BrewSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=BrewSystemPackageManager),
-        ])
-
-    #
-
-    lst.extend([
-        bind_command(CheckSystemPackageCommand, CheckSystemPackageCommandExecutor),
-    ])
-
-    #
-
-    return inj.as_bindings(*lst)
-
-
-########################################
-# ../../../omdev/interp/resolvers.py
-
-
-INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
-    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
-}
-
-
-class InterpResolver:
-    def __init__(
-            self,
-            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
-    ) -> None:
-        super().__init__()
-
-        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
-
-    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
-        lst = [
-            (i, si)
-            for i, p in enumerate(self._providers.values())
-            for si in await p.get_installed_versions(spec)
-            if spec.contains(si)
-        ]
-
-        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
-        if not slst:
-            return None
-
-        bi, bv = slst[-1]
-        bp = list(self._providers.values())[bi]
-        return (bp, bv)
-
-    async def resolve(
-            self,
-            spec: InterpSpecifier,
-            *,
-            install: bool = False,
-    ) -> ta.Optional[Interp]:
-        tup = await self._resolve_installed(spec)
-        if tup is not None:
-            bp, bv = tup
-            return await bp.get_installed_version(bv)
-
-        if not install:
-            return None
-
-        tp = list(self._providers.values())[0]  # noqa
-
-        sv = sorted(
-            [s for s in await tp.get_installable_versions(spec) if s in spec],
-            key=lambda s: s.version,
-        )
-        if not sv:
-            return None
-
-        bv = sv[-1]
-        return await tp.install_version(bv)
-
-    async def list(self, spec: InterpSpecifier) -> None:
-        print('installed:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installed_versions(spec)
-                if spec.contains(si)
-            ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
-
-        print()
+        return out
 
-        print('installable:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installable_versions(spec)
-                if spec.contains(si)
-            ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self.path,
+        )
 
+    #
 
-DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
-    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
-    PyenvInterpProvider(try_update=True),
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self.inspect:
+            s = os.path.basename(exe)
+            if s.startswith('python'):
+                s = s[len('python'):]
+            if '.' in s:
+                try:
+                    return InterpVersion.parse(s)
+                except InvalidVersion:
+                    pass
+        ii = await self.inspector.inspect(exe)
+        return ii.iv if ii is not None else None
 
-    RunningInterpProvider(),
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+        lst = []
+        for e in self.exes():
+            if (ev := await self.get_exe_version(e)) is None:
+                log.debug('Invalid system version: %s', e)
+                continue
+            lst.append((e, ev))
+        return lst
 
-    SystemInterpProvider(),
-]])
+    #
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
+
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in await self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)
 
 
 ########################################
@@ -8533,6 +9388,54 @@ def bind_remote(
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../system/inject.py
+
+
+def bind_system(
+        *,
+        system_config: SystemConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(system_config),
+    ]
+
+    #
+
+    platform = system_config.platform or detect_system_platform()
+    lst.append(inj.bind(platform, key=Platform))
+
+    #
+
+    if isinstance(platform, AmazonLinuxPlatform):
+        lst.extend([
+            inj.bind(YumSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=YumSystemPackageManager),
+        ])
+
+    elif isinstance(platform, LinuxPlatform):
+        lst.extend([
+            inj.bind(AptSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=AptSystemPackageManager),
+        ])
+
+    elif isinstance(platform, DarwinPlatform):
+        lst.extend([
+            inj.bind(BrewSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=BrewSystemPackageManager),
+        ])
+
+    #
+
+    lst.extend([
+        bind_command(CheckSystemPackageCommand, CheckSystemPackageCommandExecutor),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # ../targets/connection.py
 
@@ -8668,33 +9571,101 @@ class SshManageTargetConnector(ManageTargetConnector):
 
 
 ########################################
-# ../deploy/interp.py
+# ../../../omdev/interp/resolvers.py
 
 
-##
+INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
+    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
+}
 
 
-@dc.dataclass(frozen=True)
-class InterpCommand(Command['InterpCommand.Output']):
-    spec: str
-    install: bool = False
+class InterpResolver:
+    def __init__(
+            self,
+            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
+    ) -> None:
+        super().__init__()
 
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        exe: str
-        version: str
-        opts: InterpOpts
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
+    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
+        lst = [
+            (i, si)
+            for i, p in enumerate(self._providers.values())
+            for si in await p.get_installed_versions(spec)
+            if spec.contains(si)
+        ]
 
-class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
-    async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
-        i = InterpSpecifier.parse(check.not_none(cmd.spec))
-        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
-        return InterpCommand.Output(
-            exe=o.exe,
-            version=str(o.version.version),
-            opts=o.version.opts,
+        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
+        if not slst:
+            return None
+
+        bi, bv = slst[-1]
+        bp = list(self._providers.values())[bi]
+        return (bp, bv)
+
+    async def resolve(
+            self,
+            spec: InterpSpecifier,
+            *,
+            install: bool = False,
+    ) -> ta.Optional[Interp]:
+        tup = await self._resolve_installed(spec)
+        if tup is not None:
+            bp, bv = tup
+            return await bp.get_installed_version(bv)
+
+        if not install:
+            return None
+
+        tp = list(self._providers.values())[0]  # noqa
+
+        sv = sorted(
+            [s for s in await tp.get_installable_versions(spec) if s in spec],
+            key=lambda s: s.version,
         )
+        if not sv:
+            return None
+
+        bv = sv[-1]
+        return await tp.install_version(bv)
+
+    async def list(self, spec: InterpSpecifier) -> None:
+        print('installed:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installed_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+        print()
+
+        print('installable:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installable_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+
+DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
+    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
+    PyenvInterpProvider(try_update=True),
+
+    RunningInterpProvider(),
+
+    SystemInterpProvider(),
+]])
 
 
 ########################################
@@ -8726,6 +9697,36 @@ def bind_targets() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../deploy/interp.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InterpCommand(Command['InterpCommand.Output']):
+    spec: str
+    install: bool = False
+
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        exe: str
+        version: str
+        opts: InterpOpts
+
+
+class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
+    async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
+        i = InterpSpecifier.parse(check.not_none(cmd.spec))
+        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        return InterpCommand.Output(
+            exe=o.exe,
+            version=str(o.version.version),
+            opts=o.version.opts,
+        )
+
+
 ########################################
 # ../deploy/inject.py
 
@@ -8842,7 +9843,28 @@ def main_bootstrap(bs: MainBootstrap) -> Injector:
 # main.py
 
 
+@dc.dataclass(frozen=True)
+class ManageConfig:
+    targets: ta.Optional[ta.Mapping[str, ManageTarget]] = None
+
+
 class MainCli(ArgparseCli):
+    config_file: ta.Optional[str] = argparse_arg('--config-file', help='Config file path')  # type: ignore
+
+    @cached_nullary
+    def config(self) -> ManageConfig:
+        if (cf := self.config_file) is None:
+            cf = os.path.expanduser('~/.omlish/manage.yml')
+            if not os.path.isfile(cf):
+                cf = None
+
+        if cf is None:
+            return ManageConfig()
+        else:
+            return read_config_file(cf, ManageConfig)
+
+    #
+
     @argparse_command(
         argparse_arg('--_payload-file'),
 
@@ -8894,10 +9916,13 @@ class MainCli(ArgparseCli):
 
         msh = injector[ObjMarshalerManager]
 
-        ts = self.args.target
-        if not ts.startswith('{'):
-            ts = json.dumps({ts: {}})
-        tgt: ManageTarget = msh.unmarshal_obj(json.loads(ts), ManageTarget)
+        tgt: ManageTarget
+        if not (ts := self.args.target).startswith('{'):
+            tgt = check.not_none(self.config().targets)[ts]
+        else:
+            tgt = msh.unmarshal_obj(json.loads(ts), ManageTarget)
+
+        #
 
         cmds: ta.List[Command] = []
         cmd: Command