diff --git a/packages/container/libraries/container/src/container/services/Container.spec.ts b/packages/container/libraries/container/src/container/services/Container.spec.ts
index d86a0efb..aefd011e 100644
--- a/packages/container/libraries/container/src/container/services/Container.spec.ts
+++ b/packages/container/libraries/container/src/container/services/Container.spec.ts
@@ -69,14 +69,15 @@ describe(Container.name, () => {
       jest.Mocked<DeactivationsService>
     > as jest.Mocked<DeactivationsService>;
 
-    (ActivationsService as jest.Mock<() => ActivationsService>).mockReturnValue(
-      activationServiceMock,
-    );
-    (BindingService as jest.Mock<() => BindingService>).mockReturnValue(
+    (
+      ActivationsService.build as jest.Mock<() => ActivationsService>
+    ).mockReturnValue(activationServiceMock);
+
+    (BindingService.build as jest.Mock<() => BindingService>).mockReturnValue(
       bindingServiceMock,
     );
     (
-      DeactivationsService as jest.Mock<() => DeactivationsService>
+      DeactivationsService.build as jest.Mock<() => DeactivationsService>
     ).mockReturnValue(deactivationServiceMock);
   });
 
@@ -99,25 +100,34 @@ describe(Container.name, () => {
           jest.clearAllMocks();
         });
 
-        it('should call new ActivationsService', () => {
-          expect(ActivationsService).toHaveBeenCalledTimes(2);
-          expect(ActivationsService).toHaveBeenNthCalledWith(1, undefined);
-          expect(ActivationsService).toHaveBeenNthCalledWith(
+        it('should call new ActivationsService.build()', () => {
+          expect(ActivationsService.build).toHaveBeenCalledTimes(2);
+          expect(ActivationsService.build).toHaveBeenNthCalledWith(
+            1,
+            undefined,
+          );
+          expect(ActivationsService.build).toHaveBeenNthCalledWith(
             2,
             activationServiceMock,
           );
         });
 
-        it('should call new BindingService', () => {
-          expect(BindingService).toHaveBeenCalledTimes(2);
-          expect(BindingService).toHaveBeenNthCalledWith(1, undefined);
-          expect(BindingService).toHaveBeenNthCalledWith(2, bindingServiceMock);
+        it('should call BindingService.build', () => {
+          expect(BindingService.build).toHaveBeenCalledTimes(2);
+          expect(BindingService.build).toHaveBeenNthCalledWith(1, undefined);
+          expect(BindingService.build).toHaveBeenNthCalledWith(
+            2,
+            bindingServiceMock,
+          );
         });
 
-        it('should call new DeactivationsService', () => {
-          expect(DeactivationsService).toHaveBeenCalledTimes(2);
-          expect(DeactivationsService).toHaveBeenNthCalledWith(1, undefined);
-          expect(DeactivationsService).toHaveBeenNthCalledWith(
+        it('should call DeactivationsService.build()', () => {
+          expect(DeactivationsService.build).toHaveBeenCalledTimes(2);
+          expect(DeactivationsService.build).toHaveBeenNthCalledWith(
+            1,
+            undefined,
+          );
+          expect(DeactivationsService.build).toHaveBeenNthCalledWith(
             2,
             deactivationServiceMock,
           );
diff --git a/packages/container/libraries/container/src/container/services/Container.ts b/packages/container/libraries/container/src/container/services/Container.ts
index 4165875f..d576bbd6 100644
--- a/packages/container/libraries/container/src/container/services/Container.ts
+++ b/packages/container/libraries/container/src/container/services/Container.ts
@@ -54,17 +54,19 @@ export class Container {
 
   constructor(options?: ContainerOptions) {
     if (options?.parent !== undefined) {
-      this.#activationService = new ActivationsService(
+      this.#activationService = ActivationsService.build(
         options.parent.#activationService,
       );
-      this.#bindingService = new BindingService(options.parent.#bindingService);
-      this.#deactivationService = new DeactivationsService(
+      this.#bindingService = BindingService.build(
+        options.parent.#bindingService,
+      );
+      this.#deactivationService = DeactivationsService.build(
         options.parent.#deactivationService,
       );
     } else {
-      this.#activationService = new ActivationsService(undefined);
-      this.#bindingService = new BindingService(undefined);
-      this.#deactivationService = new DeactivationsService(undefined);
+      this.#activationService = ActivationsService.build(undefined);
+      this.#bindingService = BindingService.build(undefined);
+      this.#deactivationService = DeactivationsService.build(undefined);
     }
 
     this.#options = {
diff --git a/packages/container/libraries/core/src/binding/services/ActivationsService.spec.ts b/packages/container/libraries/core/src/binding/services/ActivationsService.spec.ts
index 22b15df5..7ef46f10 100644
--- a/packages/container/libraries/core/src/binding/services/ActivationsService.spec.ts
+++ b/packages/container/libraries/core/src/binding/services/ActivationsService.spec.ts
@@ -37,9 +37,9 @@ describe(ActivationsService.name, () => {
       OneToManyMapStar<BindingActivation, BindingActivationRelation>
     >;
 
-    parentActivationService = new ActivationsService(undefined);
+    parentActivationService = ActivationsService.build(undefined);
 
-    activationsService = new ActivationsService(parentActivationService);
+    activationsService = ActivationsService.build(parentActivationService);
   });
 
   describe('.add', () => {
@@ -79,6 +79,31 @@ describe(ActivationsService.name, () => {
     });
   });
 
+  describe('.clone', () => {
+    describe('when called', () => {
+      let result: unknown;
+
+      beforeAll(() => {
+        activationMapsMock.clone.mockReturnValueOnce(activationMapsMock);
+
+        result = activationsService.clone();
+      });
+
+      afterAll(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should call activationMaps.clone', () => {
+        expect(activationMapsMock.clone).toHaveBeenCalledTimes(1);
+        expect(activationMapsMock.clone).toHaveBeenCalledWith();
+      });
+
+      it('should return a clone()', () => {
+        expect(result).toStrictEqual(activationsService);
+      });
+    });
+  });
+
   describe('.get', () => {
     let serviceIdFixture: ServiceIdentifier;
 
diff --git a/packages/container/libraries/core/src/binding/services/ActivationsService.ts b/packages/container/libraries/core/src/binding/services/ActivationsService.ts
index af2aeb28..d3198943 100644
--- a/packages/container/libraries/core/src/binding/services/ActivationsService.ts
+++ b/packages/container/libraries/core/src/binding/services/ActivationsService.ts
@@ -1,6 +1,7 @@
 import { ServiceIdentifier } from '@inversifyjs/common';
 
 import { chain } from '../../common/calculations/chain';
+import { Cloneable } from '../../common/models/Cloneable';
 import { OneToManyMapStar } from '../../common/models/OneToManyMapStar';
 import { BindingActivation } from '../models/BindingActivation';
 
@@ -14,7 +15,7 @@ export interface BindingActivationRelation {
   [ActivationRelationKind.serviceId]: ServiceIdentifier;
 }
 
-export class ActivationsService {
+export class ActivationsService implements Cloneable<ActivationsService> {
   readonly #activationMaps: OneToManyMapStar<
     BindingActivation,
     BindingActivationRelation
@@ -22,22 +23,33 @@ export class ActivationsService {
 
   readonly #parent: ActivationsService | undefined;
 
-  constructor(parent: ActivationsService | undefined) {
-    this.#activationMaps = new OneToManyMapStar<
+  private constructor(
+    parent: ActivationsService | undefined,
+    activationMaps?: OneToManyMapStar<
       BindingActivation,
       BindingActivationRelation
-    >({
-      moduleId: {
-        isOptional: true,
-      },
-      serviceId: {
-        isOptional: false,
-      },
-    });
+    >,
+  ) {
+    this.#activationMaps =
+      activationMaps ??
+      new OneToManyMapStar<BindingActivation, BindingActivationRelation>({
+        moduleId: {
+          isOptional: true,
+        },
+        serviceId: {
+          isOptional: false,
+        },
+      });
 
     this.#parent = parent;
   }
 
+  public static build(
+    parent: ActivationsService | undefined,
+  ): ActivationsService {
+    return new ActivationsService(parent);
+  }
+
   public add(
     activation: BindingActivation,
     relation: BindingActivationRelation,
@@ -45,6 +57,15 @@ export class ActivationsService {
     this.#activationMaps.set(activation, relation);
   }
 
+  public clone(): ActivationsService {
+    const clone: ActivationsService = new ActivationsService(
+      this.#parent,
+      this.#activationMaps.clone(),
+    );
+
+    return clone;
+  }
+
   public get(
     serviceIdentifier: ServiceIdentifier,
   ): Iterable<BindingActivation> | undefined {
diff --git a/packages/container/libraries/core/src/binding/services/BindingService.spec.ts b/packages/container/libraries/core/src/binding/services/BindingService.spec.ts
index 39e721d6..ba15c74a 100644
--- a/packages/container/libraries/core/src/binding/services/BindingService.spec.ts
+++ b/packages/container/libraries/core/src/binding/services/BindingService.spec.ts
@@ -27,9 +27,34 @@ describe(BindingService.name, () => {
       },
     }) as jest.Mocked<OneToManyMapStar<Binding<unknown>, BindingRelation>>;
 
-    parentBindingService = new BindingService(undefined);
+    parentBindingService = BindingService.build(undefined);
 
-    bindingService = new BindingService(parentBindingService);
+    bindingService = BindingService.build(parentBindingService);
+  });
+
+  describe('.clone', () => {
+    describe('when called', () => {
+      let result: unknown;
+
+      beforeAll(() => {
+        bindingMapsMock.clone.mockReturnValueOnce(bindingMapsMock);
+
+        result = bindingService.clone();
+      });
+
+      afterAll(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should call activationMaps.clone()', () => {
+        expect(bindingMapsMock.clone).toHaveBeenCalledTimes(1);
+        expect(bindingMapsMock.clone).toHaveBeenCalledWith();
+      });
+
+      it('should return a clone()', () => {
+        expect(result).toStrictEqual(bindingService);
+      });
+    });
   });
 
   describe('.get', () => {
diff --git a/packages/container/libraries/core/src/binding/services/BindingService.ts b/packages/container/libraries/core/src/binding/services/BindingService.ts
index 3dcc11ca..cc844365 100644
--- a/packages/container/libraries/core/src/binding/services/BindingService.ts
+++ b/packages/container/libraries/core/src/binding/services/BindingService.ts
@@ -1,5 +1,6 @@
 import { ServiceIdentifier } from '@inversifyjs/common';
 
+import { Cloneable } from '../../common/models/Cloneable';
 import { OneToManyMapStar } from '../../common/models/OneToManyMapStar';
 import { Binding } from '../models/Binding';
 
@@ -13,26 +14,41 @@ export interface BindingRelation {
   [BindingRelationKind.serviceId]: ServiceIdentifier;
 }
 
-export class BindingService {
+export class BindingService implements Cloneable<BindingService> {
   readonly #bindingMaps: OneToManyMapStar<Binding<unknown>, BindingRelation>;
-
   readonly #parent: BindingService | undefined;
 
-  constructor(parent: BindingService | undefined) {
-    this.#bindingMaps = new OneToManyMapStar<Binding<unknown>, BindingRelation>(
-      {
+  private constructor(
+    parent: BindingService | undefined,
+    bindingMaps?: OneToManyMapStar<Binding<unknown>, BindingRelation>,
+  ) {
+    this.#bindingMaps =
+      bindingMaps ??
+      new OneToManyMapStar<Binding<unknown>, BindingRelation>({
         moduleId: {
           isOptional: true,
         },
         serviceId: {
           isOptional: false,
         },
-      },
-    );
+      });
 
     this.#parent = parent;
   }
 
+  public static build(parent: BindingService | undefined): BindingService {
+    return new BindingService(parent);
+  }
+
+  public clone(): BindingService {
+    const clone: BindingService = new BindingService(
+      this.#parent,
+      this.#bindingMaps.clone(),
+    );
+
+    return clone;
+  }
+
   public get<TResolved>(
     serviceIdentifier: ServiceIdentifier,
   ): Iterable<Binding<TResolved>> | undefined {
diff --git a/packages/container/libraries/core/src/binding/services/DeactivationsService.spec.ts b/packages/container/libraries/core/src/binding/services/DeactivationsService.spec.ts
index fecc3700..4d8bf5bf 100644
--- a/packages/container/libraries/core/src/binding/services/DeactivationsService.spec.ts
+++ b/packages/container/libraries/core/src/binding/services/DeactivationsService.spec.ts
@@ -14,15 +14,15 @@ import {
 } from './DeactivationsService';
 
 describe(DeactivationsService.name, () => {
-  let activationMapsMock: jest.Mocked<
+  let deactivationMapsMock: jest.Mocked<
     OneToManyMapStar<BindingDeactivation, BindingDeactivationRelation>
   >;
 
-  let parentActivationService: DeactivationsService;
-  let activationsService: DeactivationsService;
+  let parentDeactivationService: DeactivationsService;
+  let deactivationsService: DeactivationsService;
 
   beforeAll(() => {
-    activationMapsMock = new OneToManyMapStar<
+    deactivationMapsMock = new OneToManyMapStar<
       BindingDeactivation,
       BindingDeactivationRelation
     >({
@@ -36,9 +36,11 @@ describe(DeactivationsService.name, () => {
       OneToManyMapStar<BindingDeactivation, BindingDeactivationRelation>
     >;
 
-    parentActivationService = new DeactivationsService(undefined);
+    parentDeactivationService = DeactivationsService.build(undefined);
 
-    activationsService = new DeactivationsService(parentActivationService);
+    deactivationsService = DeactivationsService.build(
+      parentDeactivationService,
+    );
   });
 
   describe('.add', () => {
@@ -57,16 +59,16 @@ describe(DeactivationsService.name, () => {
       let result: unknown;
 
       beforeAll(() => {
-        result = activationsService.add(deactivationFixture, relationFixture);
+        result = deactivationsService.add(deactivationFixture, relationFixture);
       });
 
       afterAll(() => {
         jest.clearAllMocks();
       });
 
-      it('should call activationMaps.set()', () => {
-        expect(activationMapsMock.set).toHaveBeenCalledTimes(1);
-        expect(activationMapsMock.set).toHaveBeenCalledWith(
+      it('should call deactivationMaps.set()', () => {
+        expect(deactivationMapsMock.set).toHaveBeenCalledTimes(1);
+        expect(deactivationMapsMock.set).toHaveBeenCalledWith(
           deactivationFixture,
           relationFixture,
         );
@@ -78,6 +80,31 @@ describe(DeactivationsService.name, () => {
     });
   });
 
+  describe('.clone', () => {
+    describe('when called', () => {
+      let result: unknown;
+
+      beforeAll(() => {
+        deactivationMapsMock.clone.mockReturnValueOnce(deactivationMapsMock);
+
+        result = deactivationsService.clone();
+      });
+
+      afterAll(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should call deactivationMaps.clone', () => {
+        expect(deactivationMapsMock.clone).toHaveBeenCalledTimes(1);
+        expect(deactivationMapsMock.clone).toHaveBeenCalledWith();
+      });
+
+      it('should return a clone()', () => {
+        expect(result).toStrictEqual(deactivationsService);
+      });
+    });
+  });
+
   describe('.get', () => {
     let serviceIdFixture: ServiceIdentifier;
 
@@ -85,37 +112,37 @@ describe(DeactivationsService.name, () => {
       serviceIdFixture = 'service-identifier';
     });
 
-    describe('when called, and activationMaps.get() returns Iterable and parent activationMaps.get() returns undefined', () => {
-      let bindingActivationFixture: BindingDeactivation;
+    describe('when called, and deactivationMaps.get() returns Iterable and parent deactivationMaps.get() returns undefined', () => {
+      let bindingDeactivationFixture: BindingDeactivation;
 
       let result: unknown;
 
       beforeAll(() => {
-        bindingActivationFixture = Symbol() as unknown as BindingDeactivation;
+        bindingDeactivationFixture = Symbol() as unknown as BindingDeactivation;
 
-        activationMapsMock.get
-          .mockReturnValueOnce([bindingActivationFixture])
+        deactivationMapsMock.get
+          .mockReturnValueOnce([bindingDeactivationFixture])
           .mockReturnValueOnce(undefined);
 
         (chain as jest.Mock<typeof chain>).mockReturnValueOnce([
-          bindingActivationFixture,
+          bindingDeactivationFixture,
         ]);
 
-        result = activationsService.get(serviceIdFixture);
+        result = deactivationsService.get(serviceIdFixture);
       });
 
       afterAll(() => {
         jest.clearAllMocks();
       });
 
-      it('should call activationMaps.get()', () => {
-        expect(activationMapsMock.get).toHaveBeenCalledTimes(2);
-        expect(activationMapsMock.get).toHaveBeenNthCalledWith(
+      it('should call deactivationMaps.get()', () => {
+        expect(deactivationMapsMock.get).toHaveBeenCalledTimes(2);
+        expect(deactivationMapsMock.get).toHaveBeenNthCalledWith(
           1,
           'serviceId',
           serviceIdFixture,
         );
-        expect(activationMapsMock.get).toHaveBeenNthCalledWith(
+        expect(deactivationMapsMock.get).toHaveBeenNthCalledWith(
           2,
           'serviceId',
           serviceIdFixture,
@@ -124,48 +151,48 @@ describe(DeactivationsService.name, () => {
 
       it('should call chain()', () => {
         expect(chain).toHaveBeenCalledTimes(1);
-        expect(chain).toHaveBeenCalledWith([bindingActivationFixture]);
+        expect(chain).toHaveBeenCalledWith([bindingDeactivationFixture]);
       });
 
       it('should return BindingDeactivation[]', () => {
-        expect(result).toStrictEqual([bindingActivationFixture]);
+        expect(result).toStrictEqual([bindingDeactivationFixture]);
       });
     });
 
-    describe('when called, and activationMaps.get() returns Iterable and parent activationMaps.get() returns Iterable', () => {
-      let bindingActivationFixture: BindingDeactivation;
+    describe('when called, and deactivationMaps.get() returns Iterable and parent deactivationMaps.get() returns Iterable', () => {
+      let bindingDeactivationFixture: BindingDeactivation;
 
       let result: unknown;
 
       beforeAll(() => {
-        bindingActivationFixture = Symbol() as unknown as BindingDeactivation;
+        bindingDeactivationFixture = Symbol() as unknown as BindingDeactivation;
 
-        activationMapsMock.get
-          .mockReturnValueOnce([bindingActivationFixture])
-          .mockReturnValueOnce([bindingActivationFixture]);
+        deactivationMapsMock.get
+          .mockReturnValueOnce([bindingDeactivationFixture])
+          .mockReturnValueOnce([bindingDeactivationFixture]);
 
         (chain as jest.Mock<typeof chain>)
-          .mockReturnValueOnce([bindingActivationFixture])
+          .mockReturnValueOnce([bindingDeactivationFixture])
           .mockReturnValueOnce([
-            bindingActivationFixture,
-            bindingActivationFixture,
+            bindingDeactivationFixture,
+            bindingDeactivationFixture,
           ]);
 
-        result = activationsService.get(serviceIdFixture);
+        result = deactivationsService.get(serviceIdFixture);
       });
 
       afterAll(() => {
         jest.clearAllMocks();
       });
 
-      it('should call activationMaps.get()', () => {
-        expect(activationMapsMock.get).toHaveBeenCalledTimes(2);
-        expect(activationMapsMock.get).toHaveBeenNthCalledWith(
+      it('should call deactivationMaps.get()', () => {
+        expect(deactivationMapsMock.get).toHaveBeenCalledTimes(2);
+        expect(deactivationMapsMock.get).toHaveBeenNthCalledWith(
           1,
           'serviceId',
           serviceIdFixture,
         );
-        expect(activationMapsMock.get).toHaveBeenNthCalledWith(
+        expect(deactivationMapsMock.get).toHaveBeenNthCalledWith(
           2,
           'serviceId',
           serviceIdFixture,
@@ -174,18 +201,18 @@ describe(DeactivationsService.name, () => {
 
       it('should call chain()', () => {
         expect(chain).toHaveBeenCalledTimes(2);
-        expect(chain).toHaveBeenNthCalledWith(1, [bindingActivationFixture]);
+        expect(chain).toHaveBeenNthCalledWith(1, [bindingDeactivationFixture]);
         expect(chain).toHaveBeenNthCalledWith(
           2,
-          [bindingActivationFixture],
-          [bindingActivationFixture],
+          [bindingDeactivationFixture],
+          [bindingDeactivationFixture],
         );
       });
 
       it('should return BindingDeactivation[]', () => {
         expect(result).toStrictEqual([
-          bindingActivationFixture,
-          bindingActivationFixture,
+          bindingDeactivationFixture,
+          bindingDeactivationFixture,
         ]);
       });
     });
@@ -202,16 +229,16 @@ describe(DeactivationsService.name, () => {
       let result: unknown;
 
       beforeAll(() => {
-        result = activationsService.removeAllByModuleId(moduleIdFixture);
+        result = deactivationsService.removeAllByModuleId(moduleIdFixture);
       });
 
       afterAll(() => {
         jest.clearAllMocks();
       });
 
-      it('should call activationMaps.removeByRelation()', () => {
-        expect(activationMapsMock.removeByRelation).toHaveBeenCalledTimes(1);
-        expect(activationMapsMock.removeByRelation).toHaveBeenCalledWith(
+      it('should call deactivationMaps.removeByRelation()', () => {
+        expect(deactivationMapsMock.removeByRelation).toHaveBeenCalledTimes(1);
+        expect(deactivationMapsMock.removeByRelation).toHaveBeenCalledWith(
           'moduleId',
           moduleIdFixture,
         );
@@ -234,16 +261,16 @@ describe(DeactivationsService.name, () => {
       let result: unknown;
 
       beforeAll(() => {
-        result = activationsService.removeAllByServiceId(serviceIdFixture);
+        result = deactivationsService.removeAllByServiceId(serviceIdFixture);
       });
 
       afterAll(() => {
         jest.clearAllMocks();
       });
 
-      it('should call activationMaps.removeByRelation()', () => {
-        expect(activationMapsMock.removeByRelation).toHaveBeenCalledTimes(1);
-        expect(activationMapsMock.removeByRelation).toHaveBeenCalledWith(
+      it('should call deactivationMaps.removeByRelation()', () => {
+        expect(deactivationMapsMock.removeByRelation).toHaveBeenCalledTimes(1);
+        expect(deactivationMapsMock.removeByRelation).toHaveBeenCalledWith(
           'serviceId',
           serviceIdFixture,
         );
diff --git a/packages/container/libraries/core/src/binding/services/DeactivationsService.ts b/packages/container/libraries/core/src/binding/services/DeactivationsService.ts
index a5d87fb2..0bfe8aa5 100644
--- a/packages/container/libraries/core/src/binding/services/DeactivationsService.ts
+++ b/packages/container/libraries/core/src/binding/services/DeactivationsService.ts
@@ -1,6 +1,7 @@
 import { ServiceIdentifier } from '@inversifyjs/common';
 
 import { chain } from '../../common/calculations/chain';
+import { Cloneable } from '../../common/models/Cloneable';
 import { OneToManyMapStar } from '../../common/models/OneToManyMapStar';
 import { BindingDeactivation } from '../models/BindingDeactivation';
 
@@ -14,35 +15,55 @@ export interface BindingDeactivationRelation {
   [DeactivationRelationKind.serviceId]: ServiceIdentifier;
 }
 
-export class DeactivationsService {
-  readonly #activationMaps: OneToManyMapStar<
+export class DeactivationsService implements Cloneable<DeactivationsService> {
+  readonly #deactivationMaps: OneToManyMapStar<
     BindingDeactivation,
     BindingDeactivationRelation
   >;
 
   readonly #parent: DeactivationsService | undefined;
 
-  constructor(parent: DeactivationsService | undefined) {
-    this.#activationMaps = new OneToManyMapStar<
+  private constructor(
+    parent: DeactivationsService | undefined,
+    deactivationMaps?: OneToManyMapStar<
       BindingDeactivation,
       BindingDeactivationRelation
-    >({
-      moduleId: {
-        isOptional: true,
-      },
-      serviceId: {
-        isOptional: false,
-      },
-    });
+    >,
+  ) {
+    this.#deactivationMaps =
+      deactivationMaps ??
+      new OneToManyMapStar<BindingDeactivation, BindingDeactivationRelation>({
+        moduleId: {
+          isOptional: true,
+        },
+        serviceId: {
+          isOptional: false,
+        },
+      });
 
     this.#parent = parent;
   }
 
+  public static build(
+    parent: DeactivationsService | undefined,
+  ): DeactivationsService {
+    return new DeactivationsService(parent);
+  }
+
   public add(
     deactivation: BindingDeactivation,
     relation: BindingDeactivationRelation,
   ): void {
-    this.#activationMaps.set(deactivation, relation);
+    this.#deactivationMaps.set(deactivation, relation);
+  }
+
+  public clone(): DeactivationsService {
+    const clone: DeactivationsService = new DeactivationsService(
+      this.#parent,
+      this.#deactivationMaps.clone(),
+    );
+
+    return clone;
   }
 
   public get(
@@ -51,7 +72,7 @@ export class DeactivationsService {
     const deactivationIterables: Iterable<BindingDeactivation>[] = [];
 
     const deactivations: Iterable<BindingDeactivation> | undefined =
-      this.#activationMaps.get(
+      this.#deactivationMaps.get(
         DeactivationRelationKind.serviceId,
         serviceIdentifier,
       );
@@ -75,14 +96,14 @@ export class DeactivationsService {
   }
 
   public removeAllByModuleId(moduleId: number): void {
-    this.#activationMaps.removeByRelation(
+    this.#deactivationMaps.removeByRelation(
       DeactivationRelationKind.moduleId,
       moduleId,
     );
   }
 
   public removeAllByServiceId(serviceId: ServiceIdentifier): void {
-    this.#activationMaps.removeByRelation(
+    this.#deactivationMaps.removeByRelation(
       DeactivationRelationKind.serviceId,
       serviceId,
     );
diff --git a/packages/container/libraries/core/src/common/models/__mocks__/OneToManyMapStar.ts b/packages/container/libraries/core/src/common/models/__mocks__/OneToManyMapStar.ts
index aa88fb40..80670a8c 100644
--- a/packages/container/libraries/core/src/common/models/__mocks__/OneToManyMapStar.ts
+++ b/packages/container/libraries/core/src/common/models/__mocks__/OneToManyMapStar.ts
@@ -1,5 +1,7 @@
 import { jest } from '@jest/globals';
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const cloneMock: jest.Mock<any> = jest.fn();
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getMock: jest.Mock<any> = jest.fn();
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -8,6 +10,7 @@ const removeByRelationMock: jest.Mock<any> = jest.fn();
 const setMock: jest.Mock<any> = jest.fn();
 
 export class OneToManyMapStar<TModel, TRelation extends object> {
+  public readonly clone: () => OneToManyMapStar<TModel, TRelation>;
   public readonly get: <TKey extends keyof TRelation>(
     key: TKey,
     value: Required<TRelation>[TKey],
@@ -21,6 +24,7 @@ export class OneToManyMapStar<TModel, TRelation extends object> {
   public readonly set: (model: TModel, relation: TRelation) => void;
 
   constructor() {
+    this.clone = cloneMock;
     this.get = getMock;
     this.removeByRelation = removeByRelationMock;
     this.set = setMock;
diff --git a/packages/container/libraries/core/src/planning/calculations/plan.int.spec.ts b/packages/container/libraries/core/src/planning/calculations/plan.int.spec.ts
index 4c1862ee..12bbe5e4 100644
--- a/packages/container/libraries/core/src/planning/calculations/plan.int.spec.ts
+++ b/packages/container/libraries/core/src/planning/calculations/plan.int.spec.ts
@@ -304,7 +304,7 @@ describe(plan.name, () => {
       type: bindingTypeValues.ServiceRedirection,
     };
 
-    bindingService = new BindingService(undefined);
+    bindingService = BindingService.build(undefined);
 
     bindingService.set(constantValueBinding);
     bindingService.set(dynamicValueBinding);
diff --git a/packages/container/libraries/core/src/resolution/actions/resolve.int.spec.ts b/packages/container/libraries/core/src/resolution/actions/resolve.int.spec.ts
index 16361002..f2e310bf 100644
--- a/packages/container/libraries/core/src/resolution/actions/resolve.int.spec.ts
+++ b/packages/container/libraries/core/src/resolution/actions/resolve.int.spec.ts
@@ -196,8 +196,8 @@ describe(resolve.name, () => {
       type: bindingTypeValues.ServiceRedirection,
     };
 
-    activationService = new ActivationsService(undefined);
-    bindingService = new BindingService(undefined);
+    activationService = ActivationsService.build(undefined);
+    bindingService = BindingService.build(undefined);
 
     activationService.add(
       constantValueBindingWithActivation.onActivation as BindingActivation,