ominfra 0.0.0.dev178__py3-none-any.whl → 0.0.0.dev180__py3-none-any.whl

ominfra/scripts/manage.py

@@ -111,7 +111,7 @@ CommandT = ta.TypeVar('CommandT', bound='Command')
 CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 
 # ../../omlish/argparse/cli.py
-ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
+ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
 # ../../omlish/lite/contextmanagers.py
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
@@ -2766,21 +2766,6 @@ def read_package_resource_text(package: str, resource: str) -> str:
     return importlib.resources.read_text(package, resource)
 
 
-########################################
-# ../../../omlish/lite/shlex.py
-
-
-def shlex_needs_quote(s: str) -> bool:
-    return bool(s) and len(list(shlex.shlex(s))) > 1
-
-
-def shlex_maybe_quote(s: str) -> str:
-    if shlex_needs_quote(s):
-        return shlex.quote(s)
-    else:
-        return s
-
-
 ########################################
 # ../../../omlish/lite/strings.py
 
@@ -3580,6 +3565,21 @@ def relative_symlink(
     )
 
 
+########################################
+# ../../../omlish/shlex.py
+
+
+def shlex_needs_quote(s: str) -> bool:
+    return bool(s) and len(list(shlex.shlex(s))) > 1
+
+
+def shlex_maybe_quote(s: str) -> str:
+    if shlex_needs_quote(s):
+        return shlex.quote(s)
+    else:
+        return s
+
+
 ########################################
 # ../../../omdev/packaging/specifiers.py
 # Copyright (c) Donald Stufft and individual contributors.
@@ -4546,15 +4546,15 @@ def argparse_arg(*args, **kwargs) -> ArgparseArg:
 
 
 @dc.dataclass(eq=False)
-class ArgparseCommand:
+class ArgparseCmd:
     name: str
-    fn: ArgparseCommandFn
+    fn: ArgparseCmdFn
     args: ta.Sequence[ArgparseArg] = ()  # noqa
 
     # _: dc.KW_ONLY
 
     aliases: ta.Optional[ta.Sequence[str]] = None
-    parent: ta.Optional['ArgparseCommand'] = None
+    parent: ta.Optional['ArgparseCmd'] = None
     accepts_unknown: bool = False
 
     def __post_init__(self) -> None:
@@ -4569,7 +4569,7 @@ class ArgparseCommand:
 
         check.arg(callable(self.fn))
         check.arg(all(isinstance(a, ArgparseArg) for a in self.args))
-        check.isinstance(self.parent, (ArgparseCommand, type(None)))
+        check.isinstance(self.parent, (ArgparseCmd, type(None)))
         check.isinstance(self.accepts_unknown, bool)
 
         functools.update_wrapper(self, self.fn)
@@ -4583,21 +4583,21 @@ class ArgparseCommand:
         return self.fn(*args, **kwargs)
 
 
-def argparse_command(
+def argparse_cmd(
         *args: ArgparseArg,
         name: ta.Optional[str] = None,
         aliases: ta.Optional[ta.Iterable[str]] = None,
-        parent: ta.Optional[ArgparseCommand] = None,
+        parent: ta.Optional[ArgparseCmd] = None,
         accepts_unknown: bool = False,
-) -> ta.Any:  # ta.Callable[[ArgparseCommandFn], ArgparseCommand]:  # FIXME
+) -> ta.Any:  # ta.Callable[[ArgparseCmdFn], ArgparseCmd]:  # FIXME
     for arg in args:
         check.isinstance(arg, ArgparseArg)
     check.isinstance(name, (str, type(None)))
-    check.isinstance(parent, (ArgparseCommand, type(None)))
+    check.isinstance(parent, (ArgparseCmd, type(None)))
     check.not_isinstance(aliases, str)
 
     def inner(fn):
