diff --git a/src/main/ts/di/ActivationContext.ts b/src/main/ts/di/ActivationContext.ts
--- a/src/main/ts/di/ActivationContext.ts
+++ b/src/main/ts/di/ActivationContext.ts
@@ -1,17 +1,16 @@
 import { TraceSource } from "../log/TraceSource";
 import { argumentNotNull, argumentNotEmptyString } from "../safe";
-import { Descriptor, ContainerProvided, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+import { Descriptor, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
 import { Container } from "./Container";
 import { MapOf } from "../interfaces";
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
-export interface ActivationContextInfo<S extends object> {
+export interface ActivationContextInfo {
     name: string;
 
     service: string;
 
-    scope: ContainerServiceMap<S>;
 }
 
 export class ActivationContext<S extends object> {
@@ -19,32 +18,33 @@ export class ActivationContext<S extends
 
     _services: ContainerServiceMap<S>;
 
-    _stack: ActivationContextInfo<S>[];
-
     _visited: MapOf<any>;
 
     _name: string;
 
-    _localized: boolean = false;
+    _service: Descriptor<S, any>;
 
-    container: Container<S>;
+    _container: Container<S>;
+
+    _parent: ActivationContext<S> | undefined;
 
-    constructor(container: Container<S>, services: ContainerServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
-        argumentNotNull(container, "container");
-        argumentNotNull(services, "services");
-
-        this._name = name || "<unnamed>";
-        this._visited = visited || {};
-        this._stack = [];
-        this._cache = cache || {};
+    constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
+        this._name = name;
+        this._service = service;
+        this._visited = {};
+        this._cache = {};
         this._services = services;
-        this.container = container;
+        this._container = container;
     }
 
     getName() {
         return this._name;
     }
 
+    getContainer() {
+        return this._container;
+    }
+
     resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
         const d = this._services[name];
 
@@ -70,16 +70,6 @@ export class ActivationContext<S extends
         this._services[name] = service as any;
     }
 
-    clone() {
-        return new ActivationContext<S>(
-            this.container,
-            this._services,
-            this._name,
-            this._cache,
-            this._visited
-        );
-    }
-
     has(id: string) {
         return id in this._cache;
     }
@@ -96,9 +86,8 @@ export class ActivationContext<S extends
         if (trace.isLogEnabled())
             trace.log(`enter ${name} ${d}`);
 
-        this.enter(name, d.toString());
-        const v = d.activate(this);
-        this.leave();
+        const ctx = this.enter(d, name);
+        const v = d.activate(ctx);
 
         if (trace.isLogEnabled())
             trace.log(`leave ${name}`);
@@ -112,27 +101,23 @@ export class ActivationContext<S extends
         return count;
     }
 
-    getStack() {
-        return this._stack.slice().reverse();
+    getStack(): ActivationContextInfo[] {
+        const stack = [{
+            name: this._name,
+            service: this._service.toString()
+        }];
+
+        return this._parent ?
+            stack.concat(this._parent.getStack()) :
+            stack;
     }
 
-    private enter(name: string, service: string) {
-        this._stack.push({
-            name,
-            service,
-            scope: this._services
-        });
-        this._name = name;
-        this._services = Object.create(this._services);
-    }
-
-    private leave() {
-        const ctx = this._stack.pop();
-        if (ctx) {
-            this._services = ctx.scope;
-            this._name = ctx.name;
-        } else {
-            trace.error("Trying to leave the last activation scope");
-        }
+    private enter(service: Descriptor<S, any>, name: string): this {
+        const clone = Object.create(this);
+        clone._name = name;
+        clone._services = Object.create(this._services);
+        clone._parent = this;
+        clone._service = service;
+        return clone;
     }
 }
diff --git a/src/main/ts/di/Container.ts b/src/main/ts/di/Container.ts
--- a/src/main/ts/di/Container.ts
+++ b/src/main/ts/di/Container.ts
@@ -1,12 +1,14 @@
 import { ActivationContext } from "./ActivationContext";
 import { ValueDescriptor } from "./ValueDescriptor";
 import { ActivationError } from "./ActivationError";
-import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve, ILifetimeManager } from "./interfaces";
 import { TraceSource } from "../log/TraceSource";
 import { Configuration, RegistrationMap } from "./Configuration";
 import { Cancellation } from "../Cancellation";
 import { MapOf, IDestroyable } from "../interfaces";
 import { isDescriptor } from "./traits";
+import { LifetimeManager } from "./LifetimeManager";
+import { each } from "../safe";
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
@@ -15,6 +17,8 @@ export class Container<S extends object 
 
     readonly _cache: MapOf<any>;
 
+    readonly _lifetimeManager: ILifetimeManager;
+
     readonly _cleanup: (() => void)[];
 
     readonly _root: Container<S>;
@@ -31,6 +35,7 @@ export class Container<S extends object 
         this._root = parent ? parent.getRootContainer() : this;
         this._services.container = new ValueDescriptor(this) as any;
         this._disposed = false;
+        this._lifetimeManager = new LifetimeManager();
     }
 
     getRootContainer() {
@@ -41,6 +46,10 @@ export class Container<S extends object 
         return this._parent;
     }
 
+    getLifetimeManager() {
+        return this._lifetimeManager;
+    }
+
     resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
         trace.debug("resolve {0}", name);
         const d = this._services[name];
@@ -51,9 +60,9 @@ export class Container<S extends object 
                 throw new Error("Service '" + name + "' isn't found");
         } else {
 
-            const context = new ActivationContext<S>(this, this._services);
+            const context = new ActivationContext<S>(this, this._services, String(name), d);
             try {
-                return context.activate(d, name.toString());
+                return d.activate(context);
             } catch (error) {
                 throw new ActivationError(name.toString(), context.getStack(), error);
             }
@@ -73,11 +82,7 @@ export class Container<S extends object 
         if (arguments.length === 1) {
             const data = nameOrCollection as ServiceMap<S>;
 
-            for (const name in data) {
-                if (Object.prototype.hasOwnProperty.call(data, name)) {
-                    this.register(name, data[name] as Descriptor<S, S[keyof S]>);
-                }
-            }
+            each(data, (v, k) => this.register(k, v));
         } else {
             if (!isDescriptor(service))
                 throw new Error("The service parameter must be a descriptor");
@@ -127,17 +132,4 @@ export class Container<S extends object 
     createChildContainer<S2 extends object = S>(): Container<S & S2> {
         return new Container<S & S2>(this as any);
     }
-
-    has(id: string | number) {
-        return id in this._cache;
-    }
-
-    get(id: string | number) {
-        return this._cache[id];
-    }
-
-    store(id: string | number, value: any) {
-        return (this._cache[id] = value);
-    }
-
 }
diff --git a/src/main/ts/di/LifetimeManager.ts b/src/main/ts/di/LifetimeManager.ts
--- a/src/main/ts/di/LifetimeManager.ts
+++ b/src/main/ts/di/LifetimeManager.ts
@@ -7,16 +7,35 @@ function safeCall(item: () => void) {
     try {
         item();
     } catch {
-        // silence
+        // silence!
     }
 }
 
+const emptyLifetime: ILifetime = {
+    has() {
+        return false;
+    },
+
+    enter() {
+
+    },
+
+    get() {
+        throw new Error("The specified item isn't registered with this lifetime manager");
+    },
+
+    store() {
+        // does nothing
+    }
+
+};
+
 export class LifetimeManager implements IDestroyable, ILifetimeManager {
     private _cleanup: (() => void)[] = [];
     private _cache: MapOf<any> = {};
     private _destroyed = false;
 
-    initialize(id: string, context: ActivationContext<any>): ILifetime {
+    initialize(id: string): ILifetime {
         const self = this;
         let pending = false;
         return {
@@ -58,12 +77,6 @@ export class LifetimeManager implements 
         };
     }
 
-
-
-
-
-
-
     destroy() {
         if (!this._destroyed) {
             this._destroyed = true;
@@ -73,20 +86,56 @@ export class LifetimeManager implements 
     }
 
     static readonly empty: ILifetimeManager = {
-        has() {
-            return false;
+        initialize(): ILifetime {
+            return emptyLifetime;
         },
+        destroy() {
+            throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
+        }
+
+    };
+
+    static readonly hierarchyLifetime: ILifetimeManager = {
+        initialize(id: string, context: ActivationContext<any>): ILifetime {
+            return context.getContainer().getLifetimeManager().initialize(id, context);
+        },
+        destroy() {
+            throw new Error("Trying to destroy hierarchy lifetime manager, this is a bug.");
+        }
+    };
 
-        get() {
-            throw new Error("The specified item isn't registered with this lifetime manager");
+    static readonly singletonLifetime: ILifetimeManager = {
+        initialize(id: string): ILifetime {
+            return singletonLifetimeManager.initialize(id);
         },
+        destroy() {
+            throw new Error("Trying to destroy singleton lifetime manager, this is a bug.");
+        }
+    };
 
-        register() {
-            // does nothing
+    static readonly contextLifetime: ILifetimeManager = {
+        initialize(id: string, context: ActivationContext<any>): ILifetime {
+            return {
+                enter() {
+                    if (context.visit(id))
+                        throw new Error("Cyclic reference detected");
+                },
+                get() {
+                    return context.get(id);
+                },
+                has() {
+                    return context.has(id);
+                },
+                store(item: any) {
+                    context.store(id, item);
+                }
+
+            };
         },
-
         destroy() {
             throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
         }
     };
 }
+
+const singletonLifetimeManager = new LifetimeManager();
diff --git a/src/main/ts/di/ServiceDescriptor.ts b/src/main/ts/di/ServiceDescriptor.ts
--- a/src/main/ts/di/ServiceDescriptor.ts
+++ b/src/main/ts/di/ServiceDescriptor.ts
@@ -1,10 +1,11 @@
 import { ActivationContext } from "./ActivationContext";
-import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
+import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager } from "./interfaces";
 import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
 import { TraceSource } from "../log/TraceSource";
 import { isDescriptor } from "./traits";
 import { LifetimeManager } from "./LifetimeManager";
 import { MatchingMemberKeys } from "../interfaces";
+import { Container } from "./Container";
 
 let cacheId = 0;
 
@@ -61,7 +62,9 @@ export type InjectionSpec<T> = {
 };
 
 export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-    lifetime: ILifetimeManager;
+    owner: Container<S>;
+
+    lifetime?: ILifetimeManager;
 
     params?: P;
 
@@ -85,8 +88,12 @@ export class ServiceDescriptor<S extends
 
     _lifetime = LifetimeManager.empty;
 
+    _owner: Container<S>;
+
     constructor(opts: ServiceDescriptorParams<S, T, P>) {
-        argumentNotNull(opts, "opts");
+        argumentNotNull(opts && opts.owner, "opts.owner");
+
+        this._owner = opts.owner;
 
         if (opts.lifetime)
             this._lifetime = opts.lifetime;
diff --git a/src/main/ts/di/interfaces.ts b/src/main/ts/di/interfaces.ts
--- a/src/main/ts/di/interfaces.ts
+++ b/src/main/ts/di/interfaces.ts
@@ -3,8 +3,6 @@ import { IDestroyable } from "../interfa
 
 export interface Descriptor<S extends object = any, T = any> {
     activate(context: ActivationContext<S>): T;
-
-    clone(): this;
 }
 
 export type ServiceMap<S extends object> = {