omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/inject/_dataclasses.py

@@ -25,27 +25,30 @@ def _register(**kwargs):
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('listener',)), EqPlan(fields=('listener',)), FrozenPlan(fields=('listener',), allo"
-        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('listener',), cache=True), InitPlan(fields=(Init"
-        "Plan.Field(name='listener', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=N"
-        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),),"
-        " self_param='self', std_params=('listener',), kw_only_params=(), frozen=True, slots=False, post_init_params=()"
-        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='listener', kw_only=False, fn=None),), i"
-        "d=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('fn',)), EqPlan(fields=('fn',)), FrozenPlan(fields=('fn',), allow_dynamic_dunder_a"
+        "ttrs=False), HashPlan(action='add', fields=('fn',), cache=True), InitPlan(fields=(InitPlan.Field(name='fn', an"
+        "notation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False"
+        ", field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fields.0.validate'), check_type=None),"
+        "), self_param='self', std_params=('fn',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, "
+        "init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='fn', kw_only=False, fn=None),), id=False,"
+        " terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='01ca4dd7c51876d086eb4230f400151c659e0842',
+    plan_repr_sha1='465d8361a14bec38d3a20f2ef3aaeaed5cd23067',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__validate',
     ),
     cls_names=(
-        ('omlish.inject.listeners', 'ProvisionListenerBinding'),
+        ('omlish.inject.binder', 'AsyncFnProvider'),
+        ('omlish.inject.binder', 'FnProvider'),
     ),
 )
-def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
+def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__validate,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -64,7 +67,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                listener=self.listener,
+                fn=self.fn,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -78,7 +81,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.listener == other.listener
+                self.fn == other.fn
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -87,7 +90,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'listener',
+            'fn',
         }
 
         def __setattr__(self, name, value):
@@ -104,7 +107,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'listener',
+            'fn',
         }
 
         def __delattr__(self, name):
@@ -129,7 +132,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.listener,
+                    self.fn,
                 ))
             )
             return h
@@ -139,10 +142,16 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
 
         def __init__(
             self,
-            listener: __dataclass__init__fields__0__annotation,
+            fn: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'listener', listener)
-            self.__post_init__()
+            if not __dataclass__init__fields__0__validate(fn): 
+                raise __dataclass__FieldFnValidationError(
+                    obj=self,
+                    fn=__dataclass__init__fields__0__validate,
+                    field='fn',
+                    value=fn,
+                )
+            __dataclass__object_setattr(self, 'fn', fn)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -152,7 +161,7 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"listener={self.listener!r}")
+            parts.append(f"fn={self.fn!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -169,31 +178,46 @@ def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('owner', 'p')), EqPlan(fields=('owner', 'p')), FrozenPlan(fields=('owner', 'p'), a"
-        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('owner', 'p'), cache=False), InitPlan(fields="
-        "(InitPlan.Field(name='owner', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory"
-        "=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),"
-        " InitPlan.Field(name='p', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=Non"
-        "e, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), se"
-        "lf_param='self', std_params=('owner', 'p'), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
-        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='owner', kw_only=False, fn=None), ReprPl"
-        "an.Field(name='p', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key', 'provider', 'scope')), EqPlan(fields=('key', 'provider', 'scope')), FrozenP"
+        "lan(fields=('key', 'provider', 'scope'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ke"
+        "y', 'provider', 'scope'), cache=True), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init"
+        ".fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.IN"
+        "STANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='provi"
+        "der', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, overri"
+        "de=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.1.coerce'), validate=None, check_type="
+        "None), InitPlan.Field(name='scope', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='ini"
+        "t.fields.2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=O"
+        "pRef(name='init.fields.2.coerce'), validate=None, check_type=None)), self_param='self', std_params=('key', 'pr"
+        "ovider', 'scope'), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), validate_fns"
+        "=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None), ReprPlan.Field(name='provider', kw_"
+        "only=False, fn=None), ReprPlan.Field(name='scope', kw_only=False, fn=None)), id=False, terse=False, default_fn"
+        "=None)))"
     ),
-    plan_repr_sha1='0f6ba4c593adbc50913cf38fc7c075e91843dbde',
+    plan_repr_sha1='46c59d586838c9ad0bfaea00944f56523114cba1',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__coerce',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__coerce',
+        '__dataclass__init__fields__2__default',
     ),
     cls_names=(
-        ('omlish.inject.impl.privates', 'PrivateInfo'),
+        ('omlish.inject.binder', 'Binding'),
     ),
 )
-def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
+def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__coerce,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__coerce,
+        __dataclass__init__fields__2__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -212,8 +236,9 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                owner=self.owner,
-                p=self.p,
+                key=self.key,
+                provider=self.provider,
+                scope=self.scope,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -227,8 +252,9 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.owner == other.owner and
-                self.p == other.p
+                self.key == other.key and
+                self.provider == other.provider and
+                self.scope == other.scope
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -237,8 +263,9 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'owner',
-            'p',
+            'key',
+            'provider',
+            'scope',
         }
 
         def __setattr__(self, name, value):
@@ -255,8 +282,9 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'owner',
-            'p',
+            'key',
+            'provider',
+            'scope',
         }
 
         def __delattr__(self, name):
@@ -273,21 +301,37 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash((
-                self.owner,
-                self.p,
-            ))
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.key,
+                    self.provider,
+                    self.scope,
+                ))
+            )
+            return h
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            owner: __dataclass__init__fields__0__annotation,
-            p: __dataclass__init__fields__1__annotation,
+            key: __dataclass__init__fields__0__annotation,
+            provider: __dataclass__init__fields__1__annotation,
+            scope: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'owner', owner)
-            __dataclass__object_setattr(self, 'p', p)
+            key = __dataclass__init__fields__0__coerce(key)
+            provider = __dataclass__init__fields__1__coerce(provider)
+            scope = __dataclass__init__fields__2__coerce(scope)
+            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'provider', provider)
+            __dataclass__object_setattr(self, 'scope', scope)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -297,8 +341,9 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"owner={self.owner!r}")
-            parts.append(f"p={self.p!r}")
+            parts.append(f"key={self.key!r}")
+            parts.append(f"provider={self.provider!r}")
+            parts.append(f"scope={self.scope!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -315,22 +360,22 @@ def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attrs=False), InitPlan(fiel"
-        "ds=(InitPlan.Field(name='v', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory="
-        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),)"
-        ", self_param='self', std_params=('v',), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init"
-        "_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, ters"
-        "e=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('v',)), EqPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attr"
+        "s=False), HashPlan(action='add', fields=('v',), cache=True), InitPlan(fields=(InitPlan.Field(name='v', annotat"
+        "ion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fie"
+        "ld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('v'"
+        ",), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
+        "n(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c',
+    plan_repr_sha1='454972cdb0715dc22365cb0a504288ac36355c45',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.inject.helpers.constfn', 'ConstFn'),
+        ('omlish.inject.binder', 'ConstProvider'),
     ),
 )
-def _process_dataclass__1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c():
+def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -361,6 +406,20 @@ def _process_dataclass__1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.v == other.v
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
         __dataclass___setattr_frozen_fields = {
             'v',
         }
@@ -395,12 +454,28 @@ def _process_dataclass__1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.v,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
         def __init__(
             self,
             v: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
             __dataclass__object_setattr(self, 'v', v)
-            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -427,36 +502,29 @@ def _process_dataclass__1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('multi_key', 'dst')), EqPlan(fields=('multi_key', 'dst')), FrozenPlan(fields=('mul"
-        "ti_key', 'dst'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('multi_key', 'dst'), cache="
-        "True), InitPlan(fields=(InitPlan.Field(name='multi_key', annotation=OpRef(name='init.fields.0.annotation'), de"
-        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
-        "ate=OpRef(name='init.fields.0.validate'), check_type=None), InitPlan.Field(name='dst', annotation=OpRef(name='"
-        "init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldTyp"
-        "e.INSTANCE, coerce=OpRef(name='init.fields.1.coerce'), validate=None, check_type=None)), self_param='self', st"
-        "d_params=('multi_key', 'dst'), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), "
-        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='multi_key', kw_only=False, fn=None), ReprPlan.Field(na"
-        "me='dst', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('ty',)), EqPlan(fields=('ty',)), FrozenPlan(fields=('ty',), allow_dynamic_dunder_a"
+        "ttrs=False), HashPlan(action='add', fields=('ty',), cache=True), InitPlan(fields=(InitPlan.Field(name='ty', an"
+        "notation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False"
+        ", field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None),),"
+        " self_param='self', std_params=('ty',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, in"
+        "it_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='ty', kw_only=False, fn=None),), id=False, t"
+        "erse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='1ba38fd546769fabc04fa41bd279c7fcbbad22f2',
+    plan_repr_sha1='d152f7efec7ea241cf364f9c170bbe40950b82d9',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__validate',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__coerce',
+        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.multis', 'SetBinding'),
+        ('omlish.inject.binder', 'CtorProvider'),
     ),
 )
-def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
+def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__validate,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__coerce,
+        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -475,8 +543,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                multi_key=self.multi_key,
-                dst=self.dst,
+                ty=self.ty,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -490,8 +557,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.multi_key == other.multi_key and
-                self.dst == other.dst
+                self.ty == other.ty
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -500,8 +566,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'multi_key',
-            'dst',
+            'ty',
         }
 
         def __setattr__(self, name, value):
@@ -518,8 +583,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'multi_key',
-            'dst',
+            'ty',
         }
 
         def __delattr__(self, name):
@@ -544,8 +608,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.multi_key,
-                    self.dst,
+                    self.ty,
                 ))
             )
             return h
@@ -555,20 +618,10 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
 
         def __init__(
             self,
-            multi_key: __dataclass__init__fields__0__annotation,
-            dst: __dataclass__init__fields__1__annotation,
+            ty: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            dst = __dataclass__init__fields__1__coerce(dst)
-            if not __dataclass__init__fields__0__validate(multi_key): 
-                raise __dataclass__FieldFnValidationError(
-                    obj=self,
-                    fn=__dataclass__init__fields__0__validate,
-                    field='multi_key',
-                    value=multi_key,
-                )
-            __dataclass__object_setattr(self, 'multi_key', multi_key)
-            __dataclass__object_setattr(self, 'dst', dst)
-            self.__post_init__()
+            ty = __dataclass__init__fields__0__coerce(ty)
+            __dataclass__object_setattr(self, 'ty', ty)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -578,8 +631,7 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"multi_key={self.multi_key!r}")
-            parts.append(f"dst={self.dst!r}")
+            parts.append(f"ty={self.ty!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -596,34 +648,34 @@ def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('es', 'cs')), EqPlan(fields=('es', 'cs')), FrozenPlan(fields=('es', 'cs'), allow_d"
-        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('es', 'cs'), cache=False), InitPlan(fields=(InitPla"
-        "n.Field(name='es', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.defaul"
-        "t'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=Non"
-        "e, check_type=None), InitPlan.Field(name='cs', annotation=OpRef(name='init.fields.1.annotation'), default=OpRe"
-        "f(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANC"
-        "E, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('es', 'cs'), kw_only_params=("
-        "), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.F"
-        "ield(name='es', kw_only=False, fn=None), ReprPlan.Field(name='cs', kw_only=False, fn=None)), id=False, terse=F"
-        "alse, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key', 'priority')), EqPlan(fields=('key', 'priority')), FrozenPlan(fields=('key',"
+        " 'priority'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('key', 'priority'), cache=True"
+        "), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init.fields.0.annotation'), default=None"
+        ", default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fiel"
+        "ds.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='priority', annotation=OpRef(name='init.fi"
+        "elds.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, override=Fa"
+        "lse, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_para"
+        "ms=('key',), kw_only_params=('priority',), frozen=True, slots=False, post_init_params=(), init_fns=(), validat"
+        "e_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None), ReprPlan.Field(name='priority'"
+        ", kw_only=True, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='20c0436b77a328557ecfbe556539d09e7a50f7bd',
+    plan_repr_sha1='c45a09634b0e2a6fa1c4c76e2f691964112b0ddd',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__1__default',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Elements'),
+        ('omlish.inject.binder', 'Eager'),
     ),
 )
-def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
+def _process_dataclass__c45a09634b0e2a6fa1c4c76e2f691964112b0ddd():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__1__annotation,
         __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
@@ -644,8 +696,8 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                es=self.es,
-                cs=self.cs,
+                key=self.key,
+                priority=self.priority,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -659,8 +711,8 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.es == other.es and
-                self.cs == other.cs
+                self.key == other.key and
+                self.priority == other.priority
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -669,8 +721,8 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'es',
-            'cs',
+            'key',
+            'priority',
         }
 
         def __setattr__(self, name, value):
@@ -687,8 +739,8 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'es',
-            'cs',
+            'key',
+            'priority',
         }
 
         def __delattr__(self, name):