-        return ArgparseCommand(
+        return ArgparseCmd(
             (name if name is not None else fn.__name__).replace('_', '-'),
             fn,
             args,
@@ -4652,7 +4652,7 @@ class ArgparseCli:
         for bns in [bcls.__dict__ for bcls in reversed(mro)] + [ns]:
             bseen = set()  # type: ignore
             for k, v in bns.items():
-                if isinstance(v, (ArgparseCommand, ArgparseArg)):
+                if isinstance(v, (ArgparseCmd, ArgparseArg)):
                     check.not_in(v, bseen)
                     bseen.add(v)
                     objs[k] = v
@@ -4679,7 +4679,7 @@ class ArgparseCli:
         subparsers = parser.add_subparsers()
 
         for att, obj in objs.items():
-            if isinstance(obj, ArgparseCommand):
+            if isinstance(obj, ArgparseCmd):
                 if obj.parent is not None:
                     raise NotImplementedError
 
@@ -4741,7 +4741,7 @@ class ArgparseCli:
 
     #
 
-    def _bind_cli_cmd(self, cmd: ArgparseCommand) -> ta.Callable:
+    def _bind_cli_cmd(self, cmd: ArgparseCmd) -> ta.Callable:
         return cmd.__get__(self, type(self))
 
     def prepare_cli_run(self) -> ta.Optional[ta.Callable]:
@@ -5126,30 +5126,6 @@ def as_injector_bindings(*args: InjectorBindingOrBindings) -> InjectorBindings:
 ##
 
 
-@dc.dataclass(frozen=True)
-class OverridesInjectorBindings(InjectorBindings):
-    p: InjectorBindings
-    m: ta.Mapping[InjectorKey, InjectorBinding]
-
-    def bindings(self) -> ta.Iterator[InjectorBinding]:
-        for b in self.p.bindings():
-            yield self.m.get(b.key, b)
-
-
-def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
-    m: ta.Dict[InjectorKey, InjectorBinding] = {}
-
-    for b in as_injector_bindings(*args).bindings():
-        if b.key in m:
-            raise DuplicateInjectorKeyError(b.key)
-        m[b.key] = b
-
-    return OverridesInjectorBindings(p, m)
-
-
-##
-
-
 def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey, InjectorProvider]:
     pm: ta.Dict[InjectorKey, InjectorProvider] = {}
     am: ta.Dict[InjectorKey, ta.List[InjectorProvider]] = {}
@@ -5173,6 +5149,31 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
     return pm
 
 
+###
+# overrides
+
+
+@dc.dataclass(frozen=True)
+class OverridesInjectorBindings(InjectorBindings):
+    p: InjectorBindings
+    m: ta.Mapping[InjectorKey, InjectorBinding]
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        for b in self.p.bindings():
+            yield self.m.get(b.key, b)
+
+
+def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    m: ta.Dict[InjectorKey, InjectorBinding] = {}
+
+    for b in as_injector_bindings(*args).bindings():
+        if b.key in m:
+            raise DuplicateInjectorKeyError(b.key)
+        m[b.key] = b
+
+    return OverridesInjectorBindings(p, m)
+
+
 ###
 # scopes
 
@@ -5197,7 +5198,7 @@ class InjectorScope(abc.ABC):  # noqa
     @dc.dataclass(frozen=True)
     class State:
         seeds: ta.Dict[InjectorKey, ta.Any]
-        prvs: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
+        provisions: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
 
     def new_state(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> State:
         vs = dict(vs)
@@ -5277,11 +5278,11 @@ class ScopedInjectorProvider(InjectorProvider):
         def pfn(i: Injector) -> ta.Any:
             st = i[self.sc].state()
             try:
-                return st.prvs[self.k]
+                return st.provisions[self.k]
             except KeyError:
                 pass
             v = ufn(i)
-            st.prvs[self.k] = v
+            st.provisions[self.k] = v
             return v
 
         ufn = self.p.provider_fn()
@@ -5305,9 +5306,7 @@ class _ScopeSeedInjectorProvider(InjectorProvider):
 
 
 def bind_injector_scope(sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
-    return as_injector_bindings(
-        InjectorBinder.bind(sc, singleton=True),
-    )
+    return InjectorBinder.bind(sc, singleton=True)
 
 
 #
@@ -5847,6 +5846,8 @@ class InjectionApi:
     def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return as_injector_bindings(*args)
 
+    # overrides
+
     def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
@@ -6705,6 +6706,9 @@ class TempDirAtomicPathSwapping(AtomicPathSwapping):
 # ../../../omdev/interp/types.py
 
 
+##
+
+
 # See https://peps.python.org/pep-3149/
 INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
     ('debug', 'd'),
@@ -6736,6 +6740,9 @@ class InterpOpts:
         return s, cls(**kw)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpVersion:
     version: Version
@@ -6761,6 +6768,9 @@ class InterpVersion:
             return None
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class InterpSpecifier:
     specifier: Specifier
@@ -6788,12 +6798,25 @@ class InterpSpecifier:
         return self.contains(iv)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class Interp:
     exe: str
     version: InterpVersion
 
 
+########################################
+# ../../../omdev/interp/uv/inject.py
+
+
+def bind_interp_uv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = []
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # ../../configs.py
 
@@ -7707,6 +7730,50 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return ret.decode().strip()
 
 
+########################################
+# ../../../omdev/interp/providers/base.py
+"""
+TODO:
+ - backends
+  - local builds
+  - deadsnakes?
+  - uv
+ - loose versions
+"""
+
+
+##
+
+
+class InterpProvider(abc.ABC):
+    name: ta.ClassVar[str]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
+            sfx = 'InterpProvider'
+            if not cls.__name__.endswith(sfx):
+                raise NameError(cls)
+            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
+
+    @abc.abstractmethod
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
+        raise NotImplementedError
+
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return []
+
+    async def install_version(self, version: InterpVersion) -> Interp:
+        raise TypeError
+
+
+InterpProviders = ta.NewType('InterpProviders', ta.Sequence[InterpProvider])
+
+
 ########################################
 # ../bootstrap.py
 
@@ -8841,7 +8908,92 @@ class InterpInspector:
             return ret
 
 
-INTERP_INSPECTOR = InterpInspector()
+########################################
+# ../../../omdev/interp/resolvers.py
+
+
+@dc.dataclass(frozen=True)
+class InterpResolverProviders:
+    providers: ta.Sequence[ta.Tuple[str, InterpProvider]]
+
+
+class InterpResolver:
+    def __init__(
+            self,
+            providers: InterpResolverProviders,
+    ) -> None:
+        super().__init__()
+
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers.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()
+
+        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}')
 
 
 ########################################
@@ -9495,929 +9647,937 @@ class YumSystemPackageManager(SystemPackageManager):
 
 
 ########################################
-# ../../../omdev/interp/providers.py
+# ../../../omdev/interp/providers/running.py
+
+
+class RunningInterpProvider(InterpProvider):
+    @cached_nullary
+    def version(self) -> InterpVersion:
+        return InterpInspector.running().iv
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [self.version()]
+
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        if version != self.version():
+            raise KeyError(version)
+        return Interp(
+            exe=sys.executable,
+            version=self.version(),
+        )
+
+
+########################################
+# ../../../omdev/interp/providers/system.py
 """
 TODO:
- - backends
-  - local builds
-  - deadsnakes?
-  - uv
- - loose versions
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
 """
 
 
 ##
 
 
-class InterpProvider(abc.ABC):
-    name: ta.ClassVar[str]
+class SystemInterpProvider(InterpProvider):
+    @dc.dataclass(frozen=True)
+    class Options:
+        cmd: str = 'python3'  # FIXME: unused lol
+        path: ta.Optional[str] = None
 
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        super().__init_subclass__(**kwargs)
-        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
-            sfx = 'InterpProvider'
-            if not cls.__name__.endswith(sfx):
-                raise NameError(cls)
-            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
-
-    @abc.abstractmethod
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
-        raise NotImplementedError
-
-    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return []
-
-    async def install_version(self, version: InterpVersion) -> Interp:
-        raise TypeError
+        inspect: bool = False
 
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            inspector: ta.Optional[InterpInspector] = None,
+    ) -> None:
+        super().__init__()
 
-##
+        self._options = options
 
+        self._inspector = inspector
 
-class RunningInterpProvider(InterpProvider):
-    @cached_nullary
-    def version(self) -> InterpVersion:
-        return InterpInspector.running().iv
+    #
 
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [self.version()]
+    @staticmethod
+    def _re_which(
+            pat: re.Pattern,
+            *,
+            mode: int = os.F_OK | os.X_OK,
+            path: ta.Optional[str] = None,
+    ) -> ta.List[str]:
+        if path is None:
+            path = os.environ.get('PATH', None)
+            if path is None:
+                try:
+                    path = os.confstr('CS_PATH')
+                except (AttributeError, ValueError):
+                    path = os.defpath
 
-    async def get_installed_version(self, version: InterpVersion) -> Interp:
-        if version != self.version():
-            raise KeyError(version)
-        return Interp(
-            exe=sys.executable,
-            version=self.version(),
-        )
+        if not path:
+            return []
 
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
 
-########################################
-# ../commands/inject.py
+        def _access_check(fn: str, mode: int) -> bool:
+            return os.path.exists(fn) and os.access(fn, mode)
 
+        out = []
+        seen = set()
+        for d in pathlst:
+            normdir = os.path.normcase(d)
+            if normdir not in seen:
+                seen.add(normdir)
+                if not _access_check(normdir, mode):
+                    continue
+                for thefile in os.listdir(d):
+                    name = os.path.join(d, thefile)
+                    if not (
+                            os.path.isfile(name) and
+                            pat.fullmatch(thefile) and
+                            _access_check(name, mode)
+                    ):
+                        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._options.path,
+        )
 
-def bind_command(
-        command_cls: ta.Type[Command],
-        executor_cls: ta.Optional[ta.Type[CommandExecutor]],
-) -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind(CommandRegistration(command_cls), array=True),
-    ]
+    #
 
-    if executor_cls is not None:
-        lst.extend([
-            inj.bind(executor_cls, singleton=True),
-            inj.bind(CommandExecutorRegistration(command_cls, executor_cls), array=True),
-        ])
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self._options.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 check.not_none(self._inspector).inspect(exe)
+        return ii.iv if ii is not None else None
 
-    return inj.as_bindings(*lst)
+    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)
 
-@dc.dataclass(frozen=True)
-class _FactoryCommandExecutor(CommandExecutor):
-    factory: ta.Callable[[], CommandExecutor]
 
