diff --git a/src/main/ts/di/AggregateDescriptor.ts b/src/main/ts/di/AggregateDescriptor.ts
--- a/src/main/ts/di/AggregateDescriptor.ts
+++ b/src/main/ts/di/AggregateDescriptor.ts
@@ -1,19 +1,20 @@
-import { Descriptor, isDescriptor, Parse } from "./interfaces";
+import { Descriptor } from "./interfaces";
 import { ActivationContext } from "./ActivationContext";
 import { isPrimitive } from "../safe";
+import { isDescriptor } from "./traits";
 
-export class AggregateDescriptor<T> implements Descriptor<Parse<T>> {
-    _value: T;
+export class AggregateDescriptor<S, T> implements Descriptor<S, T> {
+    _value: any;
 
-    constructor(value: T) {
+    constructor(value: any) {
         this._value = value;
     }
 
-    activate<S>(context: ActivationContext<S>) {
+    activate(context: ActivationContext<S>): T {
         return this._parse(this._value, context, "$value");
     }
 
-    _parse<S, V>(value: V, context: ActivationContext<S>, path: string): Parse<V> {
+    _parse(value: any, context: ActivationContext<S>, path: string): any {
         if (isPrimitive(value))
             return value as any;
 
diff --git a/src/main/ts/di/Annotations.ts b/src/main/ts/di/Annotations.ts
--- a/src/main/ts/di/Annotations.ts
+++ b/src/main/ts/di/Annotations.ts
@@ -1,4 +1,5 @@
 import { Constructor } from "../interfaces";
+import { primitive } from "../safe";
 
 export interface InjectOptions {
     lazy?: boolean;
@@ -14,25 +15,28 @@ interface Lazy<K extends keyof any> exte
     lazy: true;
 }
 
-type Setter<T = any> = (v: T) => void;
-
 type Compatible<T1, T2> = T1 extends T2 ? any : never;
 
 type ExtractService<K, S> = K extends keyof S ? S[K] : K;
 
-type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
+type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
+    D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
+    WalkDependencies<D, S>;
 
-type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
+type WalkDependencies<D, S> = D extends primitive ? D :
+    { [K in keyof D]: ExtractDependency<D[K], S> };
 
-interface Config<S> {
-    dependency<K extends keyof S>(name: K): Dependency<K>;
+interface Services<S> {
+    get<K extends keyof S>(name: K): Dependency<K>;
 
     lazy<K extends keyof S>(name: K): Lazy<K>;
 
-    build<T>(): Builder<T, S>;
+    build<T extends object>(): Builder<T, S>;
 }
 
-export declare function services<S extends object>(): Config<S>;
+export declare function services<S extends object>(): Services<S>;
+
+export declare function build<T = never, S = any>(): Builder<T, S>;
 
 export class Builder<T, S> {
     consume<P extends any[]>(...args: P) {
@@ -40,13 +44,17 @@ export class Builder<T, S> {
         };
     }
 
-    inject<K extends keyof S>(dependency: K) {
+    inject<P extends any[]>(...args: P) {
         // K = "bar"
         // M = "setValue"
         // S[K] = Bar
         // T[M] = (value: string) => void
         // P[m] = (value: V) => void
-        return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
+        return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
+            target: X,
+            memberName: M,
+            descriptor: TypedPropertyDescriptor<Compatible<(...args: ExtractDependency<P, S>) => any, T[M]>>
+        ) => {
 
         };
     }
@@ -55,4 +63,13 @@ export class Builder<T, S> {
         return this as Builder<T2, S>;
     }
 
+    get<K extends keyof S>(name: K): Dependency<K> {
+        throw new Error();
+    }
+
+    lazy<K extends keyof S>(name: K): Lazy<K> {
+        throw new Error();
+    }
+
+
 }
diff --git a/src/main/ts/di/Configuration.ts b/src/main/ts/di/Configuration.ts
--- a/src/main/ts/di/Configuration.ts
+++ b/src/main/ts/di/Configuration.ts
@@ -1,17 +1,6 @@
 import {
-    ServiceRegistration,
-    TypeRegistration,
-    FactoryRegistration,
-    ServiceMap,
-    isDescriptor,
-    isDependencyRegistration,
-    DependencyRegistration,
-    ValueRegistration,
-    ActivationType,
-    isValueRegistration,
-    isTypeRegistration,
-    isFactoryRegistration,
-    PartialServiceMap
+    PartialServiceMap,
+    ActivationType
 } from "./interfaces";
 
 import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
@@ -25,7 +14,81 @@ import { TraceSource } from "../log/Trac
 import { ConfigError } from "./ConfigError";
 import { Cancellation } from "../Cancellation";
 import { makeResolver } from "./ResolverHelper";
-import { ICancellation } from "../interfaces";
+import { ICancellation, Constructor, Factory } from "../interfaces";
+import { isDescriptor } from "./traits";
+
+export interface RegistrationScope<S> {
+
+    /** сервисы, которые регистрируются в контексте активации и таким образом
+     * могут переопределять ранее зарегистрированные сервисы. за это свойство
+     * нужно платить, кроме того порядок активации будет влиять на результат
+     * разрешения зависимостей.
+     */
+    services?: PartialServiceMap<S>;
+}
+
+/**
+ * Базовый интефейс конфигурации сервисов
+ */
+export interface ServiceRegistration<T, P, S> extends RegistrationScope<S> {
+
+    activation?: ActivationType;
+
+    params?: P;
+
+    inject?: object | object[];
+
+    cleanup?: ((instance: T) => void) | string;
+}
+
+export interface TypeRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+    $type: string | (new (...params: P) => T);
+
+}
+
+export interface FactoryRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+    $factory: string | ( (...params: P) => T);
+}
+
+export interface ValueRegistration<T> {
+    $value: T;
+    parse?: boolean;
+}
+
+export interface DependencyRegistration<S, K extends keyof S> extends RegistrationScope<S> {
+    $dependency: K;
+    lazy?: boolean;
+    optional?: boolean;
+    default?: S[K];
+}
+
+const _activationTypes: { [k in ActivationType]: number; } = {
+    singleton: 1,
+    container: 2,
+    hierarchy: 3,
+    context: 4,
+    call: 5
+};
+
+export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
+    return (!isPrimitive(x)) && ("$type" in x);
+}
+
+export function isFactoryRegistration(x: any): x is FactoryRegistration<any, any, any> {
+    return (!isPrimitive(x)) && ("$factory" in x);
+}
+
+export function isValueRegistration(x: any): x is ValueRegistration<any> {
+    return (!isPrimitive(x)) && ("$value" in x);
+}
+
+export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
+    return (!isPrimitive(x)) && ("$dependency" in x);
+}
+
+export function isActivationType(x: string): x is ActivationType {
+    return typeof x === "string" && x in _activationTypes;
+}
 
 const trace = TraceSource.get("@implab/core/di/Configuration");
 async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
@@ -180,7 +243,7 @@ export class Configuration<S> {
         trace.debug("<{0}", name);
     }
 
-    async _visit<T>(data: T, name: string): Promise<any> {
+    async _visit(data: any, name: string): Promise<any> {
         if (isPrimitive(data) || isDescriptor(data))
             return data;
 
@@ -196,10 +259,10 @@ export class Configuration<S> {
             return this._visitArray(data, name);
         }
 
-        return this._visitObject(data as T & object, name);
+        return this._visitObject(data, name);
     }
 
-    async _visitObject<T extends object>(data: T, name: string) {
+    async _visitObject(data: any, name: string) {
         if (data.constructor &&
             data.constructor.prototype !== Object.prototype)
             return new ValueDescriptor(data);
@@ -259,30 +322,7 @@ export class Configuration<S> {
                 this._visit(data.params, "params");
 
         if (data.activation) {
-            if (typeof (data.activation) === "string") {
-                switch (data.activation.toLowerCase()) {
-                    case "singleton":
-                        opts.activation = ActivationType.Singleton;
-                        break;
-                    case "container":
-                        opts.activation = ActivationType.Container;
-                        break;
-                    case "hierarchy":
-                        opts.activation = ActivationType.Hierarchy;
-                        break;
-                    case "context":
-                        opts.activation = ActivationType.Context;
-                        break;
-                    case "call":
-                        opts.activation = ActivationType.Call;
-                        break;
-                    default:
-                        throw new Error("Unknown activation type: " +
-                            data.activation);
-                }
-            } else {
-                opts.activation = Number(data.activation);
-            }
+            opts.activation = data.activation;
         }
 
         if (data.cleanup)
@@ -312,7 +352,7 @@ export class Configuration<S> {
         return d;
     }
 
-    async _visitTypeRegistration<T, P>(data: TypeRegistration<T, P, S>, name: string) {
+    async _visitTypeRegistration(data: TypeRegistration<any, any, S>, name: string) {
         argumentNotNull(data.$type, "data.$type");
         this._enter(name);
 
@@ -324,7 +364,7 @@ export class Configuration<S> {
             opts.type = this._resolveType(moduleName, typeName);
         }
 
-        const d = new TypeServiceDescriptor(
+        const d = new TypeServiceDescriptor<S, any, any[]>(
             await mapAll(opts)
         );
 
@@ -333,14 +373,14 @@ export class Configuration<S> {
         return d;
     }
 
-    async _visitFactoryRegistration<T, P>(data: FactoryRegistration<T, P, S>, name: string) {
+    async _visitFactoryRegistration(data: FactoryRegistration<any, any, S>, name: string) {
         argumentOfType(data.$factory, Function, "data.$factory");
         this._enter(name);
 
         const opts = this._makeServiceParams(data);
         opts.factory = data.$factory;
 
-        const d = new FactoryServiceDescriptor(
+        const d = new FactoryServiceDescriptor<S, any, any[]>(
             await mapAll(opts)
         );
 
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,16 +1,17 @@
 import { ActivationContext } from "./ActivationContext";
 import { ValueDescriptor } from "./ValueDescriptor";
 import { ActivationError } from "./ActivationError";
-import { isDescriptor, ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
+import { ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
 import { TraceSource } from "../log/TraceSource";
 import { Configuration } from "./Configuration";
 import { Cancellation } from "../Cancellation";
 import { MapOf } from "../interfaces";
+import { isDescriptor } from "./traits";
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
 export class Container<S = any> implements Resolver<S> {
-    readonly _services: PartialServiceMap<S, ContainerServices<S>>;
+    readonly _services: PartialServiceMap<ContainerServices<S>>;
 
     readonly _cache: MapOf<any>;
 
diff --git a/src/main/ts/di/FactoryServiceDescriptor.ts b/src/main/ts/di/FactoryServiceDescriptor.ts
--- a/src/main/ts/di/FactoryServiceDescriptor.ts
+++ b/src/main/ts/di/FactoryServiceDescriptor.ts
@@ -1,6 +1,5 @@
 import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
 import { argumentNotNull, oid } from "../safe";
-import { ActivationType } from "./interfaces";
 
 export interface FactoryServiceDescriptorParams<S, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
     factory: (...args: P) => T;
@@ -15,7 +14,7 @@ export class FactoryServiceDescriptor<S,
         // bind to null
         this._factory = (...args) => opts.factory.apply(null, args as any);
 
-        if (opts.activation === ActivationType.Singleton) {
+        if (opts.activation === "singleton") {
             this._cacheId = oid(opts.factory);
         }
     }
diff --git a/src/main/ts/di/ReferenceDescriptor.ts b/src/main/ts/di/ReferenceDescriptor.ts
--- a/src/main/ts/di/ReferenceDescriptor.ts
+++ b/src/main/ts/di/ReferenceDescriptor.ts
@@ -26,7 +26,7 @@ export class ReferenceDescriptor<S = any
 
     _default: S[K] | undefined;
 
-    _services: ServiceMap<S>;
+    _services: PartialServiceMap<S>;
 
     constructor(opts: ReferenceDescriptorParams<S, K>) {
         argumentNotEmptyString(opts && opts.name, "opts.name");
@@ -53,7 +53,7 @@ export class ReferenceDescriptor<S = any
                 const ct = saved.clone();
                 try {
                     if (cfg) {
-                        each(cfg as ServiceMap<S>, (v, k) => ct.register(k, v));
+                        each(cfg, (v, k) => ct.register(k, v));
                     }
 
                     return this._optional ? ct.resolve(this._name, this._default) : ct
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,8 +1,9 @@
 import { ActivationContext } from "./ActivationContext";
-import { Descriptor, ActivationType, ServiceMap, isDescriptor, Parse, PartialServiceMap } from "./interfaces";
+import { Descriptor, ServiceMap, PartialServiceMap, ActivationType } from "./interfaces";
 import { Container } from "./Container";
-import { argumentNotNull, isPrimitive, each, keys, isNull } from "../safe";
+import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
 import { TraceSource } from "../log/TraceSource";
+import { isDescriptor } from "./traits";
 
 let cacheId = 0;
 
@@ -33,7 +34,7 @@ function makeClenupCallback(target: any,
     }
 }
 
-function _parse<T, S>(value: T, context: ActivationContext<S>, path: string): Parse<T> {
+function _parse(value: any, context: ActivationContext<any>, path: string): any {
     if (isPrimitive(value))
         return value as any;
 
@@ -77,7 +78,7 @@ export class ServiceDescriptor<S, T, P e
 
     _hasInstance = false;
 
-    _activationType = ActivationType.Call;
+    _activationType: ActivationType = "call";
 
     _services: ServiceMap<S>;
 
@@ -125,7 +126,7 @@ export class ServiceDescriptor<S, T, P e
             this._cacheId = ++cacheId;
 
         switch (this._activationType) {
-            case ActivationType.Singleton: // SINGLETON
+            case "singleton": // SINGLETON
                 // if the value is cached return it
                 if (this._hasInstance)
                     return this._instance;
@@ -146,7 +147,7 @@ export class ServiceDescriptor<S, T, P e
                 this._hasInstance = true;
                 return (this._instance = instance);
 
-            case ActivationType.Container: // CONTAINER
+            case "container": // CONTAINER
                 // return a cached value
 
                 if (this._hasInstance)
@@ -163,17 +164,17 @@ export class ServiceDescriptor<S, T, P e
                 // cache and return the instance
                 this._hasInstance = true;
                 return (this._instance = instance);
-            case ActivationType.Context: // CONTEXT
+            case "context": // CONTEXT
                 // return a cached value if one exists
 
                 if (context.has(this._cacheId))
                     return context.get(this._cacheId);
                 // context context activated instances are controlled by callers
                 return context.store(this._cacheId, this._create(context));
-            case ActivationType.Call: // CALL
+            case "call": // CALL
                 // per-call created instances are controlled by callers
                 return this._create(context);
-            case ActivationType.Hierarchy: // HIERARCHY
+            case "hierarchy": // HIERARCHY
                 // hierarchy activated instances are behave much like container activated
                 // except they are created and bound to the child container
 
@@ -209,7 +210,7 @@ export class ServiceDescriptor<S, T, P e
     _create(context: ActivationContext<S>) {
         trace.debug(`constructing ${context._name}`);
 
-        if (this._activationType !== ActivationType.Call &&
+        if (this._activationType !== "call" &&
             context.visit(this._cacheId) > 0)
             throw new Error("Recursion detected");
 
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
@@ -1,68 +1,16 @@
-import { isPrimitive, primitive } from "../safe";
 import { ActivationContext } from "./ActivationContext";
-import { Constructor, Factory } from "../interfaces";
 
 export interface Descriptor<S = any, T = any> {
     activate(context: ActivationContext<S>): T;
 }
 
-export function isDescriptor(x: any): x is Descriptor {
-    return (!isPrimitive(x)) &&
-        (x.activate instanceof Function);
-}
-
-export type ServiceMap<S, S2 extends S = S> = {
-    [k in keyof S2]: Descriptor<S, S2[k]>;
+export type ServiceMap<S> = {
+    [k in keyof S]: Descriptor<S, S[k]>;
 };
 
-export type PartialServiceMap<S, S2 extends S = S> = Partial<ServiceMap<S, S2>>;
-
-export enum ActivationType {
-    Singleton = 1,
-    Container,
-    Hierarchy,
-    Context,
-    Call
-}
-
-export interface RegistrationWithServices<S> {
-    services?: ServiceMap<S>;
-}
-
-export interface ServiceRegistration<T, P, S> extends RegistrationWithServices<S> {
-
-    activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
-
-    params?: P;
-
-    inject?: object | object[];
-
-    cleanup?: ((instance: T) => void) | string;
-}
-
-export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
-    $type: string | Constructor<T>;
-}
-
-export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
-    $factory: string | Factory<T>;
-}
-
-export interface ValueRegistration<T> {
-    $value: T;
-    parse?: boolean;
-}
-
-export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
-    $dependency: K;
-    lazy?: boolean;
-    optional?: boolean;
-    default?: S[K];
-}
-
-export type Parse<T> = T extends primitive ? T:
-        T extends Descriptor<infer V> ? V :
-        { [K in keyof T]: Parse<T[K]> };
+export type PartialServiceMap<S> = {
+    [k in keyof S]?: Descriptor<S, S[k]>;
+};
 
 export interface Resolver<S> {
     resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;
@@ -70,19 +18,4 @@ export interface Resolver<S> {
 export type ContainerServices<S> = S & {
     container: Resolver<S>;
 };
-
-export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
-    return (!isPrimitive(x)) && ("$type" in x);
-}
-
-export function isFactoryRegistration(x: any): x is FactoryRegistration<any, any, any> {
-    return (!isPrimitive(x)) && ("$factory" in x);
-}
-
-export function isValueRegistration(x: any): x is ValueRegistration<any> {
-    return (!isPrimitive(x)) && ("$value" in x);
-}
-
-export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
-    return (!isPrimitive(x)) && ("$dependency" in x);
-}
+export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
diff --git a/src/main/ts/di/traits.ts b/src/main/ts/di/traits.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/di/traits.ts
@@ -0,0 +1,7 @@
+import { isPrimitive } from "../safe";
+import { Descriptor } from "./interfaces";
+
+export function isDescriptor(x: any): x is Descriptor {
+    return (!isPrimitive(x)) &&
+        (x.activate instanceof Function);
+}
diff --git a/src/test/ts/mock/Bar.ts b/src/test/ts/mock/Bar.ts
--- a/src/test/ts/mock/Bar.ts
+++ b/src/test/ts/mock/Bar.ts
@@ -1,22 +1,22 @@
 import { Foo } from "./Foo";
-// import { config } from "./config";
+import { build } from "./config";
 
-// const service = config.build("bar");
+const service = build<Bar>();
 
-// @service.consume({
-//     f: config.dependency("foo"),
-//     nested: {
-//         lazy: config.lazy("foo")
-//     }
-// })
+@service.consume({
+    foo: service.get("foo"),
+    nested: {
+        lazy: service.lazy("foo")
+    }
+})
 export class Bar {
     barName = "bar";
 
     _v: Foo | undefined;
 
-    constructor(_opts: {
-        foo: Foo;
-        nested: {
+    constructor(_opts?: {
+        foo?: Foo;
+        nested?: {
             lazy: () => Foo
         }
     }) {
diff --git a/src/test/ts/mock/Box.ts b/src/test/ts/mock/Box.ts
--- a/src/test/ts/mock/Box.ts
+++ b/src/test/ts/mock/Box.ts
@@ -1,15 +1,17 @@
 import { services } from "../di/Annotations";
 import { Bar } from "./Bar";
+import { Foo } from "./Foo";
 
 // declare required dependencies
 const config = services<{
      bar: Bar;
+     foo: Foo;
 }>();
 
 // export service descriptor
 export const service = config.build<Box<Bar>>();
 
-@service.consume(config.dependency("bar"))
+@service.consume(config.get("bar"))
 export class Box<T> {
     private _value: T | undefined;
 
@@ -17,9 +19,10 @@ export class Box<T> {
         this._value = value;
     }
 
-    // @service.inject("bar")
-    setValue(value: T) {
+    @service.inject( config.get("bar"))
+    setValue(value?: T) {
         this._value = value;
+        return value;
     }
 
     setObj(value: object) {
diff --git a/src/test/ts/mock/config.ts b/src/test/ts/mock/config.ts
--- a/src/test/ts/mock/config.ts
+++ b/src/test/ts/mock/config.ts
@@ -1,8 +1,7 @@
 import { Foo } from "./Foo";
 import { Bar } from "./Bar";
 import { Box } from "./Box";
-import { primitive } from "../safe";
-import { Constructor } from "../interfaces";
+import { Builder } from "../di/Annotations";
 
 interface Services {
     foo: Foo;
@@ -15,24 +14,14 @@ interface Services {
 
 }
 
-interface TypeDescriptor<T, C extends Constructor<T>> {
-    $type: C;
+const services = {
+    build: <T>() => {
+        return new Builder<T, Services>();
+    }
+};
 
-    params: Wrap<ConstructorParameters<C>>;
-}
+namespace services {
 
-function typeRegistration<T, C extends Constructor<T>>(target: C, params: Wrap<ConstructorParameters<C>>): TypeDescriptor<T, C> {
-    throw new Error();
 }
 
-declare function register<T>(): { type<C extends Constructor<T>>(target: C, params: Wrap<ConstructorParameters<C>>): TypeDescriptor<T, C>};
-
-type Wrap<T> = T extends primitive ? T :
-    { [k in keyof T]: Wrap<T[k]> } | TypeDescriptor<T, Constructor<T>>;
-
-const config: Wrap<Services> = {
-    foo: typeRegistration(Foo, []),
-    bar: typeRegistration(Bar, [{ foo: null as any, nested: null as any }]),
-    box: register<Box<Foo>>().type(Box, [{ $type: Bar, params: [] }]),
-    host: ""
-};
+export = services;
diff --git a/src/test/ts/tests/ContainerTests.ts b/src/test/ts/tests/ContainerTests.ts
--- a/src/test/ts/tests/ContainerTests.ts
+++ b/src/test/ts/tests/ContainerTests.ts
@@ -91,4 +91,5 @@ test("Load configuration from module", a
 
     t.assert(!isNull(b1), "bar should not be null");
     t.assert(!isNull(b1._v), "bar.foo should not be null");
+
 });