@@ -705,21 +757,33 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash((
-                self.es,
-                self.cs,
-            ))
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.key,
+                    self.priority,
+                ))
+            )
+            return h
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            es: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
-            cs: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            key: __dataclass__init__fields__0__annotation,
+            *,
+            priority: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'es', es)
-            __dataclass__object_setattr(self, 'cs', cs)
+            key = __dataclass__init__fields__0__coerce(key)
+            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'priority', priority)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -729,8 +793,8 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"es={self.es!r}")
-            parts.append(f"cs={self.cs!r}")
+            parts.append(f"key={self.key!r}")
+            parts.append(f"priority={self.priority!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -747,26 +811,36 @@ def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('es',)), FrozenPlan(fields=('es',), allow_dynamic_dunder_attrs=False), InitPlan(fi"
-        "elds=(InitPlan.Field(name='es', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_facto"
-        "ry=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None"
-        "),), self_param='self', std_params=('es',), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
-        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='es', kw_only=False, fn=None),), id=Fals"
-        "e, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('es', 'cs')), EqPlan(fields=('es', 'cs')), FrozenPlan(fields=('es', 'cs'), allow_d"
+        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('es', 'cs'), cache=False), InitPlan(fields=(InitPla"
+        "n.Field(name='es', annotation=OpRef(name='init.fields.0.annotation'), default=OpRef(name='init.fields.0.defaul"
+        "t'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=Non"
+        "e, check_type=None), InitPlan.Field(name='cs', annotation=OpRef(name='init.fields.1.annotation'), default=OpRe"
+        "f(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANC"
+        "E, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('es', 'cs'), kw_only_params=("
+        "), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.F"
+        "ield(name='es', kw_only=False, fn=None), ReprPlan.Field(name='cs', kw_only=False, fn=None)), id=False, terse=F"
+        "alse, default_fn=None)))"
     ),
-    plan_repr_sha1='23940adf5b02820a6f9975e06728e5b58b744320',
+    plan_repr_sha1='20c0436b77a328557ecfbe556539d09e7a50f7bd',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__default',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
     ),
     cls_names=(
-        ('omlish.inject.impl.elements', 'MapProviderImpl'),
+        ('omlish.inject.binder', 'Elements'),
     ),
 )
-def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
+def _process_dataclass__20c0436b77a328557ecfbe556539d09e7a50f7bd():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__default,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -786,6 +860,7 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 es=self.es,
+                cs=self.cs,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -793,8 +868,24 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.es == other.es and
+                self.cs == other.cs
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
         __dataclass___setattr_frozen_fields = {
             'es',
+            'cs',
         }
 
         def __setattr__(self, name, value):
@@ -812,6 +903,7 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
 
         __dataclass___delattr_frozen_fields = {
             'es',
+            'cs',
         }
 
         def __delattr__(self, name):
@@ -827,11 +919,22 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
+        def __hash__(self):
+            return hash((
+                self.es,
+                self.cs,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
         def __init__(
             self,
-            es: __dataclass__init__fields__0__annotation,
+            es: __dataclass__init__fields__0__annotation = __dataclass__init__fields__0__default,
+            cs: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
             __dataclass__object_setattr(self, 'es', es)
+            __dataclass__object_setattr(self, 'cs', cs)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -842,6 +945,7 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
         def __repr__(self):
             parts = []
             parts.append(f"es={self.es!r}")
+            parts.append(f"cs={self.cs!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -858,28 +962,29 @@ def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('p',)), FrozenPlan(fields=('p',), allow_dynamic_dunder_attrs=False), InitPlan(fiel"
-        "ds=(InitPlan.Field(name='p', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory="
-        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),)"
-        ", self_param='self', std_params=('p',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, in"
-        "it_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None),), id=False, te"
-        "rse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), FrozenPlan(fields=('key',), allow_dynamic_dunde"
+        "r_attrs=False), HashPlan(action='add', fields=('key',), cache=True), InitPlan(fields=(InitPlan.Field(name='key"
+        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
+        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
+        "e),), self_param='self', std_params=('key',), kw_only_params=(), frozen=True, slots=False, post_init_params=()"
+        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None),), id=Fal"
+        "se, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='365eedd17dff52bfa369a9578066fd43141c41fd',
+    plan_repr_sha1='95e8d2726657f6c6d0abe6bace53f80710e3d314',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.impl.bindings', 'ConstProviderImpl'),
-        ('omlish.inject.impl.bindings', 'LinkProviderImpl'),
-        ('omlish.inject.impl.elements', 'ScopeSeededProviderImpl'),
+        ('omlish.inject.binder', 'Expose'),
     ),
 )
-def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
+def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -898,7 +1003,7 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                p=self.p,
+                key=self.key,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -906,8 +1011,22 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.key == other.key
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
         __dataclass___setattr_frozen_fields = {
-            'p',
+            'key',
         }
 
         def __setattr__(self, name, value):
@@ -924,7 +1043,7 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'p',
+            'key',
         }
 
         def __delattr__(self, name):
@@ -940,11 +1059,30 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.key,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
         def __init__(
             self,
-            p: __dataclass__init__fields__0__annotation,
+            key: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'p', p)
+            key = __dataclass__init__fields__0__coerce(key)
+            __dataclass__object_setattr(self, 'key', key)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -954,7 +1092,7 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"p={self.p!r}")
+            parts.append(f"key={self.key!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -971,29 +1109,40 @@ def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('k',)), EqPlan(fields=('k',)), FrozenPlan(fields=('k',), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('k',), cache=True), InitPlan(fields=(InitPlan.Field(name='k', annotat"
-        "ion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fie"
-        "ld_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None),), self"
-        "_param='self', std_params=('k',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns"
-        "=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='k', kw_only=False, fn=None),), id=False, terse=Fa"
-        "lse, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('ty', 'tag')), EqPlan(fields=('ty', 'tag')), FrozenPlan(fields=('ty', 'tag'), allo"
+        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ty', 'tag'), cache=True), InitPlan(fields=(Init"
+        "Plan.Field(name='ty', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, i"
+        "nit=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=N"
+        "one, check_type=None), InitPlan.Field(name='tag', annotation=OpRef(name='init.fields.1.annotation'), default=O"
+        "pRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=None, validate=OpRef(name='init.fields.1.validate'), check_type=None)), self_param='self', std_pa"
+        "rams=('ty',), kw_only_params=('tag',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_"
+        "fns=()), ReprPlan(fields=(ReprPlan.Field(name='ty', kw_only=False, fn=None), ReprPlan.Field(name='tag', kw_onl"
+        "y=True, fn=OpRef(name='repr.fns.1.fn'))), id=False, terse=True, default_fn=None)))"
     ),
-    plan_repr_sha1='399a0f677e522382f8e81b442490afcfdd485c6a',
+    plan_repr_sha1='e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
+        '__dataclass__init__fields__1__validate',
+        '__dataclass__repr__fns__1__fn',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'LinkProvider'),
+        ('omlish.inject.binder', 'Key'),
     ),
 )
-def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
+def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
+        __dataclass__init__fields__1__validate,
+        __dataclass__repr__fns__1__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1012,7 +1161,8 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                k=self.k,
+                ty=self.ty,
+                tag=self.tag,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1026,7 +1176,8 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.k == other.k
+                self.ty == other.ty and
+                self.tag == other.tag
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1035,7 +1186,8 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'k',
+            'ty',
+            'tag',
         }
 
         def __setattr__(self, name, value):
@@ -1052,7 +1204,8 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'k',
+            'ty',
+            'tag',
         }
 
         def __delattr__(self, name):
@@ -1077,7 +1230,8 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.k,
+                    self.ty,
+                    self.tag,
                 ))
             )
             return h
@@ -1087,10 +1241,20 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
 
         def __init__(
             self,
-            k: __dataclass__init__fields__0__annotation,
+            ty: __dataclass__init__fields__0__annotation,
+            *,
+            tag: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            k = __dataclass__init__fields__0__coerce(k)
-            __dataclass__object_setattr(self, 'k', k)
+            ty = __dataclass__init__fields__0__coerce(ty)
+            if not __dataclass__init__fields__1__validate(tag): 
+                raise __dataclass__FieldFnValidationError(
+                    obj=self,
+                    fn=__dataclass__init__fields__1__validate,
+                    field='tag',
+                    value=tag,
+                )
+            __dataclass__object_setattr(self, 'ty', ty)
+            __dataclass__object_setattr(self, 'tag', tag)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1100,7 +1264,9 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"k={self.k!r}")
+            parts.append(f"{self.ty!r}")
+            if (s := __dataclass__repr__fns__1__fn(self.tag)) is not None:
+                parts.append(f"tag={s}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1117,45 +1283,29 @@ def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key', 'provider', 'scope', 'binding')), FrozenPlan(fields=('key', 'provider', 'sc"
-        "ope', 'binding'), allow_dynamic_dunder_attrs=False), InitPlan(fields=(InitPlan.Field(name='key', annotation=Op"
-        "Ref(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
-        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='provider', annotation"
-        "=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_"
-        "type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='scope', annotation"
-        "=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields.2.default'), default_factory=None, in"
-        "it=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan"
-        ".Field(name='binding', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='init.fields.3.de"
-        "fault'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate"
-        "=None, check_type=None)), self_param='self', std_params=('key', 'provider', 'scope', 'binding'), kw_only_param"
-        "s=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPla"
-        "n.Field(name='key', kw_only=False, fn=None), ReprPlan.Field(name='provider', kw_only=False, fn=None), ReprPlan"
-        ".Field(name='scope', kw_only=False, fn=None), ReprPlan.Field(name='binding', kw_only=False, fn=None)), id=Fals"
-        "e, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('k',)), EqPlan(fields=('k',)), FrozenPlan(fields=('k',), allow_dynamic_dunder_attr"
+        "s=False), HashPlan(action='add', fields=('k',), cache=True), InitPlan(fields=(InitPlan.Field(name='k', annotat"
+        "ion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fie"
+        "ld_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None),), self"
+        "_param='self', std_params=('k',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns"
+        "=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='k', kw_only=False, fn=None),), id=False, terse=Fa"
+        "lse, default_fn=None)))"
     ),
-    plan_repr_sha1='3ea053d1a1090718f9d29a7824558f2ca9a77e31',
+    plan_repr_sha1='399a0f677e522382f8e81b442490afcfdd485c6a',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__2__annotation',
-        '__dataclass__init__fields__2__default',
-        '__dataclass__init__fields__3__annotation',
-        '__dataclass__init__fields__3__default',
+        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.impl.bindings', 'BindingImpl'),
+        ('omlish.inject.binder', 'LinkProvider'),
     ),
 )
-def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
+def _process_dataclass__399a0f677e522382f8e81b442490afcfdd485c6a():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__2__annotation,
-        __dataclass__init__fields__2__default,
-        __dataclass__init__fields__3__annotation,
-        __dataclass__init__fields__3__default,
+        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1174,10 +1324,7 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
-                provider=self.provider,
-                scope=self.scope,
-                binding=self.binding,
+                k=self.k,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1185,11 +1332,22 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.k == other.k
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
         __dataclass___setattr_frozen_fields = {
-            'key',
-            'provider',
-            'scope',
-            'binding',
+            'k',
         }
 
         def __setattr__(self, name, value):
@@ -1206,10 +1364,7 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'key',
-            'provider',
-            'scope',
-            'binding',
+            'k',
         }
 
         def __delattr__(self, name):
@@ -1225,17 +1380,29 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.k,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
-            provider: __dataclass__init__fields__1__annotation,
-            scope: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
-            binding: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
+            k: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'key', key)
-            __dataclass__object_setattr(self, 'provider', provider)
-            __dataclass__object_setattr(self, 'scope', scope)
-            __dataclass__object_setattr(self, 'binding', binding)
+            k = __dataclass__init__fields__0__coerce(k)
+            __dataclass__object_setattr(self, 'k', k)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1245,10 +1412,7 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key={self.key!r}")
-            parts.append(f"provider={self.provider!r}")
-            parts.append(f"scope={self.scope!r}")
-            parts.append(f"binding={self.binding!r}")
+            parts.append(f"k={self.k!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1265,22 +1429,24 @@ def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('v',)), EqPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attr"
-        "s=False), HashPlan(action='add', fields=('v',), cache=True), InitPlan(fields=(InitPlan.Field(name='v', annotat"
-        "ion=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, fie"
-        "ld_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_params=('v'"
-        ",), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPla"
-        "n(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('lst',)), EqPlan(fields=('lst',)), FrozenPlan(fields=('lst',), allow_dynamic_dunde"
+        "r_attrs=False), HashPlan(action='add', fields=('lst',), cache=True), InitPlan(fields=(InitPlan.Field(name='lst"
+        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
+        "False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_p"
+        "arams=('lst',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns="
+        "()), ReprPlan(fields=(ReprPlan.Field(name='lst', kw_only=False, fn=None),), id=False, terse=False, default_fn="
+        "None)))"
     ),
-    plan_repr_sha1='454972cdb0715dc22365cb0a504288ac36355c45',
+    plan_repr_sha1='d1633dcd9bb962f0e548a4a63b764b808cdac621',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'ConstProvider'),
+        ('omlish.inject.binder', 'Origin'),
+        ('omlish.inject.binder', 'Origins'),
     ),
 )