-    def execute(self, i: Command) -> ta.Awaitable[Command.Output]:
-        return self.factory().execute(i)
+########################################
+# ../../../omdev/interp/pyenv/pyenv.py
+"""
+TODO:
+ - custom tags
+  - 'aliases'
+  - https://github.com/pyenv/pyenv/pull/2966
+  - https://github.com/pyenv/pyenv/issues/218 (lol)
+  - probably need custom (temp?) definition file
+  - *or* python-build directly just into the versions dir?
+ - optionally install / upgrade pyenv itself
+ - new vers dont need these custom mac opts, only run on old vers
+"""
 
 
 ##
 
 
-def bind_commands(
-        *,
-        main_config: MainConfig,
-) -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind_array(CommandRegistration),
-        inj.bind_array_type(CommandRegistration, CommandRegistrations),
-
-        inj.bind_array(CommandExecutorRegistration),
-        inj.bind_array_type(CommandExecutorRegistration, CommandExecutorRegistrations),
-
-        inj.bind(build_command_name_map, singleton=True),
-    ]
-
-    #
-
-    def provide_obj_marshaler_installer(cmds: CommandNameMap) -> ObjMarshalerInstaller:
-        return ObjMarshalerInstaller(functools.partial(install_command_marshaling, cmds))
-
-    lst.append(inj.bind(provide_obj_marshaler_installer, array=True))
-
-    #
-
-    def provide_command_executor_map(
-            injector: Injector,
-            crs: CommandExecutorRegistrations,
-    ) -> CommandExecutorMap:
-        dct: ta.Dict[ta.Type[Command], CommandExecutor] = {}
-
-        cr: CommandExecutorRegistration
-        for cr in crs:
-            if cr.command_cls in dct:
-                raise KeyError(cr.command_cls)
-
-            factory = functools.partial(injector.provide, cr.executor_cls)
-            if main_config.debug:
-                ce = factory()
-            else:
-                ce = _FactoryCommandExecutor(factory)
+class Pyenv:
+    def __init__(
+            self,
+            *,
+            root: ta.Optional[str] = None,
+    ) -> None:
+        if root is not None and not (isinstance(root, str) and root):
+            raise ValueError(f'pyenv_root: {root!r}')
 
-            dct[cr.command_cls] = ce
+        super().__init__()
 
-        return CommandExecutorMap(dct)
+        self._root_kw = root
 
-    lst.extend([
-        inj.bind(provide_command_executor_map, singleton=True),
+    @async_cached_nullary
+    async def root(self) -> ta.Optional[str]:
+        if self._root_kw is not None:
+            return self._root_kw
 
-        inj.bind(LocalCommandExecutor, singleton=True, eager=main_config.debug),
-    ])
+        if shutil.which('pyenv'):
+            return await asyncio_subprocesses.check_output_str('pyenv', 'root')
 
-    #
+        d = os.path.expanduser('~/.pyenv')
+        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
+            return d
 
-    lst.extend([
-        bind_command(PingCommand, PingCommandExecutor),
-        bind_command(SubprocessCommand, SubprocessCommandExecutor),
-    ])
+        return None
 
-    #
+    @async_cached_nullary
+    async def exe(self) -> str:
+        return os.path.join(check.not_none(await self.root()), 'bin', 'pyenv')
 
-    return inj.as_bindings(*lst)
+    async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
+        if (root := await self.root()) is None:
+            return []
+        ret = []
+        vp = os.path.join(root, 'versions')
+        if os.path.isdir(vp):
+            for dn in os.listdir(vp):
+                ep = os.path.join(vp, dn, 'bin', 'python')
+                if not os.path.isfile(ep):
+                    continue
+                ret.append((dn, ep))
+        return ret
 
+    async def installable_versions(self) -> ta.List[str]:
+        if await self.root() is None:
+            return []
+        ret = []
+        s = await asyncio_subprocesses.check_output_str(await self.exe(), 'install', '--list')
+        for l in s.splitlines():
+            if not l.startswith('  '):
+                continue
+            l = l.strip()
+            if not l:
+                continue
+            ret.append(l)
+        return ret
 
-########################################
-# ../deploy/paths/manager.py
+    async def update(self) -> bool:
+        if (root := await self.root()) is None:
+            return False
+        if not os.path.isdir(os.path.join(root, '.git')):
+            return False
+        await asyncio_subprocesses.check_call('git', 'pull', cwd=root)
+        return True
 
 
-class DeployPathsManager:
-    def __init__(
-            self,
-            *,
-            deploy_path_owners: DeployPathOwners,
-    ) -> None:
-        super().__init__()
+##
 
-        self._deploy_path_owners = deploy_path_owners
 
-    @cached_nullary
-    def owners_by_path(self) -> ta.Mapping[DeployPath, DeployPathOwner]:
-        dct: ta.Dict[DeployPath, DeployPathOwner] = {}
-        for o in self._deploy_path_owners:
-            for p in o.get_owned_deploy_paths():
-                if p in dct:
-                    raise DeployPathError(f'Duplicate deploy path owner: {p}')
-                dct[p] = o
-        return dct
+@dc.dataclass(frozen=True)
+class PyenvInstallOpts:
+    opts: ta.Sequence[str] = ()
+    conf_opts: ta.Sequence[str] = ()
+    cflags: ta.Sequence[str] = ()
+    ldflags: ta.Sequence[str] = ()
+    env: ta.Mapping[str, str] = dc.field(default_factory=dict)
 
-    def validate_deploy_paths(self) -> None:
-        self.owners_by_path()
+    def merge(self, *others: 'PyenvInstallOpts') -> 'PyenvInstallOpts':
+        return PyenvInstallOpts(
+            opts=list(itertools.chain.from_iterable(o.opts for o in [self, *others])),
+            conf_opts=list(itertools.chain.from_iterable(o.conf_opts for o in [self, *others])),
+            cflags=list(itertools.chain.from_iterable(o.cflags for o in [self, *others])),
+            ldflags=list(itertools.chain.from_iterable(o.ldflags for o in [self, *others])),
+            env=dict(itertools.chain.from_iterable(o.env.items() for o in [self, *others])),
+        )
 
 
-########################################
-# ../deploy/tmp.py
+# TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
+DEFAULT_PYENV_INSTALL_OPTS = PyenvInstallOpts(
+    opts=[
+        '-s',
+        '-v',
+        '-k',
+    ],
+    conf_opts=[
+        # FIXME: breaks on mac for older py's
+        '--enable-loadable-sqlite-extensions',
 
+        # '--enable-shared',
 
-class DeployHomeAtomics(Func1[DeployHome, AtomicPathSwapping]):
-    pass
+        '--enable-optimizations',
+        '--with-lto',
 
+        # '--enable-profiling', # ?
 
-class DeployTmpManager(
-    SingleDirDeployPathOwner,
-):
-    def __init__(self) -> None:
-        super().__init__(
-            owned_dir='tmp',
-        )
+        # '--enable-ipv6', # ?
+    ],
+    cflags=[
+        # '-march=native',
+        # '-mtune=native',
+    ],
+)
 
-    def get_swapping(self, home: DeployHome) -> AtomicPathSwapping:
-        return TempDirAtomicPathSwapping(
-            temp_dir=self._make_dir(home),
-            root_dir=check.non_empty_str(home),
-        )
+DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
 
+THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 
-########################################
-# ../remote/connection.py
 
+#
 
-##
 
+class PyenvInstallOptsProvider(abc.ABC):
+    @abc.abstractmethod
+    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
+        raise NotImplementedError
 
-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
+class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts()
 
-    #
 
+class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
     @cached_nullary
-    def _payload_src(self) -> str:
-        return get_remote_payload_src(file=self._payload_file)
+    def framework_opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts(conf_opts=['--enable-framework'])
 
     @cached_nullary
-    def _remote_src(self) -> ta.Sequence[str]:
-        return [
-            self._payload_src(),
-            '_remote_execution_main()',
-        ]
+    def has_brew(self) -> bool:
+        return shutil.which('brew') is not None
 
-    @cached_nullary
-    def _spawn_src(self) -> str:
-        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
+    BREW_DEPS: ta.Sequence[str] = [
+        'openssl',
+        'readline',
+        'sqlite3',
+        'zlib',
+    ]
 
-    #
+    @async_cached_nullary
+    async def brew_deps_opts(self) -> PyenvInstallOpts:
+        cflags = []
+        ldflags = []
+        for dep in self.BREW_DEPS:
+            dep_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', dep)
+            cflags.append(f'-I{dep_prefix}/include')
+            ldflags.append(f'-L{dep_prefix}/lib')
+        return PyenvInstallOpts(
+            cflags=cflags,
+            ldflags=ldflags,
+        )
 
-    @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_cached_nullary
+    async def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if await asyncio_subprocesses.try_output('brew', '--prefix', 'tcl-tk') is None:
+            return PyenvInstallOpts()
 
-        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,
-            )
+        tcl_tk_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', 'tcl-tk')
+        tcl_tk_ver_str = await asyncio_subprocesses.check_output_str('brew', 'ls', '--versions', 'tcl-tk')
+        tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
 
-            chan = RemoteChannelImpl(
-                proc.stdout,
-                proc.stdin,
-                msh=self._msh,
-            )
+        return PyenvInstallOpts(conf_opts=[
+            f"--with-tcltk-includes='-I{tcl_tk_prefix}/include'",
+            f"--with-tcltk-libs='-L{tcl_tk_prefix}/lib -ltcl{tcl_tk_ver} -ltk{tcl_tk_ver}'",
+        ])
+
+    # @cached_nullary
+    # def brew_ssl_opts(self) -> PyenvInstallOpts:
+    #     pkg_config_path = subprocess_check_output_str('brew', '--prefix', 'openssl')
+    #     if 'PKG_CONFIG_PATH' in os.environ:
+    #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
+    #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
 
-            await chan.send_obj(bs)
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts().merge(
+            self.framework_opts(),
+            await self.brew_deps_opts(),
+            await self.brew_tcl_opts(),
+            # self.brew_ssl_opts(),
+        )
 
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(chan)) as rce:
-                await rce.start()
 
-                yield rce
+PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
+    'darwin': DarwinPyenvInstallOpts(),
+    'linux': LinuxPyenvInstallOpts(),
+}
 
 
 ##
 
 
-class InProcessRemoteExecutionConnector:
+class PyenvVersionInstaller:
+    """
+    Messy: can install freethreaded build with a 't' suffixed version str _or_ by THREADED_PYENV_INSTALL_OPTS - need
+    latter to build custom interp with ft, need former to use canned / blessed interps. Muh.
+    """
+
     def __init__(
             self,
+            version: str,
+            opts: ta.Optional[PyenvInstallOpts] = None,
+            interp_opts: InterpOpts = InterpOpts(),
             *,
-            msh: ObjMarshalerManager,
-            local_executor: LocalCommandExecutor,
+            pyenv: Pyenv,
+
+            install_name: ta.Optional[str] = None,
+            no_default_opts: bool = False,
     ) -> None:
         super().__init__()
 
-        self._msh = msh
-        self._local_executor = local_executor
+        self._version = version
+        self._given_opts = opts
+        self._interp_opts = interp_opts
+        self._given_install_name = install_name
 
-    @contextlib.asynccontextmanager
-    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        r0, w0 = asyncio_create_bytes_channel()
-        r1, w1 = asyncio_create_bytes_channel()
+        self._no_default_opts = no_default_opts
+        self._pyenv = pyenv
 
-        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
-        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
+    @property
+    def version(self) -> str:
+        return self._version
 