-def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
+def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1303,7 +1469,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                v=self.v,
+                lst=self.lst,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1317,7 +1483,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.v == other.v
+                self.lst == other.lst
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1326,7 +1492,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'v',
+            'lst',
         }
 
         def __setattr__(self, name, value):
@@ -1343,7 +1509,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'v',
+            'lst',
         }
 
         def __delattr__(self, name):
@@ -1368,7 +1534,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.v,
+                    self.lst,
                 ))
             )
             return h
@@ -1378,9 +1544,9 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
 
         def __init__(
             self,
-            v: __dataclass__init__fields__0__annotation,
+            lst: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'v', v)
+            __dataclass__object_setattr(self, 'lst', lst)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1390,7 +1556,7 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"v={self.v!r}")
+            parts.append(f"lst={self.lst!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1407,30 +1573,29 @@ def _process_dataclass__454972cdb0715dc22365cb0a504288ac36355c45():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('fn',)), EqPlan(fields=('fn',)), FrozenPlan(fields=('fn',), allow_dynamic_dunder_a"
-        "ttrs=False), HashPlan(action='add', fields=('fn',), cache=True), InitPlan(fields=(InitPlan.Field(name='fn', an"
-        "notation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False"
-        ", field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fields.0.validate'), check_type=None),"
-        "), self_param='self', std_params=('fn',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, "
-        "init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='fn', kw_only=False, fn=None),), id=False,"
-        " terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('elements',)), EqPlan(fields=('elements',)), FrozenPlan(fields=('elements',), allo"
+        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('elements',), cache=True), InitPlan(fields=(Init"
+        "Plan.Field(name='elements', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=N"
+        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), vali"
+        "date=None, check_type=None),), self_param='self', std_params=('elements',), kw_only_params=(), frozen=True, sl"
+        "ots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='elements'"
+        ", kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='465d8361a14bec38d3a20f2ef3aaeaed5cd23067',
+    plan_repr_sha1='8b45b0d38754c357aabee0be30419e40d1746bc4',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__validate',
+        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'AsyncFnProvider'),
-        ('omlish.inject.binder', 'FnProvider'),
+        ('omlish.inject.binder', 'Private'),
     ),
 )
-def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
+def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__validate,
+        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1449,7 +1614,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                fn=self.fn,
+                elements=self.elements,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1463,7 +1628,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.fn == other.fn
+                self.elements == other.elements
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1472,7 +1637,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'fn',
+            'elements',
         }
 
         def __setattr__(self, name, value):
@@ -1489,7 +1654,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'fn',
+            'elements',
         }
 
         def __delattr__(self, name):
@@ -1514,7 +1679,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.fn,
+                    self.elements,
                 ))
             )
             return h
@@ -1524,16 +1689,11 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
 
         def __init__(
             self,
-            fn: __dataclass__init__fields__0__annotation,
+            elements: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            if not __dataclass__init__fields__0__validate(fn): 
-                raise __dataclass__FieldFnValidationError(
-                    obj=self,
-                    fn=__dataclass__init__fields__0__validate,
-                    field='fn',
-                    value=fn,
-                )
-            __dataclass__object_setattr(self, 'fn', fn)
+            elements = __dataclass__init__fields__0__coerce(elements)
+            __dataclass__object_setattr(self, 'elements', elements)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1543,7 +1703,7 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"fn={self.fn!r}")
+            parts.append(f"elements={self.elements!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1560,46 +1720,29 @@ def _process_dataclass__465d8361a14bec38d3a20f2ef3aaeaed5cd23067():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key', 'provider', 'scope')), EqPlan(fields=('key', 'provider', 'scope')), FrozenP"
-        "lan(fields=('key', 'provider', 'scope'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ke"
-        "y', 'provider', 'scope'), cache=True), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='init"
-        ".fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.IN"
-        "STANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None), InitPlan.Field(name='provi"
-        "der', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, overri"
-        "de=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.1.coerce'), validate=None, check_type="
-        "None), InitPlan.Field(name='scope', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='ini"
-        "t.fields.2.default'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=O"
-        "pRef(name='init.fields.2.coerce'), validate=None, check_type=None)), self_param='self', std_params=('key', 'pr"
-        "ovider', 'scope'), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), validate_fns"
-        "=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None), ReprPlan.Field(name='provider', kw_"
-        "only=False, fn=None), ReprPlan.Field(name='scope', kw_only=False, fn=None)), id=False, terse=False, default_fn"
-        "=None)))"
+        "Plans(tup=(CopyPlan(fields=('scope',)), EqPlan(fields=('scope',)), FrozenPlan(fields=('scope',), allow_dynamic"
+        "_dunder_attrs=False), HashPlan(action='add', fields=('scope',), cache=True), InitPlan(fields=(InitPlan.Field(n"
+        "ame='scope', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True,"
+        " override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, chec"
+        "k_type=None),), self_param='self', std_params=('scope',), kw_only_params=(), frozen=True, slots=False, post_in"
+        "it_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='scope', kw_only=False, fn=N"
+        "one),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='46c59d586838c9ad0bfaea00944f56523114cba1',
+    plan_repr_sha1='a01535be51a62c3aedc3529e0204c6135d8d9e99',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__coerce',
-        '__dataclass__init__fields__2__annotation',
-        '__dataclass__init__fields__2__coerce',
-        '__dataclass__init__fields__2__default',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Binding'),
+        ('omlish.inject.binder', 'ScopeBinding'),
     ),
 )
-def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
+def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__coerce,
-        __dataclass__init__fields__2__annotation,
-        __dataclass__init__fields__2__coerce,
-        __dataclass__init__fields__2__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1618,8 +1761,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
-                provider=self.provider,
                 scope=self.scope,
             )
 
@@ -1634,8 +1775,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.key == other.key and
-                self.provider == other.provider and
                 self.scope == other.scope
             )
 
@@ -1645,8 +1784,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'key',
-            'provider',
             'scope',
         }
 
@@ -1664,8 +1801,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'key',
-            'provider',
             'scope',
         }
 
@@ -1691,8 +1826,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.key,
-                    self.provider,
                     self.scope,
                 ))
             )
@@ -1703,15 +1836,9 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
 
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
-            provider: __dataclass__init__fields__1__annotation,
-            scope: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            scope: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            key = __dataclass__init__fields__0__coerce(key)
-            provider = __dataclass__init__fields__1__coerce(provider)
-            scope = __dataclass__init__fields__2__coerce(scope)
-            __dataclass__object_setattr(self, 'key', key)
-            __dataclass__object_setattr(self, 'provider', provider)
+            scope = __dataclass__init__fields__0__coerce(scope)
             __dataclass__object_setattr(self, 'scope', scope)
             self.__post_init__()
 
@@ -1723,8 +1850,6 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key={self.key!r}")
-            parts.append(f"provider={self.provider!r}")
             parts.append(f"scope={self.scope!r}")
             return (
                 f"{self.__class__.__qualname__}("
@@ -1742,17 +1867,325 @@ def _process_dataclass__46c59d586838c9ad0bfaea00944f56523114cba1():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key', 'source', 'name')), EqPlan(fields=('key', 'source', 'name')), HashPlan(acti"
-        "on='set_none', fields=None, cache=None), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='in"
-        "it.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType."
-        "INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='source', annotation=OpRef(name='i"
-        "nit.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, overr"
-        "ide=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='n"
-        "ame', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields.2.default'), default_"
-        "factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type"
-        "=None)), self_param='self', std_params=('key', 'source', 'name'), kw_only_params=(), frozen=False, slots=False"
-        ", post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=Fa"
-        "lse, fn=None), ReprPlan.Field(name='source', kw_only=False, fn=None), ReprPlan.Field(name='name', kw_only=Fals"
+        "Plans(tup=(CopyPlan(fields=('ss', 'key')), EqPlan(fields=('ss', 'key')), FrozenPlan(fields=('ss', 'key'), allo"
+        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ss', 'key'), cache=True), InitPlan(fields=(Init"
+        "Plan.Field(name='ss', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, i"
+        "nit=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=N"
+        "one, check_type=None), InitPlan.Field(name='key', annotation=OpRef(name='init.fields.1.annotation'), default=N"
+        "one, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.f"
+        "ields.1.coerce'), validate=None, check_type=None)), self_param='self', std_params=('ss', 'key'), kw_only_param"
+        "s=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPla"
+        "n.Field(name='ss', kw_only=False, fn=None), ReprPlan.Field(name='key', kw_only=False, fn=None)), id=False, ter"
+        "se=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='67e893f944c9f60c3bb7298d6024e3f17b097447',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__coerce',
+    ),
+    cls_names=(
+        ('omlish.inject.binder', 'ScopeSeededProvider'),
+    ),
+)
+def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__coerce,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                ss=self.ss,
+                key=self.key,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.ss == other.ss and
+                self.key == other.key
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'ss',
+            'key',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'ss',
+            'key',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.ss,
+                    self.key,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            ss: __dataclass__init__fields__0__annotation,
+            key: __dataclass__init__fields__1__annotation,
+        ) -> __dataclass__None:
+            ss = __dataclass__init__fields__0__coerce(ss)
+            key = __dataclass__init__fields__1__coerce(key)
+            __dataclass__object_setattr(self, 'ss', ss)
+            __dataclass__object_setattr(self, 'key', key)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"ss={self.ss!r}")
+            parts.append(f"key={self.key!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('tag',)), EqPlan(fields=('tag',)), FrozenPlan(fields=('tag',), allow_dynamic_dunde"
+        "r_attrs=False), HashPlan(action='add', fields=('tag',), cache=True), InitPlan(fields=(InitPlan.Field(name='tag"
+        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
+        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
+        "e),), self_param='self', std_params=('tag',), kw_only_params=(), frozen=True, slots=False, post_init_params=No"
+        "ne, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='tag', kw_only=False, fn=None),), id=F"
+        "alse, terse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='e3da1b32863a0a4aca9ff268877a77ad5d6dd328',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
+    ),
+    cls_names=(
+        ('omlish.inject.binder', 'SeededScope'),
+    ),
+)
+def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                tag=self.tag,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.tag == other.tag
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'tag',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'tag',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.tag,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            tag: __dataclass__init__fields__0__annotation,
+        ) -> __dataclass__None:
+            tag = __dataclass__init__fields__0__coerce(tag)
+            __dataclass__object_setattr(self, 'tag', tag)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"tag={self.tag!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('key', 'source', 'name')), EqPlan(fields=('key', 'source', 'name')), HashPlan(acti"
+        "on='set_none', fields=None, cache=None), InitPlan(fields=(InitPlan.Field(name='key', annotation=OpRef(name='in"
+        "it.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType."
+        "INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='source', annotation=OpRef(name='i"
+        "nit.fields.1.annotation'), default=OpRef(name='init.fields.1.default'), default_factory=None, init=True, overr"
+        "ide=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='n"
+        "ame', annotation=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields.2.default'), default_"
+        "factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type"
+        "=None)), self_param='self', std_params=('key', 'source', 'name'), kw_only_params=(), frozen=False, slots=False"
+        ", post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=Fa"
+        "lse, fn=None), ReprPlan.Field(name='source', kw_only=False, fn=None), ReprPlan.Field(name='name', kw_only=Fals"
         "e, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
     plan_repr_sha1='54394c5ebd85aa173d2f60f20fae81b348f6cb9d',
@@ -1862,38 +2295,28 @@ def _process_dataclass__54394c5ebd85aa173d2f60f20fae81b348f6cb9d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('v', 'tag')), EqPlan(fields=('v', 'tag')), FrozenPlan(fields=('v', 'tag'), allow_d"
-        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('v', 'tag'), cache=True), InitPlan(fields=(InitPlan"
-        ".Field(name='v', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=T"
-        "rue, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Fie"
-        "ld(name='tag', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'),"
-        " default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(n"
-        "ame='init.fields.1.validate'), check_type=None)), self_param='self', std_params=('v',), kw_only_params=('tag',"
-        "), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.F"
-        "ield(name='v', kw_only=False, fn=None), ReprPlan.Field(name='tag', kw_only=True, fn=OpRef(name='repr.fns.1.fn'"
-        "))), id=False, terse=True, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('scope',)), EqPlan(fields=('scope',)), HashPlan(action='set_none', fields=None, ca"
+        "che=None), InitPlan(fields=(InitPlan.Field(name='scope', annotation=OpRef(name='init.fields.0.annotation'), de"
+        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
+        "ate=None, check_type=None),), self_param='self', std_params=('scope',), kw_only_params=(), frozen=False, slots"
+        "=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='scope', kw"
+        "_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='5cb76e85fd58b7b06dd5593254d86e557222901c',
+    plan_repr_sha1='d43eaf7e550de17fc6936c19e4e5aa545c8a93d8',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
-        '__dataclass__init__fields__1__validate',
-        '__dataclass__repr__fns__1__fn',
     ),
     cls_names=(
-        ('omlish.inject.helpers.id', 'Id'),
+        ('omlish.inject.errors', 'ScopeAlreadyOpenError'),
+        ('omlish.inject.errors', 'ScopeError'),
+        ('omlish.inject.errors', 'ScopeNotOpenError'),
     ),
 )