-        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()
+    @async_cached_nullary
+    async def opts(self) -> PyenvInstallOpts:
+        opts = self._given_opts
+        if self._no_default_opts:
+            if opts is None:
+                opts = PyenvInstallOpts()
+        else:
+            lst = [self._given_opts if self._given_opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
+            if self._interp_opts.debug:
+                lst.append(DEBUG_PYENV_INSTALL_OPTS)
+            if self._interp_opts.threaded:
+                lst.append(THREADED_PYENV_INSTALL_OPTS)
+            lst.append(await PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
+            opts = PyenvInstallOpts().merge(*lst)
+        return opts
 
-                yield rce
+    @cached_nullary
+    def install_name(self) -> str:
+        if self._given_install_name is not None:
+            return self._given_install_name
+        return self._version + ('-debug' if self._interp_opts.debug else '')
 
-        finally:
-            rch.stop()
-            await rch_task
+    @async_cached_nullary
+    async def install_dir(self) -> str:
+        return str(os.path.join(check.not_none(await self._pyenv.root()), 'versions', self.install_name()))
+
+    @async_cached_nullary
+    async def install(self) -> str:
+        opts = await self.opts()
+        env = {**os.environ, **opts.env}
+        for k, l in [
+            ('CFLAGS', opts.cflags),
+            ('LDFLAGS', opts.ldflags),
+            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
+        ]:
+            v = ' '.join(l)
+            if k in os.environ:
+                v += ' ' + os.environ[k]
+            env[k] = v
 
+        conf_args = [
+            *opts.opts,
+            self._version,
+        ]
 
-########################################
-# ../system/commands.py
+        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
+                *conf_args,
+                await self.install_dir(),
+            ]
+        else:
+            full_args = [
+                await self._pyenv.exe(),
+                'install',
+                *conf_args,
+            ]
 
+        await asyncio_subprocesses.check_call(
+            *full_args,
+            env=env,
+        )
 
-##
+        exe = os.path.join(await self.install_dir(), 'bin', 'python')
+        if not os.path.isfile(exe):
+            raise RuntimeError(f'Interpreter not found: {exe}')
+        return exe
 
 
-@dc.dataclass(frozen=True)
-class CheckSystemPackageCommand(Command['CheckSystemPackageCommand.Output']):
-    pkgs: ta.Sequence[str] = ()
+##
 
-    def __post_init__(self) -> None:
-        check.not_isinstance(self.pkgs, str)
 
+class PyenvInterpProvider(InterpProvider):
     @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        pkgs: ta.Sequence[SystemPackage]
+    class Options:
+        inspect: bool = False
 
+        try_update: bool = False
 
-class CheckSystemPackageCommandExecutor(CommandExecutor[CheckSystemPackageCommand, CheckSystemPackageCommand.Output]):
     def __init__(
             self,
+            options: Options = Options(),
             *,
-            mgr: SystemPackageManager,
+            pyenv: Pyenv,
+            inspector: InterpInspector,
     ) -> None:
         super().__init__()
 
-        self._mgr = mgr
+        self._options = options
 
-    async def execute(self, cmd: CheckSystemPackageCommand) -> CheckSystemPackageCommand.Output:
-        log.info('Checking system package!')
+        self._pyenv = pyenv
+        self._inspector = inspector
 
-        ret = await self._mgr.query(*cmd.pkgs)
+    #
 
-        return CheckSystemPackageCommand.Output(list(ret.values()))
+    @staticmethod
+    def guess_version(s: str) -> ta.Optional[InterpVersion]:
+        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
+            if s.endswith(sfx):
+                return s[:-len(sfx)], True
+            return s, False
+        ok = {}
+        s, ok['debug'] = strip_sfx(s, '-debug')
+        s, ok['threaded'] = strip_sfx(s, 't')
+        try:
+            v = Version(s)
+        except InvalidVersion:
+            return None
+        return InterpVersion(v, InterpOpts(**ok))
 
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
 
-########################################
-# ../../../omdev/interp/pyenv.py
-"""
-TODO:
- - custom tags
-  - 'aliases'
-  - https://github.com/pyenv/pyenv/pull/2966
-  - https://github.com/pyenv/pyenv/issues/218 (lol)
-  - probably need custom (temp?) definition file
-  - *or* python-build directly just into the versions dir?
- - optionally install / upgrade pyenv itself
- - new vers dont need these custom mac opts, only run on old vers
-"""
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+        iv: ta.Optional[InterpVersion]
+        if self._options.inspect:
+            try:
+                iv = check.not_none(await self._inspector.inspect(ep)).iv
+            except Exception as e:  # noqa
+                return None
+        else:
+            iv = self.guess_version(vn)
+        if iv is None:
+            return None
+        return PyenvInterpProvider.Installed(
+            name=vn,
+            exe=ep,
+            version=iv,
+        )
 
+    async def installed(self) -> ta.Sequence[Installed]:
+        ret: ta.List[PyenvInterpProvider.Installed] = []
+        for vn, ep in await self._pyenv.version_exes():
+            if (i := await self._make_installed(vn, ep)) is None:
+                log.debug('Invalid pyenv version: %s', vn)
+                continue
+            ret.append(i)
+        return ret
 
-##
+    #
 
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
 
-class Pyenv:
-    def __init__(
-            self,
-            *,
-            root: ta.Optional[str] = None,
-    ) -> None:
-        if root is not None and not (isinstance(root, str) and root):
-            raise ValueError(f'pyenv_root: {root!r}')
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for i in await self.installed():
+            if i.version == version:
+                return Interp(
+                    exe=i.exe,
+                    version=i.version,
+                )
+        raise KeyError(version)
 
-        super().__init__()
+    #
 
-        self._root_kw = root
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
 
-    @async_cached_nullary
-    async def root(self) -> ta.Optional[str]:
-        if self._root_kw is not None:
-            return self._root_kw
+        for vs in await self._pyenv.installable_versions():
+            if (iv := self.guess_version(vs)) is None:
+                continue
+            if iv.opts.debug:
+                raise Exception('Pyenv installable versions not expected to have debug suffix')
+            for d in [False, True]:
+                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
 
-        if shutil.which('pyenv'):
-            return await asyncio_subprocesses.check_output_str('pyenv', 'root')
+        return lst
 
-        d = os.path.expanduser('~/.pyenv')
-        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
-            return d
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
 
-        return None
+        if self._options.try_update and not any(v in spec for v in lst):
+            if self._pyenv.update():
+                lst = await self._get_installable_versions(spec)
+
+        return lst
+
+    async def install_version(self, version: InterpVersion) -> Interp:
+        inst_version = str(version.version)
+        inst_opts = version.opts
+        if inst_opts.threaded:
+            inst_version += 't'
+            inst_opts = dc.replace(inst_opts, threaded=False)
 
-    @async_cached_nullary
-    async def exe(self) -> str:
-        return os.path.join(check.not_none(await self.root()), 'bin', 'pyenv')
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
+            pyenv=self._pyenv,
+        )
 
-    async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
-        if (root := await self.root()) is None:
-            return []
-        ret = []
-        vp = os.path.join(root, 'versions')
-        if os.path.isdir(vp):
-            for dn in os.listdir(vp):
-                ep = os.path.join(vp, dn, 'bin', 'python')
-                if not os.path.isfile(ep):
-                    continue
-                ret.append((dn, ep))
-        return ret
+        exe = await installer.install()
+        return Interp(exe, version)
 
-    async def installable_versions(self) -> ta.List[str]:
-        if await self.root() is None:
-            return []
-        ret = []
-        s = await asyncio_subprocesses.check_output_str(await self.exe(), 'install', '--list')
-        for l in s.splitlines():
-            if not l.startswith('  '):
-                continue
-            l = l.strip()
-            if not l:
-                continue
-            ret.append(l)
-        return ret
 
-    async def update(self) -> bool:
-        if (root := await self.root()) is None:
-            return False
-        if not os.path.isdir(os.path.join(root, '.git')):
-            return False
-        await asyncio_subprocesses.check_call('git', 'pull', cwd=root)
-        return True
+########################################
+# ../commands/inject.py
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class PyenvInstallOpts:
-    opts: ta.Sequence[str] = ()
-    conf_opts: ta.Sequence[str] = ()
-    cflags: ta.Sequence[str] = ()
-    ldflags: ta.Sequence[str] = ()
-    env: ta.Mapping[str, str] = dc.field(default_factory=dict)
+def bind_command(
+        command_cls: ta.Type[Command],
+        executor_cls: ta.Optional[ta.Type[CommandExecutor]],
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(CommandRegistration(command_cls), array=True),
+    ]
 
-    def merge(self, *others: 'PyenvInstallOpts') -> 'PyenvInstallOpts':
-        return PyenvInstallOpts(
-            opts=list(itertools.chain.from_iterable(o.opts for o in [self, *others])),
-            conf_opts=list(itertools.chain.from_iterable(o.conf_opts for o in [self, *others])),
-            cflags=list(itertools.chain.from_iterable(o.cflags for o in [self, *others])),
-            ldflags=list(itertools.chain.from_iterable(o.ldflags for o in [self, *others])),
-            env=dict(itertools.chain.from_iterable(o.env.items() for o in [self, *others])),
-        )
+    if executor_cls is not None:
+        lst.extend([
+            inj.bind(executor_cls, singleton=True),
+            inj.bind(CommandExecutorRegistration(command_cls, executor_cls), array=True),
+        ])
 
+    return inj.as_bindings(*lst)
 
-# TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
-DEFAULT_PYENV_INSTALL_OPTS = PyenvInstallOpts(
-    opts=[
-        '-s',
-        '-v',
-        '-k',
-    ],
-    conf_opts=[
-        # FIXME: breaks on mac for older py's
-        '--enable-loadable-sqlite-extensions',
 
-        # '--enable-shared',
+##
 
-        '--enable-optimizations',
-        '--with-lto',
 
-        # '--enable-profiling', # ?
+@dc.dataclass(frozen=True)
+class _FactoryCommandExecutor(CommandExecutor):
+    factory: ta.Callable[[], CommandExecutor]
 
-        # '--enable-ipv6', # ?
-    ],
-    cflags=[
-        # '-march=native',
-        # '-mtune=native',
-    ],
-)
+    def execute(self, i: Command) -> ta.Awaitable[Command.Output]:
+        return self.factory().execute(i)
 
-DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
 
-THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
+##
 
 
-#
+def bind_commands(
+        *,
+        main_config: MainConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(CommandRegistration),
+        inj.bind_array_type(CommandRegistration, CommandRegistrations),
 
+        inj.bind_array(CommandExecutorRegistration),
+        inj.bind_array_type(CommandExecutorRegistration, CommandExecutorRegistrations),
 
-class PyenvInstallOptsProvider(abc.ABC):
-    @abc.abstractmethod
-    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
-        raise NotImplementedError
+        inj.bind(build_command_name_map, singleton=True),
+    ]
 
+    #
 
-class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
-    async def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts()
+    def provide_obj_marshaler_installer(cmds: CommandNameMap) -> ObjMarshalerInstaller:
+        return ObjMarshalerInstaller(functools.partial(install_command_marshaling, cmds))
 
+    lst.append(inj.bind(provide_obj_marshaler_installer, array=True))
 
-class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
-    @cached_nullary
-    def framework_opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts(conf_opts=['--enable-framework'])
+    #
 
-    @cached_nullary
-    def has_brew(self) -> bool:
-        return shutil.which('brew') is not None
+    def provide_command_executor_map(
+            injector: Injector,
+            crs: CommandExecutorRegistrations,
+    ) -> CommandExecutorMap:
+        dct: ta.Dict[ta.Type[Command], CommandExecutor] = {}
 
-    BREW_DEPS: ta.Sequence[str] = [
-        'openssl',
-        'readline',
-        'sqlite3',
-        'zlib',
-    ]
+        cr: CommandExecutorRegistration
+        for cr in crs:
+            if cr.command_cls in dct:
+                raise KeyError(cr.command_cls)
 
-    @async_cached_nullary
-    async def brew_deps_opts(self) -> PyenvInstallOpts:
-        cflags = []
-        ldflags = []
-        for dep in self.BREW_DEPS:
-            dep_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', dep)
-            cflags.append(f'-I{dep_prefix}/include')
-            ldflags.append(f'-L{dep_prefix}/lib')
-        return PyenvInstallOpts(
-            cflags=cflags,
-            ldflags=ldflags,
-        )
+            factory = functools.partial(injector.provide, cr.executor_cls)
+            if main_config.debug:
+                ce = factory()
+            else:
+                ce = _FactoryCommandExecutor(factory)
 
-    @async_cached_nullary
-    async def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if await asyncio_subprocesses.try_output('brew', '--prefix', 'tcl-tk') is None:
-            return PyenvInstallOpts()
+            dct[cr.command_cls] = ce
 
-        tcl_tk_prefix = await asyncio_subprocesses.check_output_str('brew', '--prefix', 'tcl-tk')
-        tcl_tk_ver_str = await asyncio_subprocesses.check_output_str('brew', 'ls', '--versions', 'tcl-tk')
-        tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
+        return CommandExecutorMap(dct)
 
-        return PyenvInstallOpts(conf_opts=[
-            f"--with-tcltk-includes='-I{tcl_tk_prefix}/include'",
-            f"--with-tcltk-libs='-L{tcl_tk_prefix}/lib -ltcl{tcl_tk_ver} -ltk{tcl_tk_ver}'",
-        ])
+    lst.extend([
+        inj.bind(provide_command_executor_map, singleton=True),
 
-    # @cached_nullary
-    # def brew_ssl_opts(self) -> PyenvInstallOpts:
-    #     pkg_config_path = subprocess_check_output_str('brew', '--prefix', 'openssl')
-    #     if 'PKG_CONFIG_PATH' in os.environ:
-    #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
-    #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
+        inj.bind(LocalCommandExecutor, singleton=True, eager=main_config.debug),
+    ])
 
-    async def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts().merge(
-            self.framework_opts(),
-            await self.brew_deps_opts(),
-            await self.brew_tcl_opts(),
-            # self.brew_ssl_opts(),
-        )
+    #
 
+    lst.extend([
+        bind_command(PingCommand, PingCommandExecutor),
+        bind_command(SubprocessCommand, SubprocessCommandExecutor),
+    ])
 
-PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
-    'darwin': DarwinPyenvInstallOpts(),
-    'linux': LinuxPyenvInstallOpts(),
-}
+    #
 
+    return inj.as_bindings(*lst)
 
-##
 
+########################################
+# ../deploy/paths/manager.py
 
-class PyenvVersionInstaller:
-    """
-    Messy: can install freethreaded build with a 't' suffixed version str _or_ by THREADED_PYENV_INSTALL_OPTS - need
-    latter to build custom interp with ft, need former to use canned / blessed interps. Muh.
-    """
 
+class DeployPathsManager:
     def __init__(
             self,
-            version: str,
-            opts: ta.Optional[PyenvInstallOpts] = None,
-            interp_opts: InterpOpts = InterpOpts(),
             *,
-            install_name: ta.Optional[str] = None,
-            no_default_opts: bool = False,
-            pyenv: Pyenv = Pyenv(),
+            deploy_path_owners: DeployPathOwners,
     ) -> None:
         super().__init__()
 
-        self._version = version
-        self._given_opts = opts
-        self._interp_opts = interp_opts
-        self._given_install_name = install_name
-
-        self._no_default_opts = no_default_opts
-        self._pyenv = pyenv
-
-    @property
-    def version(self) -> str:
-        return self._version
+        self._deploy_path_owners = deploy_path_owners
 