-def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
+def _process_dataclass__d43eaf7e550de17fc6936c19e4e5aa545c8a93d8():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default,
-        __dataclass__init__fields__1__validate,
-        __dataclass__repr__fns__1__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1912,8 +2335,7 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                v=self.v,
-                tag=self.tag,
+                scope=self.scope,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1927,8 +2349,7 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.v == other.v and
-                self.tag == other.tag
+                self.scope == other.scope
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1936,9 +2357,87 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__eq__', __eq__)
 
+        setattr(__dataclass__cls, '__hash__', None)
+
+        def __init__(
+            self,
+            scope: __dataclass__init__fields__0__annotation,
+        ) -> __dataclass__None:
+            self.scope = scope
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"scope={self.scope!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('v',)), FrozenPlan(fields=('v',), allow_dynamic_dunder_attrs=False), InitPlan(fiel"
+        "ds=(InitPlan.Field(name='v', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory="
+        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),)"
+        ", self_param='self', std_params=('v',), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init"
+        "_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='v', kw_only=False, fn=None),), id=False, ters"
+        "e=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+    ),
+    cls_names=(
+        ('omlish.inject.helpers.constfn', 'ConstFn'),
+    ),
+)
+def _process_dataclass__1a1c1b0c2f2ad1d4b7f67f6c870a5eb6e37e231c():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                v=self.v,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
         __dataclass___setattr_frozen_fields = {
             'v',
-            'tag',
         }
 
         def __setattr__(self, name, value):
@@ -1956,7 +2455,6 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
 
         __dataclass___delattr_frozen_fields = {
             'v',
-            'tag',
         }
 
         def __delattr__(self, name):
@@ -1972,39 +2470,12 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.v,
-                    self.tag,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
             v: __dataclass__init__fields__0__annotation,
-            *,
-            tag: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            if not __dataclass__init__fields__1__validate(tag): 
-                raise __dataclass__FieldFnValidationError(
-                    obj=self,
-                    fn=__dataclass__init__fields__1__validate,
-                    field='tag',
-                    value=tag,
-                )
             __dataclass__object_setattr(self, 'v', v)
-            __dataclass__object_setattr(self, 'tag', tag)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2014,9 +2485,7 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.v!r}")
-            if (s := __dataclass__repr__fns__1__fn(self.tag)) is not None:
-                parts.append(f"tag={s}")
+            parts.append(f"v={self.v!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2029,35 +2498,42 @@ def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
         setattr(__dataclass__cls, '__repr__', __repr__)
 
     return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('root', 'level')), EqPlan(fields=('root', 'level')), FrozenPlan(fields=('root', 'l"
-        "evel'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('root', 'level'), cache=False), Init"
-        "Plan(fields=(InitPlan.Field(name='root', annotation=OpRef(name='init.fields.0.annotation'), default=None, defa"
-        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
-        "type=None), InitPlan.Field(name='level', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
-        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
-        "type=None)), self_param='self', std_params=('root', 'level'), kw_only_params=(), frozen=True, slots=False, pos"
-        "t_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='root', kw_only=False,"
-        " fn=None), ReprPlan.Field(name='level', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+
+
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('v', 'tag')), EqPlan(fields=('v', 'tag')), FrozenPlan(fields=('v', 'tag'), allow_d"
+        "ynamic_dunder_attrs=False), HashPlan(action='add', fields=('v', 'tag'), cache=True), InitPlan(fields=(InitPlan"
+        ".Field(name='v', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=T"
+        "rue, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Fie"
+        "ld(name='tag', annotation=OpRef(name='init.fields.1.annotation'), default=OpRef(name='init.fields.1.default'),"
+        " default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(n"
+        "ame='init.fields.1.validate'), check_type=None)), self_param='self', std_params=('v',), kw_only_params=('tag',"
+        "), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.F"
+        "ield(name='v', kw_only=False, fn=None), ReprPlan.Field(name='tag', kw_only=True, fn=OpRef(name='repr.fns.1.fn'"
+        "))), id=False, terse=True, default_fn=None)))"
     ),
-    plan_repr_sha1='5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3',
+    plan_repr_sha1='5cb76e85fd58b7b06dd5593254d86e557222901c',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default',
+        '__dataclass__init__fields__1__validate',
+        '__dataclass__repr__fns__1__fn',
     ),
     cls_names=(
-        ('omlish.inject.helpers.wrappers', 'WrapperBinderHelper._Level'),
+        ('omlish.inject.helpers.id', 'Id'),
     ),
 )
-def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
+def _process_dataclass__5cb76e85fd58b7b06dd5593254d86e557222901c():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default,
+        __dataclass__init__fields__1__validate,
+        __dataclass__repr__fns__1__fn,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2076,8 +2552,8 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                root=self.root,
-                level=self.level,
+                v=self.v,
+                tag=self.tag,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2091,8 +2567,8 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.root == other.root and
-                self.level == other.level
+                self.v == other.v and
+                self.tag == other.tag
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2101,8 +2577,8 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'root',
-            'level',
+            'v',
+            'tag',
         }
 
         def __setattr__(self, name, value):
@@ -2119,8 +2595,8 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'root',
-            'level',
+            'v',
+            'tag',
         }
 
         def __delattr__(self, name):
@@ -2137,21 +2613,38 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash((
-                self.root,
-                self.level,
-            ))
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.v,
+                    self.tag,
+                ))
+            )
+            return h
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            root: __dataclass__init__fields__0__annotation,
-            level: __dataclass__init__fields__1__annotation,
+            v: __dataclass__init__fields__0__annotation,
+            *,
+            tag: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'root', root)
-            __dataclass__object_setattr(self, 'level', level)
+            if not __dataclass__init__fields__1__validate(tag): 
+                raise __dataclass__FieldFnValidationError(
+                    obj=self,
+                    fn=__dataclass__init__fields__1__validate,
+                    field='tag',
+                    value=tag,
+                )
+            __dataclass__object_setattr(self, 'v', v)
+            __dataclass__object_setattr(self, 'tag', tag)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2161,8 +2654,9 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"root={self.root!r}")
-            parts.append(f"level={self.level!r}")
+            parts.append(f"{self.v!r}")
+            if (s := __dataclass__repr__fns__1__fn(self.tag)) is not None:
+                parts.append(f"tag={s}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2179,34 +2673,21 @@ def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('seeds', 'prvs')), EqPlan(fields=('seeds', 'prvs')), FrozenPlan(fields=('seeds', '"
-        "prvs'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('seeds', 'prvs'), cache=False), Init"
-        "Plan(fields=(InitPlan.Field(name='seeds', annotation=OpRef(name='init.fields.0.annotation'), default=None, def"
-        "ault_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check"
-        "_type=None), InitPlan.Field(name='prvs', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
-        "ult_factory=OpRef(name='init.fields.1.default_factory'), init=True, override=False, field_type=FieldType.INSTA"
-        "NCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('seeds', 'prvs'), kw_only_p"
-        "arams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Rep"
-        "rPlan.Field(name='seeds', kw_only=False, fn=None), ReprPlan.Field(name='prvs', kw_only=False, fn=None)), id=Fa"
-        "lse, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='61f34069d7091014f66ca9e1c1d27dbbc1a4e03f',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default_factory',
+        "Plans(tup=(CopyPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), InitPlan(fields=(), s"
+        "elf_param='self', std_params=(), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns="
+        "(), validate_fns=()), ReprPlan(fields=(), id=True, terse=False, default_fn=None)))"
     ),
+    plan_repr_sha1='c726b62427445e76234a6a472593ae91ca8d6457',
+    op_ref_idents=(),
     cls_names=(
-        ('omlish.inject.impl.elements', 'SeededScopeImpl.State'),
+        ('omlish.inject.helpers.multis', 'ItemsBinderHelper._ItemTag'),
+        ('omlish.inject.helpers.wrappers', 'WrapperBinderHelper._Root'),
     ),
 )
-def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
+def _process_dataclass__c726b62427445e76234a6a472593ae91ca8d6457():
     def _process_dataclass(
         *,
         __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default_factory,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2224,40 +2705,16 @@ def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                seeds=self.seeds,
-                prvs=self.prvs,
-            )
+            return __dataclass__cls()  # noqa
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
         if '__copy__' in __dataclass__cls.__dict__:
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.seeds == other.seeds and
-                self.prvs == other.prvs
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
-        __dataclass___setattr_frozen_fields = {
-            'seeds',
-            'prvs',
-        }
-
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -2267,15 +2724,9 @@ def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
-        __dataclass___delattr_frozen_fields = {
-            'seeds',
-            'prvs',
-        }
-
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -2285,24 +2736,10 @@ def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            return hash((
-                self.seeds,
-                self.prvs,
-            ))
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
-            seeds: __dataclass__init__fields__0__annotation,
-            prvs: __dataclass__init__fields__1__annotation = __dataclass__HAS_DEFAULT_FACTORY,
         ) -> __dataclass__None:
-            if prvs is __dataclass__HAS_DEFAULT_FACTORY:
-                prvs = __dataclass__init__fields__1__default_factory()
-            __dataclass__object_setattr(self, 'seeds', seeds)
-            __dataclass__object_setattr(self, 'prvs', prvs)
+            pass
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2312,10 +2749,8 @@ def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"seeds={self.seeds!r}")
-            parts.append(f"prvs={self.prvs!r}")
             return (
-                f"{self.__class__.__qualname__}("
+                f"{self.__class__.__qualname__}@{hex(id(self))[2:]}("
                 f"{', '.join(parts)}"
                 f")"
             )
@@ -2330,36 +2765,26 @@ def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('ss', 'key')), EqPlan(fields=('ss', 'key')), FrozenPlan(fields=('ss', 'key'), allo"
-        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ss', 'key'), cache=True), InitPlan(fields=(Init"
-        "Plan.Field(name='ss', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, i"
-        "nit=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=N"
-        "one, check_type=None), InitPlan.Field(name='key', annotation=OpRef(name='init.fields.1.annotation'), default=N"
-        "one, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.f"
-        "ields.1.coerce'), validate=None, check_type=None)), self_param='self', std_params=('ss', 'key'), kw_only_param"
-        "s=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPla"
-        "n.Field(name='ss', kw_only=False, fn=None), ReprPlan.Field(name='key', kw_only=False, fn=None)), id=False, ter"
-        "se=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('vs',)), FrozenPlan(fields=('vs',), allow_dynamic_dunder_attrs=False), InitPlan(fi"
+        "elds=(InitPlan.Field(name='vs', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_facto"
+        "ry=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None"
+        "),), self_param='self', std_params=('vs',), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
+        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='vs', kw_only=False, fn=None),), id=Fals"
+        "e, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='67e893f944c9f60c3bb7298d6024e3f17b097447',
+    plan_repr_sha1='c4cee7449949f8c11b10dcaf6b91f62f28a6fd18',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'ScopeSeededProvider'),
+        ('omlish.inject.helpers.multis', 'ItemsBinderHelper._ItemsBox'),
     ),
 )
-def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
+def _process_dataclass__c4cee7449949f8c11b10dcaf6b91f62f28a6fd18():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2378,8 +2803,7 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                ss=self.ss,
-                key=self.key,
+                vs=self.vs,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2387,24 +2811,8 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.ss == other.ss and
-                self.key == other.key
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
         __dataclass___setattr_frozen_fields = {
-            'ss',
-            'key',
+            'vs',
         }
 
         def __setattr__(self, name, value):
@@ -2421,8 +2829,7 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'ss',
-            'key',
+            'vs',
         }
 
         def __delattr__(self, name):
@@ -2438,33 +2845,11 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.ss,
-                    self.key,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
-            ss: __dataclass__init__fields__0__annotation,
-            key: __dataclass__init__fields__1__annotation,
+            vs: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            ss = __dataclass__init__fields__0__coerce(ss)
-            key = __dataclass__init__fields__1__coerce(key)
-            __dataclass__object_setattr(self, 'ss', ss)
-            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'vs', vs)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2474,8 +2859,7 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"ss={self.ss!r}")
-            parts.append(f"key={self.key!r}")
+            parts.append(f"vs={self.vs!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2492,41 +2876,31 @@ def _process_dataclass__67e893f944c9f60c3bb7298d6024e3f17b097447():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('multi_key', 'map_key', 'dst')), EqPlan(fields=('multi_key', 'map_key', 'dst')), F"
-        "rozenPlan(fields=('multi_key', 'map_key', 'dst'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
-        "elds=('multi_key', 'map_key', 'dst'), cache=True), InitPlan(fields=(InitPlan.Field(name='multi_key', annotatio"
-        "n=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field"
-        "_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fields.0.validate'), check_type=None), InitPl"
-        "an.Field(name='map_key', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None"
-        ", init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), Init"
-        "Plan.Field(name='dst', annotation=OpRef(name='init.fields.2.annotation'), default=None, default_factory=None, "
-        "init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.2.coerce'), validate="
-        "None, check_type=None)), self_param='self', std_params=('multi_key', 'map_key', 'dst'), kw_only_params=(), fro"
-        "zen=True, slots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(nam"
-        "e='multi_key', kw_only=False, fn=None), ReprPlan.Field(name='map_key', kw_only=False, fn=None), ReprPlan.Field"
-        "(name='dst', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('root', 'level')), EqPlan(fields=('root', 'level')), FrozenPlan(fields=('root', 'l"
+        "evel'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('root', 'level'), cache=False), Init"
+        "Plan(fields=(InitPlan.Field(name='root', annotation=OpRef(name='init.fields.0.annotation'), default=None, defa"
+        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
+        "type=None), InitPlan.Field(name='level', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
+        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
+        "type=None)), self_param='self', std_params=('root', 'level'), kw_only_params=(), frozen=True, slots=False, pos"
+        "t_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='root', kw_only=False,"
+        " fn=None), ReprPlan.Field(name='level', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='6ed12b80942097addba0fe978453312450cdf8d9',
+    plan_repr_sha1='5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__validate',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__2__annotation',
-        '__dataclass__init__fields__2__coerce',
     ),
     cls_names=(
-        ('omlish.inject.multis', 'MapBinding'),
+        ('omlish.inject.helpers.wrappers', 'WrapperBinderHelper._Level'),
     ),
 )
-def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
+def _process_dataclass__5e1bef09da6295e8de9fe8f2ffad3a1a4e70d5a3():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__validate,
         __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__2__annotation,
-        __dataclass__init__fields__2__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2545,9 +2919,8 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                multi_key=self.multi_key,
-                map_key=self.map_key,
-                dst=self.dst,
+                root=self.root,
+                level=self.level,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2561,9 +2934,8 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.multi_key == other.multi_key and
-                self.map_key == other.map_key and
-                self.dst == other.dst
+                self.root == other.root and
+                self.level == other.level
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2572,9 +2944,8 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'multi_key',
-            'map_key',
-            'dst',
+            'root',
+            'level',
         }
 
         def __setattr__(self, name, value):
@@ -2591,9 +2962,8 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'multi_key',
-            'map_key',
-            'dst',
+            'root',
+            'level',
         }
 
         def __delattr__(self, name):
@@ -2610,42 +2980,21 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.multi_key,
-                    self.map_key,
-                    self.dst,
-                ))
-            )
-            return h
+            return hash((
+                self.root,
+                self.level,
+            ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            multi_key: __dataclass__init__fields__0__annotation,
-            map_key: __dataclass__init__fields__1__annotation,
-            dst: __dataclass__init__fields__2__annotation,
+            root: __dataclass__init__fields__0__annotation,
+            level: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            dst = __dataclass__init__fields__2__coerce(dst)
-            if not __dataclass__init__fields__0__validate(multi_key): 
-                raise __dataclass__FieldFnValidationError(
-                    obj=self,
-                    fn=__dataclass__init__fields__0__validate,
-                    field='multi_key',
-                    value=multi_key,
-                )
-            __dataclass__object_setattr(self, 'multi_key', multi_key)
-            __dataclass__object_setattr(self, 'map_key', map_key)
-            __dataclass__object_setattr(self, 'dst', dst)
-            self.__post_init__()
+            __dataclass__object_setattr(self, 'root', root)
+            __dataclass__object_setattr(self, 'level', level)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2655,9 +3004,8 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"multi_key={self.multi_key!r}")
-            parts.append(f"map_key={self.map_key!r}")
-            parts.append(f"dst={self.dst!r}")
+            parts.append(f"root={self.root!r}")
+            parts.append(f"level={self.level!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2674,30 +3022,31 @@ def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('multi_key',)), EqPlan(fields=('multi_key',)), FrozenPlan(fields=('multi_key',), a"
-        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('multi_key',), cache=True), InitPlan(fields=("
-        "InitPlan.Field(name='multi_key', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_fact"
-        "ory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fie"
-        "lds.0.validate'), check_type=None),), self_param='self', std_params=('multi_key',), kw_only_params=(), frozen="
-        "True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name="
-        "'multi_key', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('p', 'kt')), FrozenPlan(fields=('p', 'kt'), allow_dynamic_dunder_attrs=False), Ini"
+        "tPlan(fields=(InitPlan.Field(name='p', annotation=OpRef(name='init.fields.0.annotation'), default=None, defaul"
+        "t_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_ty"
+        "pe=None), InitPlan.Field(name='kt', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
+        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
+        "None)), self_param='self', std_params=('p', 'kt'), kw_only_params=(), frozen=True, slots=False, post_init_para"
+        "ms=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None), Rep"
+        "rPlan.Field(name='kt', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='864a29bd231d03e4f0141a4dc7872a66df50771d',
+    plan_repr_sha1='fd0f4351f533bc90a8c6f24973004fcc1931cf0d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__validate',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.inject.multis', 'MapProvider'),
-        ('omlish.inject.multis', 'SetProvider'),
+        ('omlish.inject.impl.bindings', 'AsyncCallableProviderImpl'),
+        ('omlish.inject.impl.bindings', 'CallableProviderImpl'),
     ),
 )
-def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
+def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__validate,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2716,7 +3065,8 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                multi_key=self.multi_key,
+                p=self.p,
+                kt=self.kt,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2724,22 +3074,9 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.multi_key == other.multi_key
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
         __dataclass___setattr_frozen_fields = {
-            'multi_key',
+            'p',
+            'kt',
         }
 
         def __setattr__(self, name, value):
@@ -2756,7 +3093,8 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'multi_key',
+            'p',
+            'kt',
         }
 
         def __delattr__(self, name):
@@ -2772,35 +3110,13 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.multi_key,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
-            multi_key: __dataclass__init__fields__0__annotation,
+            p: __dataclass__init__fields__0__annotation,
+            kt: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            if not __dataclass__init__fields__0__validate(multi_key): 
-                raise __dataclass__FieldFnValidationError(
-                    obj=self,
-                    fn=__dataclass__init__fields__0__validate,
-                    field='multi_key',
-                    value=multi_key,
-                )
-            __dataclass__object_setattr(self, 'multi_key', multi_key)
+            __dataclass__object_setattr(self, 'p', p)
+            __dataclass__object_setattr(self, 'kt', kt)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2810,7 +3126,8 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"multi_key={self.multi_key!r}")
+            parts.append(f"p={self.p!r}")
+            parts.append(f"kt={self.kt!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2827,29 +3144,45 @@ def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('elements',)), EqPlan(fields=('elements',)), FrozenPlan(fields=('elements',), allo"
-        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('elements',), cache=True), InitPlan(fields=(Init"
-        "Plan.Field(name='elements', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=N"
-        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), vali"
-        "date=None, check_type=None),), self_param='self', std_params=('elements',), kw_only_params=(), frozen=True, sl"
-        "ots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='elements'"
-        ", kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('key', 'provider', 'scope', 'binding')), FrozenPlan(fields=('key', 'provider', 'sc"
+        "ope', 'binding'), allow_dynamic_dunder_attrs=False), InitPlan(fields=(InitPlan.Field(name='key', annotation=Op"
+        "Ref(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
+        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='provider', annotation"
+        "=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_"
+        "type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='scope', annotation"
+        "=OpRef(name='init.fields.2.annotation'), default=OpRef(name='init.fields.2.default'), default_factory=None, in"
+        "it=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan"
+        ".Field(name='binding', annotation=OpRef(name='init.fields.3.annotation'), default=OpRef(name='init.fields.3.de"
+        "fault'), default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate"
+        "=None, check_type=None)), self_param='self', std_params=('key', 'provider', 'scope', 'binding'), kw_only_param"
+        "s=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPla"
+        "n.Field(name='key', kw_only=False, fn=None), ReprPlan.Field(name='provider', kw_only=False, fn=None), ReprPlan"
+        ".Field(name='scope', kw_only=False, fn=None), ReprPlan.Field(name='binding', kw_only=False, fn=None)), id=Fals"
+        "e, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='8b45b0d38754c357aabee0be30419e40d1746bc4',
+    plan_repr_sha1='3ea053d1a1090718f9d29a7824558f2ca9a77e31',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__default',
+        '__dataclass__init__fields__3__annotation',
+        '__dataclass__init__fields__3__default',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Private'),
+        ('omlish.inject.impl.bindings', 'BindingImpl'),
     ),
 )
-def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
+def _process_dataclass__3ea053d1a1090718f9d29a7824558f2ca9a77e31():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__default,
+        __dataclass__init__fields__3__annotation,
+        __dataclass__init__fields__3__default,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2868,7 +3201,10 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                elements=self.elements,
+                key=self.key,
+                provider=self.provider,
+                scope=self.scope,
+                binding=self.binding,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2876,22 +3212,11 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.elements == other.elements
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
         __dataclass___setattr_frozen_fields = {
-            'elements',
+            'key',
+            'provider',
+            'scope',
+            'binding',
         }
 
         def __setattr__(self, name, value):
@@ -2908,7 +3233,10 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'elements',
+            'key',
+            'provider',
+            'scope',
+            'binding',
         }
 
         def __delattr__(self, name):
@@ -2919,35 +3247,22 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
 
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.elements,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
         def __init__(
             self,
-            elements: __dataclass__init__fields__0__annotation,
+            key: __dataclass__init__fields__0__annotation,
+            provider: __dataclass__init__fields__1__annotation,
+            scope: __dataclass__init__fields__2__annotation = __dataclass__init__fields__2__default,
+            binding: __dataclass__init__fields__3__annotation = __dataclass__init__fields__3__default,
         ) -> __dataclass__None:
-            elements = __dataclass__init__fields__0__coerce(elements)
-            __dataclass__object_setattr(self, 'elements', elements)
-            self.__post_init__()
+            __dataclass__object_setattr(self, 'key', key)
+            __dataclass__object_setattr(self, 'provider', provider)
+            __dataclass__object_setattr(self, 'scope', scope)
+            __dataclass__object_setattr(self, 'binding', binding)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2957,7 +3272,10 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"elements={self.elements!r}")
+            parts.append(f"key={self.key!r}")
+            parts.append(f"provider={self.provider!r}")
+            parts.append(f"scope={self.scope!r}")
+            parts.append(f"binding={self.binding!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2974,22 +3292,24 @@ def _process_dataclass__8b45b0d38754c357aabee0be30419e40d1746bc4():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('impl',)), FrozenPlan(fields=('impl',), allow_dynamic_dunder_attrs=False), InitPla"
-        "n(fields=(InitPlan.Field(name='impl', annotation=OpRef(name='init.fields.0.annotation'), default=None, default"
-        "_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_typ"
-        "e=None),), self_param='self', std_params=('impl',), kw_only_params=(), frozen=True, slots=False, post_init_par"
-        "ams=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='impl', kw_only=False, fn=None),"
-        "), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('p',)), FrozenPlan(fields=('p',), allow_dynamic_dunder_attrs=False), InitPlan(fiel"
+        "ds=(InitPlan.Field(name='p', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory="
+        "None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),)"
+        ", self_param='self', std_params=('p',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, in"
+        "it_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None),), id=False, te"
+        "rse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='8e1f31f368d04d4784c49dcc2d91408279e36285',
+    plan_repr_sha1='365eedd17dff52bfa369a9578066fd43141c41fd',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.inject.impl.bindings', 'InternalProvider'),
+        ('omlish.inject.impl.bindings', 'ConstProviderImpl'),
+        ('omlish.inject.impl.bindings', 'LinkProviderImpl'),
+        ('omlish.inject.impl.elements', 'ScopeSeededProviderImpl'),
     ),
 )
-def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
+def _process_dataclass__365eedd17dff52bfa369a9578066fd43141c41fd():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -3012,7 +3332,7 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                impl=self.impl,
+                p=self.p,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -3021,7 +3341,7 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
         setattr(__dataclass__cls, '__copy__', __copy__)
 
         __dataclass___setattr_frozen_fields = {
-            'impl',
+            'p',
         }
 
         def __setattr__(self, name, value):
@@ -3038,7 +3358,7 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'impl',
+            'p',
         }
 
         def __delattr__(self, name):
@@ -3056,9 +3376,9 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
 
         def __init__(
             self,
-            impl: __dataclass__init__fields__0__annotation,
+            p: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'impl', impl)
+            __dataclass__object_setattr(self, 'p', p)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3068,7 +3388,7 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"impl={self.impl!r}")
+            parts.append(f"p={self.p!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3085,30 +3405,26 @@ def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key',)), EqPlan(fields=('key',)), FrozenPlan(fields=('key',), allow_dynamic_dunde"
-        "r_attrs=False), HashPlan(action='add', fields=('key',), cache=True), InitPlan(fields=(InitPlan.Field(name='key"
-        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
-        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
-        "e),), self_param='self', std_params=('key',), kw_only_params=(), frozen=True, slots=False, post_init_params=()"
-        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key', kw_only=False, fn=None),), id=Fal"
-        "se, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('impl',)), FrozenPlan(fields=('impl',), allow_dynamic_dunder_attrs=False), InitPla"
+        "n(fields=(InitPlan.Field(name='impl', annotation=OpRef(name='init.fields.0.annotation'), default=None, default"
+        "_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_typ"
+        "e=None),), self_param='self', std_params=('impl',), kw_only_params=(), frozen=True, slots=False, post_init_par"
+        "ams=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='impl', kw_only=False, fn=None),"
+        "), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='95e8d2726657f6c6d0abe6bace53f80710e3d314',
+    plan_repr_sha1='8e1f31f368d04d4784c49dcc2d91408279e36285',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Eager'),
-        ('omlish.inject.binder', 'Expose'),
+        ('omlish.inject.impl.bindings', 'InternalProvider'),
     ),
 )