-    @async_cached_nullary
-    async def opts(self) -> PyenvInstallOpts:
-        opts = self._given_opts
-        if self._no_default_opts:
-            if opts is None:
-                opts = PyenvInstallOpts()
-        else:
-            lst = [self._given_opts if self._given_opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
-            if self._interp_opts.debug:
-                lst.append(DEBUG_PYENV_INSTALL_OPTS)
-            if self._interp_opts.threaded:
-                lst.append(THREADED_PYENV_INSTALL_OPTS)
-            lst.append(await PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
-            opts = PyenvInstallOpts().merge(*lst)
-        return opts
+    @cached_nullary
+    def owners_by_path(self) -> ta.Mapping[DeployPath, DeployPathOwner]:
+        dct: ta.Dict[DeployPath, DeployPathOwner] = {}
+        for o in self._deploy_path_owners:
+            for p in o.get_owned_deploy_paths():
+                if p in dct:
+                    raise DeployPathError(f'Duplicate deploy path owner: {p}')
+                dct[p] = o
+        return dct
 
-    @cached_nullary
-    def install_name(self) -> str:
-        if self._given_install_name is not None:
-            return self._given_install_name
-        return self._version + ('-debug' if self._interp_opts.debug else '')
+    def validate_deploy_paths(self) -> None:
+        self.owners_by_path()
 
-    @async_cached_nullary
-    async def install_dir(self) -> str:
-        return str(os.path.join(check.not_none(await self._pyenv.root()), 'versions', self.install_name()))
 
-    @async_cached_nullary
-    async def install(self) -> str:
-        opts = await self.opts()
-        env = {**os.environ, **opts.env}
-        for k, l in [
-            ('CFLAGS', opts.cflags),
-            ('LDFLAGS', opts.ldflags),
-            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
-        ]:
-            v = ' '.join(l)
-            if k in os.environ:
-                v += ' ' + os.environ[k]
-            env[k] = v
+########################################
+# ../deploy/tmp.py
 
-        conf_args = [
-            *opts.opts,
-            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
-                *conf_args,
-                await self.install_dir(),
-            ]
-        else:
-            full_args = [
-                await self._pyenv.exe(),
-                'install',
-                *conf_args,
-            ]
+class DeployHomeAtomics(Func1[DeployHome, AtomicPathSwapping]):
+    pass
 
-        await asyncio_subprocesses.check_call(
-            *full_args,
-            env=env,
+
+class DeployTmpManager(
+    SingleDirDeployPathOwner,
+):
+    def __init__(self) -> None:
+        super().__init__(
+            owned_dir='tmp',
         )
 
-        exe = os.path.join(await self.install_dir(), 'bin', 'python')
-        if not os.path.isfile(exe):
-            raise RuntimeError(f'Interpreter not found: {exe}')
-        return exe
+    def get_swapping(self, home: DeployHome) -> AtomicPathSwapping:
+        return TempDirAtomicPathSwapping(
+            temp_dir=self._make_dir(home),
+            root_dir=check.non_empty_str(home),
+        )
+
+
+########################################
+# ../remote/connection.py
 
 
 ##
 
 
-class PyenvInterpProvider(InterpProvider):
+class PyremoteRemoteExecutionConnector:
     def __init__(
             self,
-            pyenv: Pyenv = Pyenv(),
-
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
-
             *,
-
-            try_update: bool = False,
+            spawning: RemoteSpawning,
+            msh: ObjMarshalerManager,
+            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
     ) -> None:
         super().__init__()
 
-        self._pyenv = pyenv
+        self._spawning = spawning
+        self._msh = msh
+        self._payload_file = payload_file
 
-        self._inspect = inspect
-        self._inspector = inspector
+    #
 
-        self._try_update = try_update
+    @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()',
+        ]
 
-    @staticmethod
-    def guess_version(s: str) -> ta.Optional[InterpVersion]:
-        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
-            if s.endswith(sfx):
-                return s[:-len(sfx)], True
-            return s, False
-        ok = {}
-        s, ok['debug'] = strip_sfx(s, '-debug')
-        s, ok['threaded'] = strip_sfx(s, 't')
-        try:
-            v = Version(s)
-        except InvalidVersion:
-            return None
-        return InterpVersion(v, InterpOpts(**ok))
+    @cached_nullary
+    def _spawn_src(self) -> str:
+        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
 
-    class Installed(ta.NamedTuple):
-        name: str
-        exe: str
-        version: InterpVersion
+    #
 
-    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
-        iv: ta.Optional[InterpVersion]
-        if self._inspect:
-            try:
-                iv = check.not_none(await self._inspector.inspect(ep)).iv
-            except Exception as e:  # noqa
-                return None
-        else:
-            iv = self.guess_version(vn)
-        if iv is None:
-            return None
-        return PyenvInterpProvider.Installed(
-            name=vn,
-            exe=ep,
-            version=iv,
-        )
+    @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 def installed(self) -> ta.Sequence[Installed]:
-        ret: ta.List[PyenvInterpProvider.Installed] = []
-        for vn, ep in await self._pyenv.version_exes():
-            if (i := await self._make_installed(vn, ep)) is None:
-                log.debug('Invalid pyenv version: %s', vn)
-                continue
-            ret.append(i)
-        return ret
+        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,
+            )
 
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in await self.installed()]
+            await chan.send_obj(bs)
 
-    async def get_installed_version(self, version: InterpVersion) -> Interp:
-        for i in await self.installed():
-            if i.version == version:
-                return Interp(
-                    exe=i.exe,
-                    version=i.version,
-                )
-        raise KeyError(version)
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(chan)) as rce:
+                await rce.start()
 
-    #
+                yield rce
 
-    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = []
 
-        for vs in await self._pyenv.installable_versions():
-            if (iv := self.guess_version(vs)) is None:
-                continue
-            if iv.opts.debug:
-                raise Exception('Pyenv installable versions not expected to have debug suffix')
-            for d in [False, True]:
-                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
+##
 
-        return lst
 
-    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = await self._get_installable_versions(spec)
+class InProcessRemoteExecutionConnector:
+    def __init__(
+            self,
+            *,
+            msh: ObjMarshalerManager,
+            local_executor: LocalCommandExecutor,
+    ) -> None:
+        super().__init__()
 
-        if self._try_update and not any(v in spec for v in lst):
-            if self._pyenv.update():
-                lst = await self._get_installable_versions(spec)
+        self._msh = msh
+        self._local_executor = local_executor
 
-        return lst
+    @contextlib.asynccontextmanager
+    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        r0, w0 = asyncio_create_bytes_channel()
+        r1, w1 = asyncio_create_bytes_channel()
 
-    async def install_version(self, version: InterpVersion) -> Interp:
-        inst_version = str(version.version)
-        inst_opts = version.opts
-        if inst_opts.threaded:
-            inst_version += 't'
-            inst_opts = dc.replace(inst_opts, threaded=False)
+        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
+        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
 
-        installer = PyenvVersionInstaller(
-            inst_version,
-            interp_opts=inst_opts,
+        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()
 
-        exe = await installer.install()
-        return Interp(exe, version)
+                yield rce
+
+        finally:
+            rch.stop()
+            await rch_task
 
 
 ########################################
-# ../../../omdev/interp/system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
+# ../system/commands.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CheckSystemPackageCommand(Command['CheckSystemPackageCommand.Output']):
+    pkgs: ta.Sequence[str] = ()
+
+    def __post_init__(self) -> None:
+        check.not_isinstance(self.pkgs, str)
+
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pkgs: ta.Sequence[SystemPackage]
 
 
-##
+class CheckSystemPackageCommandExecutor(CommandExecutor[CheckSystemPackageCommand, CheckSystemPackageCommand.Output]):
+    def __init__(
+            self,
+            *,
+            mgr: SystemPackageManager,
+    ) -> None:
+        super().__init__()
 
+        self._mgr = mgr
 
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
+    async def execute(self, cmd: CheckSystemPackageCommand) -> CheckSystemPackageCommand.Output:
+        log.info('Checking system package!')
 
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
+        ret = await self._mgr.query(*cmd.pkgs)
 
-    #
+        return CheckSystemPackageCommand.Output(list(ret.values()))
 
-    @staticmethod
-    def _re_which(
-            pat: re.Pattern,
-            *,
-            mode: int = os.F_OK | os.X_OK,
-            path: ta.Optional[str] = None,
-    ) -> ta.List[str]:
-        if path is None:
-            path = os.environ.get('PATH', None)
-            if path is None:
-                try:
-                    path = os.confstr('CS_PATH')
-                except (AttributeError, ValueError):
-                    path = os.defpath
 
-        if not path:
-            return []
+########################################
+# ../../../omdev/interp/providers/inject.py
 
-        path = os.fsdecode(path)
-        pathlst = path.split(os.pathsep)
 
-        def _access_check(fn: str, mode: int) -> bool:
-            return os.path.exists(fn) and os.access(fn, mode)
+def bind_interp_providers() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(InterpProvider),
+        inj.bind_array_type(InterpProvider, InterpProviders),
 
-        out = []
-        seen = set()
-        for d in pathlst:
-            normdir = os.path.normcase(d)
-            if normdir not in seen:
-                seen.add(normdir)
-                if not _access_check(normdir, mode):
-                    continue
-                for thefile in os.listdir(d):
-                    name = os.path.join(d, thefile)
-                    if not (
-                            os.path.isfile(name) and
-                            pat.fullmatch(thefile) and
-                            _access_check(name, mode)
-                    ):
-                        continue
-                    out.append(name)
+        inj.bind(RunningInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=RunningInterpProvider, array=True),
 
-        return out
+        inj.bind(SystemInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=SystemInterpProvider, array=True),
+    ]
 
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
+    return inj.as_bindings(*lst)
 
-    #
 
-    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
+########################################
+# ../../../omdev/interp/pyenv/inject.py
 
-    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
 
-    #
+def bind_interp_pyenv() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(Pyenv, singleton=True),
 
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in await self.exe_versions()]
+        inj.bind(PyenvInterpProvider, singleton=True),
+        inj.bind(InterpProvider, to_key=PyenvInterpProvider, array=True),
+    ]
 
-    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)
+    return inj.as_bindings(*lst)
 
 
 ########################################
@@ -10784,101 +10944,44 @@ class SshManageTargetConnector(ManageTargetConnector):
 
 
 ########################################
-# ../../../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
+# ../../../omdev/interp/inject.py
 
-        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)
+def bind_interp() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        bind_interp_providers(),
 
-        if not install:
-            return None
+        bind_interp_pyenv(),
 
-        tp = list(self._providers.values())[0]  # noqa
+        bind_interp_uv(),
 
-        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
+        inj.bind(InterpInspector, singleton=True),
+    ]
 
-        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)
+    def provide_interp_resolver_providers(injector: Injector) -> InterpResolverProviders:
+        # FIXME: lol
+        rps: ta.List[ta.Any] = [
+            injector.provide(c)
+            for c in [
+                PyenvInterpProvider,
+                RunningInterpProvider,
+                SystemInterpProvider,
             ]
-            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}')
+        return InterpResolverProviders([(rp.name, rp) for rp in rps])
 
+    lst.append(inj.bind(provide_interp_resolver_providers, singleton=True))
 
-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),
+    lst.extend([
+        inj.bind(InterpResolver, singleton=True),
+    ])
 
-    RunningInterpProvider(),
+    #
 
-    SystemInterpProvider(),
-]])
+    return inj.as_bindings(*lst)
 
 
 ########################################
@@ -10910,6 +11013,15 @@ def bind_targets() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../../../omdev/interp/default.py
+
+
+@cached_nullary
+def get_default_interp_resolver() -> InterpResolver:
+    return inj.create_injector(bind_interp())[InterpResolver]
+
+
 ########################################
 # ../deploy/interp.py
 
@@ -10932,7 +11044,7 @@ class InterpCommand(Command['InterpCommand.Output']):
 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))
+        o = check.not_none(await get_default_interp_resolver().resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),
@@ -10959,7 +11071,7 @@ class DeployVenvManager:
     ) -> None:
         if spec.interp is not None:
             i = InterpSpecifier.parse(check.not_none(spec.interp))
-            o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i))
+            o = check.not_none(await get_default_interp_resolver().resolve(i))
             sys_exe = o.exe
         else:
             sys_exe = 'python3'
@@ -11166,16 +11278,18 @@ class DeployDriver:
             self,
             *,
             spec: DeploySpec,
+            home: DeployHome,
+            time: DeployTime,
 
-            deploys: DeployManager,
             paths: DeployPathsManager,
             apps: DeployAppManager,
     ) -> None:
         super().__init__()
 
         self._spec = spec
+        self._home = home
+        self._time = time
 
-        self._deploys = deploys
         self._paths = paths
         self._apps = apps
 
@@ -11184,17 +11298,8 @@ class DeployDriver:
 
         #
 
-        hs = check.non_empty_str(self._spec.home)
-        hs = os.path.expanduser(hs)
-        hs = os.path.realpath(hs)
-        hs = os.path.abspath(hs)
-
-        home = DeployHome(hs)
-
-        #
-
         deploy_tags = DeployTagMap(
-            self._deploys.make_deploy_time(),
+            self._time,
             self._spec.key(),
         )
 
@@ -11209,7 +11314,7 @@ class DeployDriver:
 
             await self._apps.prepare_app(
                 app,
-                home,
+                self._home,
                 app_tags,
             )
 
@@ -11247,10 +11352,57 @@ class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]
 # ../deploy/inject.py
 
 
+##
+
+
 class DeployInjectorScope(ContextvarInjectorScope):
     pass
 
 
+def bind_deploy_scope() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_scope(DeployInjectorScope),
+        inj.bind_scope_seed(DeploySpec, DeployInjectorScope),
+
+        inj.bind(DeployDriver, in_=DeployInjectorScope),
+    ]
+
+    #
+
+    def provide_deploy_driver_factory(injector: Injector, sc: DeployInjectorScope) -> DeployDriverFactory:
+        @contextlib.contextmanager
+        def factory(spec: DeploySpec) -> ta.Iterator[DeployDriver]:
+            with sc.enter({
+                inj.as_key(DeploySpec): spec,
+            }):
+                yield injector[DeployDriver]
+        return DeployDriverFactory(factory)
+    lst.append(inj.bind(provide_deploy_driver_factory, singleton=True))
+
+    #
+
+    def provide_deploy_home(deploy: DeploySpec) -> DeployHome:
+        hs = check.non_empty_str(deploy.home)
+        hs = os.path.expanduser(hs)
+        hs = os.path.realpath(hs)
+        hs = os.path.abspath(hs)
+        return DeployHome(hs)
+    lst.append(inj.bind(provide_deploy_home, in_=DeployInjectorScope))
+
+    #
+
+    def provide_deploy_time(deploys: DeployManager) -> DeployTime:
+        return deploys.make_deploy_time()
+    lst.append(inj.bind(provide_deploy_time, in_=DeployInjectorScope))
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+##
+
+
 def bind_deploy(
         *,
         deploy_config: DeployConfig,
@@ -11259,6 +11411,8 @@ def bind_deploy(
         inj.bind(deploy_config),
 
         bind_deploy_paths(),
+
+        bind_deploy_scope(),
     ]
 
     #
@@ -11294,25 +11448,6 @@ def bind_deploy(
 
     #
 
-    def provide_deploy_driver_factory(injector: Injector, sc: DeployInjectorScope) -> DeployDriverFactory:
-        @contextlib.contextmanager
-        def factory(spec: DeploySpec) -> ta.Iterator[DeployDriver]:
-            with sc.enter({
-                inj.as_key(DeploySpec): spec,
-            }):
-                yield injector[DeployDriver]
-        return DeployDriverFactory(factory)
-    lst.append(inj.bind(provide_deploy_driver_factory, singleton=True))
-
-    lst.extend([
-        inj.bind_scope(DeployInjectorScope),
-        inj.bind_scope_seed(DeploySpec, DeployInjectorScope),
-
-        inj.bind(DeployDriver, in_=DeployInjectorScope),
-    ])
-
-    #
-
     lst.extend([
         bind_command(DeployCommand, DeployCommandExecutor),
         bind_command(InterpCommand, InterpCommandExecutor),
@@ -11435,7 +11570,7 @@ class MainCli(ArgparseCli):
 
     #
 
-    @argparse_command(
+    @argparse_cmd(
         argparse_arg('--_payload-file'),
 
         argparse_arg('--pycharm-debug-port', type=int),