-def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
+def _process_dataclass__8e1f31f368d04d4784c49dcc2d91408279e36285():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -3127,7 +3443,7 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                key=self.key,
+                impl=self.impl,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -3135,22 +3451,8 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.key == other.key
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
         __dataclass___setattr_frozen_fields = {
-            'key',
+            'impl',
         }
 
         def __setattr__(self, name, value):
@@ -3167,7 +3469,7 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'key',
+            'impl',
         }
 
         def __delattr__(self, name):
@@ -3183,30 +3485,11 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.key,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
-            key: __dataclass__init__fields__0__annotation,
+            impl: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            key = __dataclass__init__fields__0__coerce(key)
-            __dataclass__object_setattr(self, 'key', key)
-            self.__post_init__()
+            __dataclass__object_setattr(self, 'impl', impl)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3216,7 +3499,7 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key={self.key!r}")
+            parts.append(f"impl={self.impl!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3233,29 +3516,26 @@ def _process_dataclass__95e8d2726657f6c6d0abe6bace53f80710e3d314():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('scope',)), EqPlan(fields=('scope',)), FrozenPlan(fields=('scope',), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('scope',), cache=True), InitPlan(fields=(InitPlan.Field(n"
-        "ame='scope', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True,"
-        " override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, chec"
-        "k_type=None),), self_param='self', std_params=('scope',), kw_only_params=(), frozen=True, slots=False, post_in"
-        "it_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='scope', kw_only=False, fn=N"
-        "one),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('es',)), FrozenPlan(fields=('es',), allow_dynamic_dunder_attrs=False), InitPlan(fi"
+        "elds=(InitPlan.Field(name='es', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_facto"
+        "ry=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None"
+        "),), self_param='self', std_params=('es',), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
+        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='es', kw_only=False, fn=None),), id=Fals"
+        "e, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='a01535be51a62c3aedc3529e0204c6135d8d9e99',
+    plan_repr_sha1='23940adf5b02820a6f9975e06728e5b58b744320',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'ScopeBinding'),
+        ('omlish.inject.impl.elements', 'MapProviderImpl'),
     ),
 )
-def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
+def _process_dataclass__23940adf5b02820a6f9975e06728e5b58b744320():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -3274,7 +3554,7 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                scope=self.scope,
+                es=self.es,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -3282,22 +3562,8 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.scope == other.scope
-            )
-
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
         __dataclass___setattr_frozen_fields = {
-            'scope',
+            'es',
         }
 
         def __setattr__(self, name, value):
@@ -3314,7 +3580,7 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'scope',
+            'es',
         }
 
         def __delattr__(self, name):
@@ -3330,30 +3596,11 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
-        def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.scope,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
         def __init__(
             self,
-            scope: __dataclass__init__fields__0__annotation,
+            es: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            scope = __dataclass__init__fields__0__coerce(scope)
-            __dataclass__object_setattr(self, 'scope', scope)
-            self.__post_init__()
+            __dataclass__object_setattr(self, 'es', es)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3363,7 +3610,7 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"scope={self.scope!r}")
+            parts.append(f"es={self.es!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3380,30 +3627,34 @@ def _process_dataclass__a01535be51a62c3aedc3529e0204c6135d8d9e99():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('pik', 'k')), InitPlan(fields=(InitPlan.Field(name='pik', annotation=OpRef(name='i"
-        "nit.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType"
-        ".INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='k', annotation=OpRef(name='init."
-        "fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INS"
-        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('pik', 'k'), kw_only_para"
-        "ms=(), frozen=False, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprP"
-        "lan.Field(name='pik', kw_only=False, fn=None), ReprPlan.Field(name='k', kw_only=False, fn=None)), id=False, te"
-        "rse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('seeds', 'prvs')), EqPlan(fields=('seeds', 'prvs')), FrozenPlan(fields=('seeds', '"
+        "prvs'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('seeds', 'prvs'), cache=False), Init"
+        "Plan(fields=(InitPlan.Field(name='seeds', annotation=OpRef(name='init.fields.0.annotation'), default=None, def"
+        "ault_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check"
+        "_type=None), InitPlan.Field(name='prvs', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
+        "ult_factory=OpRef(name='init.fields.1.default_factory'), init=True, override=False, field_type=FieldType.INSTA"
+        "NCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('seeds', 'prvs'), kw_only_p"
+        "arams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(Rep"
+        "rPlan.Field(name='seeds', kw_only=False, fn=None), ReprPlan.Field(name='prvs', kw_only=False, fn=None)), id=Fa"
+        "lse, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='a0f40dc1d602e06fadec23a1aa53c8d57356f22f',
+    plan_repr_sha1='61f34069d7091014f66ca9e1c1d27dbbc1a4e03f',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__default_factory',
     ),
     cls_names=(
-        ('omlish.inject.impl.privates', 'ExposedPrivateProviderImpl'),
+        ('omlish.inject.impl.elements', 'SeededScopeImpl.State'),
     ),
 )
-def _process_dataclass__a0f40dc1d602e06fadec23a1aa53c8d57356f22f():
+def _process_dataclass__61f34069d7091014f66ca9e1c1d27dbbc1a4e03f():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__default_factory,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -3422,22 +3673,84 @@ def _process_dataclass__a0f40dc1d602e06fadec23a1aa53c8d57356f22f():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                pik=self.pik,
-                k=self.k,
+                seeds=self.seeds,
+                prvs=self.prvs,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.seeds == other.seeds and
+                self.prvs == other.prvs
             )
 
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'seeds',
+            'prvs',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'seeds',
+            'prvs',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.seeds,
+                self.prvs,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            pik: __dataclass__init__fields__0__annotation,
-            k: __dataclass__init__fields__1__annotation,
+            seeds: __dataclass__init__fields__0__annotation,
+            prvs: __dataclass__init__fields__1__annotation = __dataclass__HAS_DEFAULT_FACTORY,
         ) -> __dataclass__None:
-            self.pik = pik
-            self.k = k
+            if prvs is __dataclass__HAS_DEFAULT_FACTORY:
+                prvs = __dataclass__init__fields__1__default_factory()
+            __dataclass__object_setattr(self, 'seeds', seeds)
+            __dataclass__object_setattr(self, 'prvs', prvs)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3447,8 +3760,8 @@ def _process_dataclass__a0f40dc1d602e06fadec23a1aa53c8d57356f22f():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"pik={self.pik!r}")
-            parts.append(f"k={self.k!r}")
+            parts.append(f"seeds={self.seeds!r}")
+            parts.append(f"prvs={self.prvs!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3576,25 +3889,25 @@ def _process_dataclass__b721abb54732f14a7bceaf230a932d37b1a8ee48():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('id', 'ec')), InitPlan(fields=(InitPlan.Field(name='id', annotation=OpRef(name='in"
-        "it.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType."
-        "INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='ec', annotation=OpRef(name='init."
+        "Plans(tup=(CopyPlan(fields=('pik', 'k')), InitPlan(fields=(InitPlan.Field(name='pik', annotation=OpRef(name='i"
+        "nit.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType"
+        ".INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='k', annotation=OpRef(name='init."
         "fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INS"
-        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('id', 'ec'), kw_only_para"
+        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('pik', 'k'), kw_only_para"
         "ms=(), frozen=False, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprP"
-        "lan.Field(name='id', kw_only=False, fn=None), ReprPlan.Field(name='ec', kw_only=False, fn=None)), id=False, te"
+        "lan.Field(name='pik', kw_only=False, fn=None), ReprPlan.Field(name='k', kw_only=False, fn=None)), id=False, te"
         "rse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674',
+    plan_repr_sha1='a0f40dc1d602e06fadec23a1aa53c8d57356f22f',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.inject.impl.privates', 'PrivateInjectorProviderImpl'),
+        ('omlish.inject.impl.privates', 'ExposedPrivateProviderImpl'),
     ),
 )
-def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
+def _process_dataclass__a0f40dc1d602e06fadec23a1aa53c8d57356f22f():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -3618,8 +3931,8 @@ def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                id=self.id,
-                ec=self.ec,
+                pik=self.pik,
+                k=self.k,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -3629,11 +3942,11 @@ def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
 
         def __init__(
             self,
-            id: __dataclass__init__fields__0__annotation,
-            ec: __dataclass__init__fields__1__annotation,
+            pik: __dataclass__init__fields__0__annotation,
+            k: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            self.id = id
-            self.ec = ec
+            self.pik = pik
+            self.k = k
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3643,8 +3956,8 @@ def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"id={self.id!r}")
-            parts.append(f"ec={self.ec!r}")
+            parts.append(f"pik={self.pik!r}")
+            parts.append(f"k={self.k!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -3661,36 +3974,31 @@ def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('src', 'ovr')), EqPlan(fields=('src', 'ovr')), FrozenPlan(fields=('src', 'ovr'), a"
-        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('src', 'ovr'), cache=True), InitPlan(fields=("
-        "InitPlan.Field(name='src', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=No"
-        "ne, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), valid"
-        "ate=None, check_type=None), InitPlan.Field(name='ovr', annotation=OpRef(name='init.fields.1.annotation'), defa"
-        "ult=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='i"
-        "nit.fields.1.coerce'), validate=None, check_type=None)), self_param='self', std_params=('src', 'ovr'), kw_only"
-        "_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(Rep"
-        "rPlan.Field(name='src', kw_only=False, fn=None), ReprPlan.Field(name='ovr', kw_only=False, fn=None)), id=False"
-        ", terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('owner', 'p')), EqPlan(fields=('owner', 'p')), FrozenPlan(fields=('owner', 'p'), a"
+        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('owner', 'p'), cache=False), InitPlan(fields="
+        "(InitPlan.Field(name='owner', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory"
+        "=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),"
+        " InitPlan.Field(name='p', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=Non"
+        "e, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), se"
+        "lf_param='self', std_params=('owner', 'p'), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
+        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='owner', kw_only=False, fn=None), ReprPl"
+        "an.Field(name='p', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='c35199aac6d207aea4ae186fa99b44f431914e53',
+    plan_repr_sha1='0f6ba4c593adbc50913cf38fc7c075e91843dbde',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__coerce',
     ),
     cls_names=(
-        ('omlish.inject.overrides', 'Overrides'),
+        ('omlish.inject.impl.privates', 'PrivateInfo'),
     ),
 )
-def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
+def _process_dataclass__0f6ba4c593adbc50913cf38fc7c075e91843dbde():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -3709,8 +4017,8 @@ def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                src=self.src,
-                ovr=self.ovr,
+                owner=self.owner,
+                p=self.p,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -3724,8 +4032,8 @@ def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.src == other.src and
-                self.ovr == other.ovr
+                self.owner == other.owner and
+                self.p == other.p
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -3734,8 +4042,8 @@ def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'src',
-            'ovr',
+            'owner',
+            'p',
         }
 
         def __setattr__(self, name, value):
@@ -3752,8 +4060,8 @@ def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'src',
-            'ovr',
+            'owner',
+            'p',
         }
 
         def __delattr__(self, name):
@@ -3770,145 +4078,21 @@ def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            try:
-                return self.__dataclass_hash__
-            except AttributeError:
-                pass
-            object.__setattr__(
-                self,
-                '__dataclass_hash__',
-                h := hash((
-                    self.src,
-                    self.ovr,
-                ))
-            )
-            return h
+            return hash((
+                self.owner,
+                self.p,
+            ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            src: __dataclass__init__fields__0__annotation,
-            ovr: __dataclass__init__fields__1__annotation,
-        ) -> __dataclass__None:
-            src = __dataclass__init__fields__0__coerce(src)
-            ovr = __dataclass__init__fields__1__coerce(ovr)
-            __dataclass__object_setattr(self, 'src', src)
-            __dataclass__object_setattr(self, 'ovr', ovr)
-            self.__post_init__()
-
-        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
-        if '__init__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__init__', __init__)
-
-        @__dataclass___recursive_repr()
-        def __repr__(self):
-            parts = []
-            parts.append(f"src={self.src!r}")
-            parts.append(f"ovr={self.ovr!r}")
-            return (
-                f"{self.__class__.__qualname__}("
-                f"{', '.join(parts)}"
-                f")"
-            )
-
-        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
-        if '__repr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__repr__', __repr__)
-
-    return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('vs',)), FrozenPlan(fields=('vs',), allow_dynamic_dunder_attrs=False), InitPlan(fi"
-        "elds=(InitPlan.Field(name='vs', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_facto"
-        "ry=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None"
-        "),), self_param='self', std_params=('vs',), kw_only_params=(), frozen=True, slots=False, post_init_params=None"
-        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='vs', kw_only=False, fn=None),), id=Fals"
-        "e, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='c4cee7449949f8c11b10dcaf6b91f62f28a6fd18',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-    ),
-    cls_names=(
-        ('omlish.inject.helpers.multis', 'ItemsBinderHelper._ItemsBox'),
-    ),
-)
-def _process_dataclass__c4cee7449949f8c11b10dcaf6b91f62f28a6fd18():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__FieldFnValidationError,  # noqa
-        __dataclass__FieldTypeValidationError,  # noqa
-        __dataclass__FnValidationError,  # noqa
-        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
-        __dataclass__FunctionType=types.FunctionType,  # noqa
-        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
-        __dataclass__MISSING=dataclasses.MISSING,  # noqa
-        __dataclass__None=None,  # noqa
-        __dataclass__TypeError=TypeError,  # noqa
-        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
-        __dataclass__isinstance=isinstance,  # noqa
-        __dataclass__object_setattr=object.__setattr__,  # noqa
-        __dataclass__property=property,  # noqa
-    ):
-        def __copy__(self):
-            if self.__class__ is not __dataclass__cls:
-                raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                vs=self.vs,
-            )
-
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
-
-        __dataclass___setattr_frozen_fields = {
-            'vs',
-        }
-
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        __dataclass___delattr_frozen_fields = {
-            'vs',
-        }
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
-        def __init__(
-            self,
-            vs: __dataclass__init__fields__0__annotation,
+            owner: __dataclass__init__fields__0__annotation,
+            p: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'vs', vs)
+            __dataclass__object_setattr(self, 'owner', owner)
+            __dataclass__object_setattr(self, 'p', p)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -3918,7 +4102,8 @@ def _process_dataclass__c4cee7449949f8c11b10dcaf6b91f62f28a6fd18():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"vs={self.vs!r}")
+            parts.append(f"owner={self.owner!r}")
+            parts.append(f"p={self.p!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4069,21 +4254,30 @@ def _process_dataclass__c5f6a36b3a0205325ea2602947f4888237a21382():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), InitPlan(fields=(), s"
-        "elf_param='self', std_params=(), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns="
-        "(), validate_fns=()), ReprPlan(fields=(), id=True, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('id', 'ec')), InitPlan(fields=(InitPlan.Field(name='id', annotation=OpRef(name='in"
+        "it.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType."
+        "INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='ec', annotation=OpRef(name='init."
+        "fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INS"
+        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('id', 'ec'), kw_only_para"
+        "ms=(), frozen=False, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprP"
+        "lan.Field(name='id', kw_only=False, fn=None), ReprPlan.Field(name='ec', kw_only=False, fn=None)), id=False, te"
+        "rse=False, default_fn=None)))"
+    ),
+    plan_repr_sha1='bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
     ),
-    plan_repr_sha1='c726b62427445e76234a6a472593ae91ca8d6457',
-    op_ref_idents=(),
     cls_names=(
-        ('omlish.inject.helpers.multis', 'ItemsBinderHelper._ItemTag'),
-        ('omlish.inject.helpers.wrappers', 'WrapperBinderHelper._Root'),
+        ('omlish.inject.impl.privates', 'PrivateInjectorProviderImpl'),
     ),
 )
-def _process_dataclass__c726b62427445e76234a6a472593ae91ca8d6457():
+def _process_dataclass__bbf0fd5802ba5ae35dd7ebcd29d05cb860a10674():
     def _process_dataclass(
         *,
         __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4101,41 +4295,23 @@ def _process_dataclass__c726b62427445e76234a6a472593ae91ca8d6457():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls()  # noqa
+            return __dataclass__cls(  # noqa
+                id=self.id,
+                ec=self.ec,
+            )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
         if '__copy__' in __dataclass__cls.__dict__:
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
-        def __setattr__(self, name, value):
-            if (
-                type(self) is __dataclass__cls
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
-            super(__dataclass__cls, self).__setattr__(name, value)
-
-        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
-        if '__setattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__setattr__', __setattr__)
-
-        def __delattr__(self, name):
-            if (
-                type(self) is __dataclass__cls
-            ):
-                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
-            super(__dataclass__cls, self).__delattr__(name)
-
-        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
-        if '__delattr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__delattr__', __delattr__)
-
         def __init__(
             self,
+            id: __dataclass__init__fields__0__annotation,
+            ec: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            pass
+            self.id = id
+            self.ec = ec
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4145,8 +4321,10 @@ def _process_dataclass__c726b62427445e76234a6a472593ae91ca8d6457():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
+            parts.append(f"id={self.id!r}")
+            parts.append(f"ec={self.ec!r}")
             return (
-                f"{self.__class__.__qualname__}@{hex(id(self))[2:]}("
+                f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
                 f")"
             )
@@ -4161,29 +4339,27 @@ def _process_dataclass__c726b62427445e76234a6a472593ae91ca8d6457():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('ty',)), EqPlan(fields=('ty',)), FrozenPlan(fields=('ty',), allow_dynamic_dunder_a"
-        "ttrs=False), HashPlan(action='add', fields=('ty',), cache=True), InitPlan(fields=(InitPlan.Field(name='ty', an"
-        "notation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False"
-        ", field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=None),),"
-        " self_param='self', std_params=('ty',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, in"
-        "it_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='ty', kw_only=False, fn=None),), id=False, t"
-        "erse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('listener',)), EqPlan(fields=('listener',)), FrozenPlan(fields=('listener',), allo"
+        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('listener',), cache=True), InitPlan(fields=(Init"
+        "Plan.Field(name='listener', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=N"
+        "one, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),),"
+        " self_param='self', std_params=('listener',), kw_only_params=(), frozen=True, slots=False, post_init_params=()"
+        ", init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='listener', kw_only=False, fn=None),), i"
+        "d=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='d152f7efec7ea241cf364f9c170bbe40950b82d9',
+    plan_repr_sha1='01ca4dd7c51876d086eb4230f400151c659e0842',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'CtorProvider'),
+        ('omlish.inject.listeners', 'ProvisionListenerBinding'),
     ),
 )
-def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
+def _process_dataclass__01ca4dd7c51876d086eb4230f400151c659e0842():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4202,7 +4378,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                ty=self.ty,
+                listener=self.listener,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4216,7 +4392,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.ty == other.ty
+                self.listener == other.listener
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4225,7 +4401,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'ty',
+            'listener',
         }
 
         def __setattr__(self, name, value):
@@ -4242,7 +4418,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'ty',
+            'listener',
         }
 
         def __delattr__(self, name):
@@ -4267,7 +4443,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.ty,
+                    self.listener,
                 ))
             )
             return h
@@ -4277,10 +4453,10 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
 
         def __init__(
             self,
-            ty: __dataclass__init__fields__0__annotation,
+            listener: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            ty = __dataclass__init__fields__0__coerce(ty)
-            __dataclass__object_setattr(self, 'ty', ty)
+            __dataclass__object_setattr(self, 'listener', listener)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4290,7 +4466,7 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"ty={self.ty!r}")
+            parts.append(f"listener={self.listener!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4307,28 +4483,41 @@ def _process_dataclass__d152f7efec7ea241cf364f9c170bbe40950b82d9():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('lst',)), EqPlan(fields=('lst',)), FrozenPlan(fields=('lst',), allow_dynamic_dunde"
-        "r_attrs=False), HashPlan(action='add', fields=('lst',), cache=True), InitPlan(fields=(InitPlan.Field(name='lst"
-        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
-        "False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self', std_p"
-        "arams=('lst',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns="
-        "()), ReprPlan(fields=(ReprPlan.Field(name='lst', kw_only=False, fn=None),), id=False, terse=False, default_fn="
-        "None)))"
+        "Plans(tup=(CopyPlan(fields=('multi_key', 'map_key', 'dst')), EqPlan(fields=('multi_key', 'map_key', 'dst')), F"
+        "rozenPlan(fields=('multi_key', 'map_key', 'dst'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
+        "elds=('multi_key', 'map_key', 'dst'), cache=True), InitPlan(fields=(InitPlan.Field(name='multi_key', annotatio"
+        "n=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field"
+        "_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fields.0.validate'), check_type=None), InitPl"
+        "an.Field(name='map_key', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None"
+        ", init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), Init"
+        "Plan.Field(name='dst', annotation=OpRef(name='init.fields.2.annotation'), default=None, default_factory=None, "
+        "init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.2.coerce'), validate="
+        "None, check_type=None)), self_param='self', std_params=('multi_key', 'map_key', 'dst'), kw_only_params=(), fro"
+        "zen=True, slots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(nam"
+        "e='multi_key', kw_only=False, fn=None), ReprPlan.Field(name='map_key', kw_only=False, fn=None), ReprPlan.Field"
+        "(name='dst', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='d1633dcd9bb962f0e548a4a63b764b808cdac621',
+    plan_repr_sha1='6ed12b80942097addba0fe978453312450cdf8d9',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__validate',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
+        '__dataclass__init__fields__2__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Origin'),
-        ('omlish.inject.binder', 'Origins'),
+        ('omlish.inject.multis', 'MapBinding'),
     ),
 )
-def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
+def _process_dataclass__6ed12b80942097addba0fe978453312450cdf8d9():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__validate,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
+        __dataclass__init__fields__2__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4347,7 +4536,9 @@ def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                lst=self.lst,
+                multi_key=self.multi_key,
+                map_key=self.map_key,
+                dst=self.dst,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4361,7 +4552,9 @@ def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.lst == other.lst
+                self.multi_key == other.multi_key and
+                self.map_key == other.map_key and
+                self.dst == other.dst
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4370,7 +4563,9 @@ def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'lst',
+            'multi_key',
+            'map_key',
+            'dst',
         }
 
         def __setattr__(self, name, value):
@@ -4387,7 +4582,9 @@ def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'lst',
+            'multi_key',
+            'map_key',
+            'dst',
         }
 
         def __delattr__(self, name):
@@ -4411,115 +4608,35 @@ def _process_dataclass__d1633dcd9bb962f0e548a4a63b764b808cdac621():
             object.__setattr__(
                 self,
                 '__dataclass_hash__',
-                h := hash((
-                    self.lst,
-                ))
-            )
-            return h
-
-        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
-        setattr(__dataclass__cls, '__hash__', __hash__)
-
-        def __init__(
-            self,
-            lst: __dataclass__init__fields__0__annotation,
-        ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'lst', lst)
-
-        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
-        if '__init__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__init__', __init__)
-
-        @__dataclass___recursive_repr()
-        def __repr__(self):
-            parts = []
-            parts.append(f"lst={self.lst!r}")
-            return (
-                f"{self.__class__.__qualname__}("
-                f"{', '.join(parts)}"
-                f")"
-            )
-
-        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
-        if '__repr__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__repr__', __repr__)
-
-    return _process_dataclass
-
-
-@_register(
-    plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('scope',)), EqPlan(fields=('scope',)), HashPlan(action='set_none', fields=None, ca"
-        "che=None), InitPlan(fields=(InitPlan.Field(name='scope', annotation=OpRef(name='init.fields.0.annotation'), de"
-        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
-        "ate=None, check_type=None),), self_param='self', std_params=('scope',), kw_only_params=(), frozen=False, slots"
-        "=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='scope', kw"
-        "_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='d43eaf7e550de17fc6936c19e4e5aa545c8a93d8',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-    ),
-    cls_names=(
-        ('omlish.inject.errors', 'ScopeAlreadyOpenError'),
-        ('omlish.inject.errors', 'ScopeError'),
-        ('omlish.inject.errors', 'ScopeNotOpenError'),
-    ),
-)
-def _process_dataclass__d43eaf7e550de17fc6936c19e4e5aa545c8a93d8():
-    def _process_dataclass(
-        *,
-        __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__FieldFnValidationError,  # noqa
-        __dataclass__FieldTypeValidationError,  # noqa
-        __dataclass__FnValidationError,  # noqa
-        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
-        __dataclass__FunctionType=types.FunctionType,  # noqa
-        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
-        __dataclass__MISSING=dataclasses.MISSING,  # noqa
-        __dataclass__None=None,  # noqa
-        __dataclass__TypeError=TypeError,  # noqa
-        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
-        __dataclass__isinstance=isinstance,  # noqa
-        __dataclass__object_setattr=object.__setattr__,  # noqa
-        __dataclass__property=property,  # noqa
-    ):
-        def __copy__(self):
-            if self.__class__ is not __dataclass__cls:
-                raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                scope=self.scope,
-            )
-
-        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
-        if '__copy__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__copy__', __copy__)
-
-        def __eq__(self, other):
-            if self is other:
-                return True
-            if self.__class__ is not other.__class__:
-                return NotImplemented
-            return (
-                self.scope == other.scope
+                h := hash((
+                    self.multi_key,
+                    self.map_key,
+                    self.dst,
+                ))
             )
+            return h
 
-        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
-        if '__eq__' in __dataclass__cls.__dict__:
-            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
-        setattr(__dataclass__cls, '__eq__', __eq__)
-
-        setattr(__dataclass__cls, '__hash__', None)
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            scope: __dataclass__init__fields__0__annotation,
+            multi_key: __dataclass__init__fields__0__annotation,
+            map_key: __dataclass__init__fields__1__annotation,
+            dst: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            self.scope = scope
+            dst = __dataclass__init__fields__2__coerce(dst)
+            if not __dataclass__init__fields__0__validate(multi_key): 
+                raise __dataclass__FieldFnValidationError(
+                    obj=self,
+                    fn=__dataclass__init__fields__0__validate,
+                    field='multi_key',
+                    value=multi_key,
+                )
+            __dataclass__object_setattr(self, 'multi_key', multi_key)
+            __dataclass__object_setattr(self, 'map_key', map_key)
+            __dataclass__object_setattr(self, 'dst', dst)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4529,7 +4646,9 @@ def _process_dataclass__d43eaf7e550de17fc6936c19e4e5aa545c8a93d8():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"scope={self.scope!r}")
+            parts.append(f"multi_key={self.multi_key!r}")
+            parts.append(f"map_key={self.map_key!r}")
+            parts.append(f"dst={self.dst!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4546,29 +4665,30 @@ def _process_dataclass__d43eaf7e550de17fc6936c19e4e5aa545c8a93d8():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('tag',)), EqPlan(fields=('tag',)), FrozenPlan(fields=('tag',), allow_dynamic_dunde"
-        "r_attrs=False), HashPlan(action='add', fields=('tag',), cache=True), InitPlan(fields=(InitPlan.Field(name='tag"
-        "', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override="
-        "False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=None, check_type=Non"
-        "e),), self_param='self', std_params=('tag',), kw_only_params=(), frozen=True, slots=False, post_init_params=No"
-        "ne, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='tag', kw_only=False, fn=None),), id=F"
-        "alse, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('multi_key',)), EqPlan(fields=('multi_key',)), FrozenPlan(fields=('multi_key',), a"
+        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('multi_key',), cache=True), InitPlan(fields=("
+        "InitPlan.Field(name='multi_key', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_fact"
+        "ory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=OpRef(name='init.fie"
+        "lds.0.validate'), check_type=None),), self_param='self', std_params=('multi_key',), kw_only_params=(), frozen="
+        "True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name="
+        "'multi_key', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='e3da1b32863a0a4aca9ff268877a77ad5d6dd328',
+    plan_repr_sha1='864a29bd231d03e4f0141a4dc7872a66df50771d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__validate',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'SeededScope'),
+        ('omlish.inject.multis', 'MapProvider'),
+        ('omlish.inject.multis', 'SetProvider'),
     ),
 )
-def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
+def _process_dataclass__864a29bd231d03e4f0141a4dc7872a66df50771d():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__validate,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4587,7 +4707,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                tag=self.tag,
+                multi_key=self.multi_key,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4601,7 +4721,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.tag == other.tag
+                self.multi_key == other.multi_key
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4610,7 +4730,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'tag',
+            'multi_key',
         }
 
         def __setattr__(self, name, value):
@@ -4627,7 +4747,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'tag',
+            'multi_key',
         }
 
         def __delattr__(self, name):
@@ -4652,7 +4772,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.tag,
+                    self.multi_key,
                 ))
             )
             return h
@@ -4662,10 +4782,16 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
 
         def __init__(
             self,
-            tag: __dataclass__init__fields__0__annotation,
+            multi_key: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            tag = __dataclass__init__fields__0__coerce(tag)
-            __dataclass__object_setattr(self, 'tag', tag)
+            if not __dataclass__init__fields__0__validate(multi_key): 
+                raise __dataclass__FieldFnValidationError(
+                    obj=self,
+                    fn=__dataclass__init__fields__0__validate,
+                    field='multi_key',
+                    value=multi_key,
+                )
+            __dataclass__object_setattr(self, 'multi_key', multi_key)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4675,7 +4801,7 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"tag={self.tag!r}")
+            parts.append(f"multi_key={self.multi_key!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4692,40 +4818,36 @@ def _process_dataclass__e3da1b32863a0a4aca9ff268877a77ad5d6dd328():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('ty', 'tag')), EqPlan(fields=('ty', 'tag')), FrozenPlan(fields=('ty', 'tag'), allo"
-        "w_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('ty', 'tag'), cache=True), InitPlan(fields=(Init"
-        "Plan.Field(name='ty', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, i"
-        "nit=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), validate=N"
-        "one, check_type=None), InitPlan.Field(name='tag', annotation=OpRef(name='init.fields.1.annotation'), default=O"
-        "pRef(name='init.fields.1.default'), default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=None, validate=OpRef(name='init.fields.1.validate'), check_type=None)), self_param='self', std_pa"
-        "rams=('ty',), kw_only_params=('tag',), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_"
-        "fns=()), ReprPlan(fields=(ReprPlan.Field(name='ty', kw_only=False, fn=None), ReprPlan.Field(name='tag', kw_onl"
-        "y=True, fn=OpRef(name='repr.fns.1.fn'))), id=False, terse=True, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('multi_key', 'dst')), EqPlan(fields=('multi_key', 'dst')), FrozenPlan(fields=('mul"
+        "ti_key', 'dst'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('multi_key', 'dst'), cache="
+        "True), InitPlan(fields=(InitPlan.Field(name='multi_key', annotation=OpRef(name='init.fields.0.annotation'), de"
+        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
+        "ate=OpRef(name='init.fields.0.validate'), check_type=None), InitPlan.Field(name='dst', annotation=OpRef(name='"
+        "init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldTyp"
+        "e.INSTANCE, coerce=OpRef(name='init.fields.1.coerce'), validate=None, check_type=None)), self_param='self', st"
+        "d_params=('multi_key', 'dst'), kw_only_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), "
+        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='multi_key', kw_only=False, fn=None), ReprPlan.Field(na"
+        "me='dst', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2',
+    plan_repr_sha1='1ba38fd546769fabc04fa41bd279c7fcbbad22f2',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__0__coerce',
+        '__dataclass__init__fields__0__validate',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__1__default',
-        '__dataclass__init__fields__1__validate',
-        '__dataclass__repr__fns__1__fn',
+        '__dataclass__init__fields__1__coerce',
     ),
     cls_names=(
-        ('omlish.inject.binder', 'Key'),
+        ('omlish.inject.multis', 'SetBinding'),
     ),
 )
-def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
+def _process_dataclass__1ba38fd546769fabc04fa41bd279c7fcbbad22f2():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__0__coerce,
+        __dataclass__init__fields__0__validate,
         __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__1__default,
-        __dataclass__init__fields__1__validate,
-        __dataclass__repr__fns__1__fn,
+        __dataclass__init__fields__1__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4744,8 +4866,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                ty=self.ty,
-                tag=self.tag,
+                multi_key=self.multi_key,
+                dst=self.dst,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4759,8 +4881,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.ty == other.ty and
-                self.tag == other.tag
+                self.multi_key == other.multi_key and
+                self.dst == other.dst
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -4769,8 +4891,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'ty',
-            'tag',
+            'multi_key',
+            'dst',
         }
 
         def __setattr__(self, name, value):
@@ -4787,8 +4909,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'ty',
-            'tag',
+            'multi_key',
+            'dst',
         }
 
         def __delattr__(self, name):
@@ -4813,8 +4935,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
                 self,
                 '__dataclass_hash__',
                 h := hash((
-                    self.ty,
-                    self.tag,
+                    self.multi_key,
+                    self.dst,
                 ))
             )
             return h
@@ -4824,20 +4946,20 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
 
         def __init__(
             self,
-            ty: __dataclass__init__fields__0__annotation,
-            *,
-            tag: __dataclass__init__fields__1__annotation = __dataclass__init__fields__1__default,
+            multi_key: __dataclass__init__fields__0__annotation,
+            dst: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            ty = __dataclass__init__fields__0__coerce(ty)
-            if not __dataclass__init__fields__1__validate(tag): 
+            dst = __dataclass__init__fields__1__coerce(dst)
+            if not __dataclass__init__fields__0__validate(multi_key): 
                 raise __dataclass__FieldFnValidationError(
                     obj=self,
-                    fn=__dataclass__init__fields__1__validate,
-                    field='tag',
-                    value=tag,
+                    fn=__dataclass__init__fields__0__validate,
+                    field='multi_key',
+                    value=multi_key,
                 )
-            __dataclass__object_setattr(self, 'ty', ty)
-            __dataclass__object_setattr(self, 'tag', tag)
+            __dataclass__object_setattr(self, 'multi_key', multi_key)
+            __dataclass__object_setattr(self, 'dst', dst)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4847,9 +4969,8 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"{self.ty!r}")
-            if (s := __dataclass__repr__fns__1__fn(self.tag)) is not None:
-                parts.append(f"tag={s}")
+            parts.append(f"multi_key={self.multi_key!r}")
+            parts.append(f"dst={self.dst!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -4866,31 +4987,36 @@ def _process_dataclass__e780a7b78a8d3e5c6ddd87c0bc5ae50bda8d0db2():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('p', 'kt')), FrozenPlan(fields=('p', 'kt'), allow_dynamic_dunder_attrs=False), Ini"
-        "tPlan(fields=(InitPlan.Field(name='p', annotation=OpRef(name='init.fields.0.annotation'), default=None, defaul"
-        "t_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_ty"
-        "pe=None), InitPlan.Field(name='kt', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
-        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
-        "None)), self_param='self', std_params=('p', 'kt'), kw_only_params=(), frozen=True, slots=False, post_init_para"
-        "ms=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='p', kw_only=False, fn=None), Rep"
-        "rPlan.Field(name='kt', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('src', 'ovr')), EqPlan(fields=('src', 'ovr')), FrozenPlan(fields=('src', 'ovr'), a"
+        "llow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('src', 'ovr'), cache=True), InitPlan(fields=("
+        "InitPlan.Field(name='src', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=No"
+        "ne, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='init.fields.0.coerce'), valid"
+        "ate=None, check_type=None), InitPlan.Field(name='ovr', annotation=OpRef(name='init.fields.1.annotation'), defa"
+        "ult=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=OpRef(name='i"
+        "nit.fields.1.coerce'), validate=None, check_type=None)), self_param='self', std_params=('src', 'ovr'), kw_only"
+        "_params=(), frozen=True, slots=False, post_init_params=(), init_fns=(), validate_fns=()), ReprPlan(fields=(Rep"
+        "rPlan.Field(name='src', kw_only=False, fn=None), ReprPlan.Field(name='ovr', kw_only=False, fn=None)), id=False"
+        ", terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='fd0f4351f533bc90a8c6f24973004fcc1931cf0d',
+    plan_repr_sha1='c35199aac6d207aea4ae186fa99b44f431914e53',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__0__coerce',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__1__coerce',
     ),
     cls_names=(
-        ('omlish.inject.impl.bindings', 'AsyncCallableProviderImpl'),
-        ('omlish.inject.impl.bindings', 'CallableProviderImpl'),
+        ('omlish.inject.overrides', 'Overrides'),
     ),
 )
-def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
+def _process_dataclass__c35199aac6d207aea4ae186fa99b44f431914e53():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__0__coerce,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__1__coerce,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -4909,8 +5035,8 @@ def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                p=self.p,
-                kt=self.kt,
+                src=self.src,
+                ovr=self.ovr,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -4918,9 +5044,24 @@ def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__copy__', __copy__)
 
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.src == other.src and
+                self.ovr == other.ovr
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
         __dataclass___setattr_frozen_fields = {
-            'p',
-            'kt',
+            'src',
+            'ovr',
         }
 
         def __setattr__(self, name, value):
@@ -4937,8 +5078,8 @@ def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'p',
-            'kt',
+            'src',
+            'ovr',
         }
 
         def __delattr__(self, name):
@@ -4954,13 +5095,34 @@ def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
+        def __hash__(self):
+            try:
+                return self.__dataclass_hash__
+            except AttributeError:
+                pass
+            object.__setattr__(
+                self,
+                '__dataclass_hash__',
+                h := hash((
+                    self.src,
+                    self.ovr,
+                ))
+            )
+            return h
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
         def __init__(
             self,
-            p: __dataclass__init__fields__0__annotation,
-            kt: __dataclass__init__fields__1__annotation,
+            src: __dataclass__init__fields__0__annotation,
+            ovr: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'p', p)
-            __dataclass__object_setattr(self, 'kt', kt)
+            src = __dataclass__init__fields__0__coerce(src)
+            ovr = __dataclass__init__fields__1__coerce(ovr)
+            __dataclass__object_setattr(self, 'src', src)
+            __dataclass__object_setattr(self, 'ovr', ovr)
+            self.__post_init__()
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -4970,8 +5132,8 @@ def _process_dataclass__fd0f4351f533bc90a8c6f24973004fcc1931cf0d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"p={self.p!r}")
-            parts.append(f"kt={self.kt!r}")
+            parts.append(f"src={self.src!r}")
+            parts.append(f"ovr={self.ovr!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"