@twin.org/engine-types 0.0.2-next.18 → 0.0.2-next.19

package/dist/cjs/index.cjs

@@ -140,78 +140,50 @@ const AttestationConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseAttestationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAttestationConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === AttestationConnectorType.Nft) {
-        connector = new attestationConnectorNft.NftAttestationConnector({
+    if (instanceConfig.type === AttestationConnectorType.Nft) {
+        component = new attestationConnectorNft.NftAttestationConnector({
             identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
             nftConnectorType: engineCore.getRegisteredInstanceType("nftConnector"),
             ...instanceConfig.options
         });
         instanceType = attestationConnectorNft.NftAttestationConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "attestationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    attestationModels.AttestationConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: attestationModels.AttestationConnectorFactory
+    };
 }
 /**
  * Initialise the attestation component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseAttestationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAttestationComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AttestationComponentType.Service) {
+    if (instanceConfig.type === AttestationComponentType.Service) {
         component = new attestationService.AttestationService({
             ...instanceConfig.options
         });
         instanceType = "attestation-service";
     }
-    else if (type === AttestationComponentType.RestClient) {
+    else if (instanceConfig.type === AttestationComponentType.RestClient) {
         component = new attestationRestClient.AttestationClient(instanceConfig.options);
         instanceType = "attestation-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "attestationComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -289,7 +261,7 @@ const EntityStorageConnectorType = {
  * @param typeCustom Override the type of connector to use instead of default configuration.
  * @param schema The schema for the entity storage.
  * @returns The name of the instance type that was created.
- * @throws GeneralError if the connector type is unknown.
+ * @throws GeneralError when the configuration is invalid.
  */
 function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
     const instanceName = core.StringHelper.kebabCase(schema);
@@ -445,18 +417,12 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseEntityStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Entity Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEntityStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === EntityStorageComponentType.Service) {
+    if (instanceConfig.type === EntityStorageComponentType.Service) {
         const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
         // See if there is a custom entity storage for this type, otherwise just use the default one.
         const hasCustom = context.config.types.entityStorageConnector?.some(c => c.type === kebabName || c.overrideInstanceType === kebabName);
@@ -469,7 +435,7 @@ async function initialiseEntityStorageComponent(engineCore, context, instanceCon
         });
         instanceType = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
     }
-    else if (type === EntityStorageComponentType.RestClient) {
+    else if (instanceConfig.type === EntityStorageComponentType.RestClient) {
         const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
         component = new entityStorageRestClient.EntityStorageClient({
             pathPrefix: kebabName,
@@ -477,19 +443,11 @@ async function initialiseEntityStorageComponent(engineCore, context, instanceCon
         });
         instanceType = `${"entity-storage-client"}-${kebabName}`;
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            serviceType: "entityStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -514,18 +472,12 @@ const AuditableItemGraphComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Graph Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AuditableItemGraphComponentType.Service) {
+    if (instanceConfig.type === AuditableItemGraphComponentType.Service) {
         auditableItemGraphService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
@@ -536,23 +488,15 @@ async function initialiseAuditableItemGraphComponent(engineCore, context, instan
         });
         instanceType = "auditable-item-graph-service";
     }
-    else if (type === AuditableItemGraphComponentType.RestClient) {
+    else if (instanceConfig.type === AuditableItemGraphComponentType.RestClient) {
         component = new auditableItemGraphRestClient.AuditableItemGraphClient(instanceConfig.options);
         instanceType = "auditable-item-graph-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemGraphComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -577,18 +521,12 @@ const AuditableItemStreamComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Stream Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AuditableItemStreamComponentType.Service) {
+    if (instanceConfig.type === AuditableItemStreamComponentType.Service) {
         auditableItemStreamService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
@@ -599,23 +537,15 @@ async function initialiseAuditableItemStreamComponent(engineCore, context, insta
         });
         instanceType = "auditable-item-stream-service";
     }
-    else if (type === AuditableItemStreamComponentType.RestClient) {
+    else if (instanceConfig.type === AuditableItemStreamComponentType.RestClient) {
         component = new auditableItemStreamRestClient.AuditableItemStreamClient(instanceConfig.options);
         instanceType = "auditable-item-stream-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemStreamComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -638,18 +568,12 @@ const AuthenticationGeneratorComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseAuthenticationGeneratorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Authentication Generator Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseAuthenticationGeneratorComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === AuthenticationGeneratorComponentType.VerifiableCredential) {
+    if (instanceConfig.type === AuthenticationGeneratorComponentType.VerifiableCredential) {
         component = new identityAuthentication.VerifiableCredentialAuthenticationGenerator({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             identityConnectorType: engineCore.getRegisteredInstanceType("identityConnector"),
@@ -657,19 +581,11 @@ async function initialiseAuthenticationGeneratorComponent(engineCore, context, i
         });
         instanceType = "verifiable-credential-authentication-generator";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "AuthenticationGeneratorComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    apiModels.AuthenticationGeneratorFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: apiModels.AuthenticationGeneratorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -692,36 +608,25 @@ const BackgroundTaskConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Background Task Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === BackgroundTaskConnectorType.EntityStorage) {
+    if (instanceConfig.type === BackgroundTaskConnectorType.EntityStorage) {
         backgroundTaskConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
-        connector = new backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector({
+        component = new backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "backgroundTaskConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    backgroundTaskModels.BackgroundTaskConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: backgroundTaskModels.BackgroundTaskConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -781,23 +686,17 @@ const BlobStorageConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseBlobStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBlobStorageConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === BlobStorageConnectorType.Ipfs) {
-        connector = new blobStorageConnectorIpfs.IpfsBlobStorageConnector(instanceConfig.options);
+    if (instanceConfig.type === BlobStorageConnectorType.Ipfs) {
+        component = new blobStorageConnectorIpfs.IpfsBlobStorageConnector(instanceConfig.options);
         instanceType = blobStorageConnectorIpfs.IpfsBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.File) {
-        connector = new blobStorageConnectorFile.FileBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.File) {
+        component = new blobStorageConnectorFile.FileBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -808,12 +707,12 @@ async function initialiseBlobStorageConnector(engineCore, context, instanceConfi
         });
         instanceType = blobStorageConnectorFile.FileBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.Memory) {
-        connector = new blobStorageConnectorMemory.MemoryBlobStorageConnector();
+    else if (instanceConfig.type === BlobStorageConnectorType.Memory) {
+        component = new blobStorageConnectorMemory.MemoryBlobStorageConnector();
         instanceType = blobStorageConnectorMemory.MemoryBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.AwsS3) {
-        connector = new blobStorageConnectorAwsS3.S3BlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.AwsS3) {
+        component = new blobStorageConnectorAwsS3.S3BlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -822,8 +721,8 @@ async function initialiseBlobStorageConnector(engineCore, context, instanceConfi
         });
         instanceType = blobStorageConnectorAwsS3.S3BlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.GcpStorage) {
-        connector = new blobStorageConnectorGcp.GcpBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.GcpStorage) {
+        component = new blobStorageConnectorGcp.GcpBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -832,8 +731,8 @@ async function initialiseBlobStorageConnector(engineCore, context, instanceConfi
         });
         instanceType = blobStorageConnectorGcp.GcpBlobStorageConnector.NAMESPACE;
     }
-    else if (type === BlobStorageConnectorType.AzureStorage) {
-        connector = new blobStorageConnectorAzure.AzureBlobStorageConnector({
+    else if (instanceConfig.type === BlobStorageConnectorType.AzureStorage) {
+        component = new blobStorageConnectorAzure.AzureBlobStorageConnector({
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
@@ -842,37 +741,23 @@ async function initialiseBlobStorageConnector(engineCore, context, instanceConfi
         });
         instanceType = blobStorageConnectorAzure.AzureBlobStorageConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "blobStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    blobStorageModels.BlobStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: blobStorageModels.BlobStorageConnectorFactory
+    };
 }
 /**
  * Initialise the blob storage component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseBlobStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseBlobStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === BlobStorageComponentType.Service) {
+    if (instanceConfig.type === BlobStorageComponentType.Service) {
         blobStorageService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
         component = new blobStorageService.BlobStorageService({
@@ -881,23 +766,15 @@ async function initialiseBlobStorageComponent(engineCore, context, instanceConfi
         });
         instanceType = "blob-storage-service";
     }
-    else if (type === BlobStorageComponentType.RestClient) {
+    else if (instanceConfig.type === BlobStorageComponentType.RestClient) {
         component = new blobStorageRestClient.BlobStorageClient(instanceConfig.options);
         instanceType = "blob-storage-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "blobStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -954,90 +831,56 @@ const DataProcessingComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseDataConverterConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Data Converter Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataConverterConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === DataConverterConnectorType.Json) {
-        connector = new dataProcessingConverters.JsonConverterConnector();
+    if (instanceConfig.type === DataConverterConnectorType.Json) {
+        component = new dataProcessingConverters.JsonConverterConnector();
         instanceType = dataProcessingConverters.JsonConverterConnector.NAMESPACE;
     }
-    else if (type === DataConverterConnectorType.Xml) {
-        connector = new dataProcessingConverters.XmlConverterConnector();
+    else if (instanceConfig.type === DataConverterConnectorType.Xml) {
+        component = new dataProcessingConverters.XmlConverterConnector();
         instanceType = dataProcessingConverters.XmlConverterConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "dataConverterConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    dataProcessingModels.DataConverterConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: dataProcessingModels.DataConverterConnectorFactory
+    };
 }
 /**
  * Initialise the data extractor connector.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseDataExtractorConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Data Extractor Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataExtractorConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === DataExtractorConnectorType.JsonPath) {
-        connector = new dataProcessingExtractors.JsonPathExtractorConnector();
+    if (instanceConfig.type === DataExtractorConnectorType.JsonPath) {
+        component = new dataProcessingExtractors.JsonPathExtractorConnector();
         instanceType = dataProcessingExtractors.JsonPathExtractorConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "dataExtractorConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    dataProcessingModels.DataExtractorConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: dataProcessingModels.DataExtractorConnectorFactory
+    };
 }
 /**
  * Initialise the data processing component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseDataProcessingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Data Processing Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataProcessingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === DataProcessingComponentType.Service) {
+    if (instanceConfig.type === DataProcessingComponentType.Service) {
         dataProcessingService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.extractionRuleGroupStorageConnectorType, "ExtractionRuleGroup");
         component = new dataProcessingService.DataProcessingService({
@@ -1045,23 +888,15 @@ async function initialiseDataProcessingComponent(engineCore, context, instanceCo
         });
         instanceType = "data-processing-service";
     }
-    else if (type === DataProcessingComponentType.RestClient) {
+    else if (instanceConfig.type === DataProcessingComponentType.RestClient) {
         component = new dataProcessingRestClient.DataProcessingClient(instanceConfig.options);
         instanceType = "data-processing-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "dataProcessingComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1092,18 +927,12 @@ const DataSpaceConnectorComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseDataSpaceConnectorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Data Space Connector Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDataSpaceConnectorComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === DataSpaceConnectorComponentType.Service) {
+    if (instanceConfig.type === DataSpaceConnectorComponentType.Service) {
         dataSpaceConnectorService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityLogEntityStorageType, "ActivityLogDetails");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.activityTaskEntityStorageType, "ActivityTask");
@@ -1115,27 +944,22 @@ async function initialiseDataSpaceConnectorComponent(engineCore, context, instan
         });
         instanceType = "data-space-connector-service";
     }
-    else if (type === DataSpaceConnectorComponentType.RestClient) {
+    else if (instanceConfig.type === DataSpaceConnectorComponentType.RestClient) {
         component = new dataSpaceConnectorRestClient.DataSpaceConnectorClient(instanceConfig.options);
         instanceType = "data-space-connector-client";
     }
-    else if (type === DataSpaceConnectorComponentType.SocketClient) {
+    else if (instanceConfig.type === DataSpaceConnectorComponentType.SocketClient) {
         component = new dataSpaceConnectorSocketClient.DataSpaceConnectorSocketClient({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = "data-space-connector-socket-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "DataSpaceConnectorComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1162,18 +986,12 @@ const DocumentManagementComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseDocumentManagementComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Document Management Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseDocumentManagementComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === DocumentManagementComponentType.Service) {
+    if (instanceConfig.type === DocumentManagementComponentType.Service) {
         component = new documentManagementService.DocumentManagementService({
             auditableItemGraphComponentType: engineCore.getRegisteredInstanceType("auditableItemGraphComponent"),
             blobStorageComponentType: engineCore.getRegisteredInstanceType("blobStorageComponent"),
@@ -1183,23 +1001,15 @@ async function initialiseDocumentManagementComponent(engineCore, context, instan
         });
         instanceType = "document-management-service";
     }
-    else if (type === DocumentManagementComponentType.RestClient) {
+    else if (instanceConfig.type === DocumentManagementComponentType.RestClient) {
         component = new documentManagementRestClient.DocumentManagementClient(instanceConfig.options);
         instanceType = "document-management-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "documentManagementComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1239,75 +1049,53 @@ const EventBusConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseEventBusConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Event Bus Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEventBusConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === EventBusConnectorType.Local) {
+    if (instanceConfig.type === EventBusConnectorType.Local) {
         connector = new eventBusConnectorLocal.LocalEventBusConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = eventBusConnectorLocal.LocalEventBusConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "eventBusConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    eventBusModels.EventBusConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: eventBusModels.EventBusConnectorFactory,
+        component: connector
+    };
 }
 /**
  * Initialise the event bus component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseEventBusComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Event Bus Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseEventBusComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === EventBusComponentType.Service) {
+    if (instanceConfig.type === EventBusComponentType.Service) {
         component = new eventBusService.EventBusService({
             eventBusConnectorType: engineCore.getRegisteredInstanceType("eventBusConnector"),
             ...instanceConfig.options
         });
         instanceType = "event-bus-service";
     }
-    else if (type === EventBusComponentType.SocketClient) {
+    else if (instanceConfig.type === EventBusComponentType.SocketClient) {
         component = new eventBusSocketClient.EventBusSocketClient({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = "event-bus-socket-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "EventBusComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: core.ComponentFactory,
+        component
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1371,27 +1159,19 @@ class EngineTypeHelper {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialise a faucet connector.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseFaucetConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Faucet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseFaucetConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === FaucetConnectorType.Iota) {
+    if (instanceConfig.type === FaucetConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new walletConnectorIota.IotaFaucetConnector({
+        component = new walletConnectorIota.IotaFaucetConnector({
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1400,23 +1180,17 @@ async function initialiseFaucetConnector(engineCore, context, instanceConfig, ov
         });
         instanceType = walletConnectorIota.IotaFaucetConnector.NAMESPACE;
     }
-    else if (type === FaucetConnectorType.EntityStorage) {
-        connector = new walletConnectorEntityStorage.EntityStorageFaucetConnector(instanceConfig.options);
+    else if (instanceConfig.type === FaucetConnectorType.EntityStorage) {
+        walletConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+        component = new walletConnectorEntityStorage.EntityStorageFaucetConnector(instanceConfig.options);
         instanceType = walletConnectorEntityStorage.EntityStorageFaucetConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "faucetConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    walletModels.FaucetConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: walletModels.FaucetConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1443,18 +1217,12 @@ const FederatedCatalogueComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseFederatedCatalogueComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Federated Catalogue Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseFederatedCatalogueComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === FederatedCatalogueComponentType.Service) {
+    if (instanceConfig.type === FederatedCatalogueComponentType.Service) {
         federatedCatalogueService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.dataResourceEntityStorageType, "DataResourceEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.participantEntityStorageType, "ParticipantEntry");
@@ -1467,23 +1235,15 @@ async function initialiseFederatedCatalogueComponent(engineCore, context, instan
         });
         instanceType = "federated-catalogue-service";
     }
-    else if (type === FederatedCatalogueComponentType.RestClient) {
+    else if (instanceConfig.type === FederatedCatalogueComponentType.RestClient) {
         component = new federatedCatalogueRestClient.FederatedCatalogueClient(instanceConfig.options);
         instanceType = "federated-catalogue-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "FederatedCatalogueComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1527,20 +1287,14 @@ const IdentityConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseIdentityConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === IdentityConnectorType.Iota) {
+    if (instanceConfig.type === IdentityConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new identityConnectorIota.IotaIdentityConnector({
+        component = new identityConnectorIota.IotaIdentityConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options,
             config: {
@@ -1550,60 +1304,44 @@ async function initialiseIdentityConnector(engineCore, context, instanceConfig,
         });
         instanceType = identityConnectorIota.IotaIdentityConnector.NAMESPACE;
     }
-    else if (type === IdentityConnectorType.EntityStorage) {
+    else if (instanceConfig.type === IdentityConnectorType.EntityStorage) {
         identityConnectorEntityStorage.initSchema({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new identityConnectorEntityStorage.EntityStorageIdentityConnector({
+        component = new identityConnectorEntityStorage.EntityStorageIdentityConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = identityConnectorEntityStorage.EntityStorageIdentityConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    identityModels.IdentityConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: identityModels.IdentityConnectorFactory
+    };
 }
 /**
  * Initialise the identity component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseIdentityComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityComponentType.Service) {
+    if (instanceConfig.type === IdentityComponentType.Service) {
         component = new identityService.IdentityService(instanceConfig.options);
         instanceType = "identity-service";
     }
-    else if (type === IdentityComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityComponentType.RestClient) {
         component = new identityRestClient.IdentityClient(instanceConfig.options);
         instanceType = "identity-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1643,77 +1381,49 @@ const IdentityProfileConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseIdentityProfileConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityProfileConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === IdentityProfileConnectorType.EntityStorage) {
+    if (instanceConfig.type === IdentityProfileConnectorType.EntityStorage) {
         identityConnectorEntityStorage.initSchema({ includeDocument: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
         connector = new identityConnectorEntityStorage.EntityStorageIdentityProfileConnector(instanceConfig.options);
         instanceType = identityConnectorEntityStorage.EntityStorageIdentityProfileConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            serviceType: "identityProfile"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    identityModels.IdentityProfileConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component: connector,
+        instanceType,
+        factory: identityModels.IdentityProfileConnectorFactory
+    };
 }
 /**
  * Initialise the identity profile component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseIdentityProfileComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityProfileComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityProfileComponentType.Service) {
+    if (instanceConfig.type === IdentityProfileComponentType.Service) {
         component = new identityService.IdentityProfileService({
             profileEntityConnectorType: engineCore.getRegisteredInstanceType("identityProfileConnector"),
             ...instanceConfig.options
         });
         instanceType = "identity-profile-service";
     }
-    else if (type === IdentityProfileComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityProfileComponentType.RestClient) {
         component = new identityRestClient.IdentityProfileClient(instanceConfig.options);
         instanceType = "identity-profile-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityProfileComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1761,20 +1471,14 @@ const IdentityResolverConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseIdentityResolverConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Resolver Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityResolverConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === IdentityResolverConnectorType.Iota) {
+    if (instanceConfig.type === IdentityResolverConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new identityConnectorIota.IotaIdentityResolverConnector({
+        component = new identityConnectorIota.IotaIdentityResolverConnector({
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1783,49 +1487,38 @@ async function initialiseIdentityResolverConnector(engineCore, context, instance
         });
         instanceType = identityConnectorIota.IotaIdentityResolverConnector.NAMESPACE;
     }
-    else if (type === IdentityResolverConnectorType.EntityStorage) {
+    else if (instanceConfig.type === IdentityResolverConnectorType.EntityStorage) {
         identityConnectorEntityStorage.initSchema({ includeProfile: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new identityConnectorEntityStorage.EntityStorageIdentityResolverConnector({
+        component = new identityConnectorEntityStorage.EntityStorageIdentityResolverConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             ...instanceConfig.options
         });
         instanceType = identityConnectorEntityStorage.EntityStorageIdentityResolverConnector.NAMESPACE;
     }
-    else if (type === IdentityResolverConnectorType.Universal) {
-        connector = new identityConnectorUniversal.UniversalResolverConnector({
+    else if (instanceConfig.type === IdentityResolverConnectorType.Universal) {
+        component = new identityConnectorUniversal.UniversalResolverConnector({
             ...instanceConfig.options
         });
         instanceType = identityConnectorUniversal.UniversalResolverConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityResolverConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    identityModels.IdentityResolverConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: identityModels.IdentityResolverConnectorFactory
+    };
 }
 /**
  * Initialise the identity resolver component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseIdentityResolverComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Resolver Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseIdentityResolverComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === IdentityResolverComponentType.Service) {
+    if (instanceConfig.type === IdentityResolverComponentType.Service) {
         const defaultIdentityResolverType = engineCore.getRegisteredInstanceType("identityResolverConnector");
         component = new identityService.IdentityResolverService({
             fallbackResolverConnectorType: defaultIdentityResolverType !== IdentityResolverConnectorType.Universal
@@ -1835,20 +1528,15 @@ async function initialiseIdentityResolverComponent(engineCore, context, instance
         });
         instanceType = "identity-resolver-service";
     }
-    else if (type === IdentityResolverComponentType.RestClient) {
+    else if (instanceConfig.type === IdentityResolverComponentType.RestClient) {
         component = new identityRestClient.IdentityResolverClient(instanceConfig.options);
         instanceType = "identity-resolver-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityResolverComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1875,18 +1563,12 @@ const ImmutableProofComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseImmutableProofComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Proof Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseImmutableProofComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === ImmutableProofComponentType.Service) {
+    if (instanceConfig.type === ImmutableProofComponentType.Service) {
         immutableProofService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
         component = new immutableProofService.ImmutableProofService({
@@ -1898,23 +1580,15 @@ async function initialiseImmutableProofComponent(engineCore, context, instanceCo
         });
         instanceType = "immutable-proof-service";
     }
-    else if (type === ImmutableProofComponentType.RestClient) {
+    else if (instanceConfig.type === ImmutableProofComponentType.RestClient) {
         component = new immutableProofRestClient.ImmutableProofClient(instanceConfig.options);
         instanceType = "immutable-proof-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "immutableProofComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1962,79 +1636,57 @@ const LoggingConnectorType = {
  * @param engineCore The engine core.
  * @param context The engine core context.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseLoggingConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseLoggingConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === LoggingConnectorType.Console) {
-        connector = new loggingConnectorConsole.ConsoleLoggingConnector(instanceConfig.options);
+    if (instanceConfig.type === LoggingConnectorType.Console) {
+        component = new loggingConnectorConsole.ConsoleLoggingConnector(instanceConfig.options);
         instanceType = loggingConnectorConsole.ConsoleLoggingConnector.NAMESPACE;
     }
-    else if (type === LoggingConnectorType.EntityStorage) {
+    else if (instanceConfig.type === LoggingConnectorType.EntityStorage) {
         loggingConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
-        connector = new loggingConnectorEntityStorage.EntityStorageLoggingConnector(instanceConfig.options);
+        component = new loggingConnectorEntityStorage.EntityStorageLoggingConnector(instanceConfig.options);
         instanceType = loggingConnectorEntityStorage.EntityStorageLoggingConnector.NAMESPACE;
     }
-    else if (type === LoggingConnectorType.Multi) {
-        connector = new loggingModels.MultiLoggingConnector(instanceConfig.options);
+    else if (instanceConfig.type === LoggingConnectorType.Multi) {
+        component = new loggingModels.MultiLoggingConnector(instanceConfig.options);
         instanceType = loggingModels.MultiLoggingConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "loggingConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    loggingModels.LoggingConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: loggingModels.LoggingConnectorFactory
+    };
 }
 /**
  * Initialise the logging component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseLoggingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseLoggingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === LoggingComponentType.Service) {
+    if (instanceConfig.type === LoggingComponentType.Service) {
         component = new loggingService.LoggingService({
             loggingConnectorType: engineCore.getRegisteredInstanceType("loggingConnector"),
             ...instanceConfig.options
         });
         instanceType = "logging-service";
     }
-    else if (type === LoggingComponentType.RestClient) {
+    else if (instanceConfig.type === LoggingComponentType.RestClient) {
         component = new loggingRestClient.LoggingClient(instanceConfig.options);
         instanceType = "logging-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "loggingComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2121,61 +1773,44 @@ const MessagingSmsConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseMessagingEmailConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Email Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingEmailConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === MessagingEmailConnectorType.EntityStorage) {
+    if (instanceConfig.type === MessagingEmailConnectorType.EntityStorage) {
         messagingConnectorEntityStorage.initSchema({ email: true, sms: false, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingEmailEntryStorageConnectorType, "EmailEntry");
-        connector = new messagingConnectorEntityStorage.EntityStorageMessagingEmailConnector({
+        component = new messagingConnectorEntityStorage.EntityStorageMessagingEmailConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingEmailConnector.NAMESPACE;
     }
-    else if (type === MessagingEmailConnectorType.Aws) {
-        connector = new messagingConnectorAws.AwsMessagingEmailConnector({
+    else if (instanceConfig.type === MessagingEmailConnectorType.Aws) {
+        component = new messagingConnectorAws.AwsMessagingEmailConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingEmailConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingEmailConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    messagingModels.MessagingEmailConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: messagingModels.MessagingEmailConnectorFactory
+    };
 }
 /**
  * Initialise a messaging sms connector.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseMessagingSmsConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging SMS Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingSmsConnector(engineCore, context, instanceConfig) {
     let connector;
     let instanceType;
-    if (type === MessagingSmsConnectorType.EntityStorage) {
+    if (instanceConfig.type === MessagingSmsConnectorType.EntityStorage) {
         messagingConnectorEntityStorage.initSchema({ email: false, sms: true, pushNotification: false });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingSmsEntryStorageConnectorType, "SmsEntry");
         connector = new messagingConnectorEntityStorage.EntityStorageMessagingSmsConnector({
@@ -2184,85 +1819,63 @@ async function initialiseMessagingSmsConnector(engineCore, context, instanceConf
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingSmsConnector.NAMESPACE;
     }
-    else if (type === MessagingSmsConnectorType.Aws) {
+    else if (instanceConfig.type === MessagingSmsConnectorType.Aws) {
         connector = new messagingConnectorAws.AwsMessagingSmsConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingSmsConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingSmsConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    messagingModels.MessagingSmsConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: messagingModels.MessagingSmsConnectorFactory,
+        component: connector
+    };
 }
 /**
  * Initialise a messaging push notification connector.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseMessagingPushNotificationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Push Notification Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingPushNotificationConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === MessagingPushNotificationConnectorType.EntityStorage) {
+    if (instanceConfig.type === MessagingPushNotificationConnectorType.EntityStorage) {
         messagingConnectorEntityStorage.initSchema({ email: false, sms: false, pushNotification: true });
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingDeviceEntryStorageConnectorType, "PushNotificationDeviceEntry");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.messagingMessageEntryStorageConnectorType, "PushNotificationMessageEntry");
-        connector = new messagingConnectorEntityStorage.EntityStorageMessagingPushNotificationConnector({
+        component = new messagingConnectorEntityStorage.EntityStorageMessagingPushNotificationConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorEntityStorage.EntityStorageMessagingPushNotificationConnector.NAMESPACE;
     }
-    else if (type === MessagingPushNotificationConnectorType.Aws) {
-        connector = new messagingConnectorAws.AwsMessagingPushNotificationConnector({
+    else if (instanceConfig.type === MessagingPushNotificationConnectorType.Aws) {
+        component = new messagingConnectorAws.AwsMessagingPushNotificationConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = messagingConnectorAws.AwsMessagingPushNotificationConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "messagingPushNotificationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    messagingModels.MessagingPushNotificationsConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: messagingModels.MessagingPushNotificationsConnectorFactory
+    };
 }
 /**
  * Initialise the messaging component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseMessagingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === MessagingComponentType.Service) {
+    if (instanceConfig.type === MessagingComponentType.Service) {
         component = new messagingService.MessagingService({
             messagingEmailConnectorType: engineCore.getRegisteredInstanceTypeOptional("messagingEmailConnector"),
             messagingSmsConnectorType: engineCore.getRegisteredInstanceTypeOptional("messagingSmsConnector"),
@@ -2272,34 +1885,23 @@ async function initialiseMessagingComponent(engineCore, context, instanceConfig,
         });
         instanceType = "messaging-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "messagingComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 /**
  * Initialise the messaging admin component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseMessagingAdminComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Messaging Admin Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseMessagingAdminComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === MessagingAdminComponentType.Service) {
+    if (instanceConfig.type === MessagingAdminComponentType.Service) {
         messagingService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.templateEntryStorageConnectorType, "TemplateEntry");
         component = new messagingService.MessagingAdminService({
@@ -2307,16 +1909,11 @@ async function initialiseMessagingAdminComponent(engineCore, context, instanceCo
         });
         instanceType = "messaging-admin-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "messagingAdminComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2360,26 +1957,20 @@ const NftConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseNftConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `NFT Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseNftConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === NftConnectorType.EntityStorage) {
+    if (instanceConfig.type === NftConnectorType.EntityStorage) {
         nftConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
-        connector = new nftConnectorEntityStorage.EntityStorageNftConnector(instanceConfig.options);
+        component = new nftConnectorEntityStorage.EntityStorageNftConnector(instanceConfig.options);
         instanceType = nftConnectorEntityStorage.EntityStorageNftConnector.NAMESPACE;
     }
-    else if (type === NftConnectorType.Iota) {
+    else if (instanceConfig.type === NftConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new nftConnectorIota.IotaNftConnector({
+        component = new nftConnectorIota.IotaNftConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             walletConnectorType: engineCore.getRegisteredInstanceType("walletConnector"),
             loggingComponentType: engineCore.getRegisteredInstanceTypeOptional("loggingComponent"),
@@ -2391,57 +1982,35 @@ async function initialiseNftConnector(engineCore, context, instanceConfig, overr
         });
         instanceType = nftConnectorIota.IotaNftConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "nftConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    nftModels.NftConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: nftModels.NftConnectorFactory
+    };
 }
 /**
  * Initialise the NFT component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseNftComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Nft Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseNftComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === NftComponentType.Service) {
+    if (instanceConfig.type === NftComponentType.Service) {
         component = new nftService.NftService(instanceConfig.options);
         instanceType = "nft-service";
     }
-    else if (type === NftComponentType.RestClient) {
+    else if (instanceConfig.type === NftComponentType.RestClient) {
         component = new nftRestClient.NftClient(instanceConfig.options);
         instanceType = "nft-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "nftComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2468,18 +2037,12 @@ const RightsManagementDapComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementDapComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management DAP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementDapComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementDapComponentType.Service) {
+    if (instanceConfig.type === RightsManagementDapComponentType.Service) {
         component = new rightsManagementDapService.DataAccessPointService({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             policyEnforcementPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPepComponent"),
@@ -2490,7 +2053,7 @@ async function initialiseRightsManagementDapComponent(engineCore, context, insta
         });
         instanceType = "data-access-point-service";
     }
-    else if (type === RightsManagementDapComponentType.RestClient) {
+    else if (instanceConfig.type === RightsManagementDapComponentType.RestClient) {
         component = new rightsManagementRestClient.DataAccessPointClient({
             ...instanceConfig.options,
             authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
@@ -2500,19 +2063,11 @@ async function initialiseRightsManagementDapComponent(engineCore, context, insta
         });
         instanceType = "data-access-point-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementDapComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2535,37 +2090,23 @@ const RightsManagementDarpComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementDarpComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management DARP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementDarpComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementDarpComponentType.Service) {
+    if (instanceConfig.type === RightsManagementDarpComponentType.Service) {
         component = new rightsManagementDapService.DataAccessRequestPointService({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = "data-access-request-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementDarpComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2592,18 +2133,12 @@ const RightsManagementPapComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPapComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PAP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPapComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPapComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPapComponentType.Service) {
         rightsManagementPapService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.odrlPolicyEntityStorageType, "OdrlPolicy");
         component = new rightsManagementPapService.PolicyAdministrationPointService({
@@ -2612,23 +2147,15 @@ async function initialiseRightsManagementPapComponent(engineCore, context, insta
         });
         instanceType = "policy-administration-point-service";
     }
-    else if (type === RightsManagementPapComponentType.RestClient) {
+    else if (instanceConfig.type === RightsManagementPapComponentType.RestClient) {
         component = new rightsManagementRestClient.PolicyAdministrationPointClient(instanceConfig.options);
         instanceType = "policy-administration-point-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPapComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2651,18 +2178,12 @@ const RightsManagementPdpComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPdpComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
-    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PDP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPdpComponent(engineCore$1, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPdpComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPdpComponentType.Service) {
         const arbiterModules = [];
         if (core.Is.arrayValue(instanceConfig.options?.arbiterModulesConfig)) {
             for (const moduleConfig of instanceConfig.options.arbiterModulesConfig) {
@@ -2685,19 +2206,11 @@ async function initialiseRightsManagementPdpComponent(engineCore$1, context, ins
         });
         instanceType = "policy-decision-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPdpComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2724,18 +2237,12 @@ const RightsManagementPepComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPepComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
-    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PEP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPepComponent(engineCore$1, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPepComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPepComponentType.Service) {
         const processorModules = [];
         if (core.Is.arrayValue(instanceConfig.options?.processorModulesConfig)) {
             for (const moduleConfig of instanceConfig.options.processorModulesConfig) {
@@ -2756,19 +2263,11 @@ async function initialiseRightsManagementPepComponent(engineCore$1, context, ins
         });
         instanceType = "policy-enforcement-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPepComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2791,18 +2290,12 @@ const RightsManagementPipComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPipComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
-    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PIP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPipComponent(engineCore$1, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPipComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPipComponentType.Service) {
         const informationSourceModules = [];
         if (core.Is.arrayValue(instanceConfig.options?.informationModulesConfig)) {
             for (const moduleConfig of instanceConfig.options.informationModulesConfig) {
@@ -2822,19 +2315,11 @@ async function initialiseRightsManagementPipComponent(engineCore$1, context, ins
         });
         instanceType = "policy-information-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPipComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2857,18 +2342,12 @@ const RightsManagementPmpComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPmpComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PMP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPmpComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPmpComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPmpComponentType.Service) {
         component = new rightsManagementPmpService.PolicyManagementPointService({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             policyAdministrationPointComponentType: engineCore.getRegisteredInstanceType("rightsManagementPapComponent"),
@@ -2876,19 +2355,11 @@ async function initialiseRightsManagementPmpComponent(engineCore, context, insta
         });
         instanceType = "policy-management-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPmpComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2915,18 +2386,12 @@ const RightsManagementPnapComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPnapComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PNAP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPnapComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPnapComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPnapComponentType.Service) {
         rightsManagementPnpService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.policyNegotiationEntityStorageType, "PolicyNegotiation");
         component = new rightsManagementPnpService.PolicyNegotiationAdminPointService({
@@ -2937,23 +2402,15 @@ async function initialiseRightsManagementPnapComponent(engineCore, context, inst
         });
         instanceType = "policy-negotiation-admin-point-service";
     }
-    else if (type === RightsManagementPnapComponentType.RestClient) {
+    else if (instanceConfig.type === RightsManagementPnapComponentType.RestClient) {
         component = new rightsManagementRestClient.PolicyNegotiationAdminPointClient(instanceConfig.options);
         instanceType = "policy-negotiation-admin-point-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPnapComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -2980,18 +2437,12 @@ const RightsManagementPnpComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPnpComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
-    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PNP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPnpComponent(engineCore$1, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPnpComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPnpComponentType.Service) {
         const negotiatorModules = [];
         if (core.Is.arrayValue(instanceConfig.options?.negotiatorModulesConfig)) {
             for (const moduleConfig of instanceConfig.options.negotiatorModulesConfig) {
@@ -3024,7 +2475,7 @@ async function initialiseRightsManagementPnpComponent(engineCore$1, context, ins
         });
         instanceType = "policy-negotiation-point-service";
     }
-    else if (type === RightsManagementPnpComponentType.RestClient) {
+    else if (instanceConfig.type === RightsManagementPnpComponentType.RestClient) {
         component = new rightsManagementRestClient.PolicyNegotiationPointClient({
             ...instanceConfig.options,
             authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
@@ -3034,19 +2485,11 @@ async function initialiseRightsManagementPnpComponent(engineCore$1, context, ins
         });
         instanceType = "policy-negotiation-point-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPnpComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3069,18 +2512,12 @@ const RightsManagementPxpComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseRightsManagementPxpComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
-    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Rights Management PXP Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseRightsManagementPxpComponent(engineCore$1, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === RightsManagementPxpComponentType.Service) {
+    if (instanceConfig.type === RightsManagementPxpComponentType.Service) {
         const modules = [];
         if (core.Is.arrayValue(instanceConfig.options?.actionModulesConfig)) {
             for (const moduleConfig of instanceConfig.options.actionModulesConfig) {
@@ -3100,19 +2537,11 @@ async function initialiseRightsManagementPxpComponent(engineCore$1, context, ins
         });
         instanceType = "policy-execution-point-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "RightsManagementPxpComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3139,18 +2568,12 @@ const SynchronisedStorageComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseSynchronisedStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Synchronised Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseSynchronisedStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === SynchronisedStorageComponentType.Service) {
+    if (instanceConfig.type === SynchronisedStorageComponentType.Service) {
         synchronisedStorageService.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.syncSnapshotStorageConnectorType, "SyncSnapshotEntry");
         component = new synchronisedStorageService.SynchronisedStorageService({
@@ -3168,7 +2591,7 @@ async function initialiseSynchronisedStorageComponent(engineCore, context, insta
         });
         instanceType = "synchronised-storage-service";
     }
-    else if (type === SynchronisedStorageComponentType.RestClient) {
+    else if (instanceConfig.type === SynchronisedStorageComponentType.RestClient) {
         component = new synchronisedStorageRestClient.SynchronisedStorageClient({
             ...instanceConfig.options,
             authenticationGeneratorType: instanceConfig.options?.authenticationGeneratorType ??
@@ -3178,19 +2601,11 @@ async function initialiseSynchronisedStorageComponent(engineCore, context, insta
         });
         instanceType = "synchronised-storage-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "SynchronisedStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3211,37 +2626,23 @@ const TaskSchedulerComponentType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseTaskSchedulerComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Task Scheduler: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTaskSchedulerComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === TaskSchedulerComponentType.Service) {
+    if (instanceConfig.type === TaskSchedulerComponentType.Service) {
         component = new backgroundTaskScheduler.TaskSchedulerService({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = "task-scheduler-service";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "taskSchedulerComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3281,75 +2682,53 @@ const TelemetryConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseTelemetryConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTelemetryConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === TelemetryConnectorType.EntityStorage) {
+    if (instanceConfig.type === TelemetryConnectorType.EntityStorage) {
         telemetryConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
-        connector = new telemetryConnectorEntityStorage.EntityStorageTelemetryConnector({
+        component = new telemetryConnectorEntityStorage.EntityStorageTelemetryConnector({
             loggingComponentType: engineCore.getRegisteredInstanceType("loggingComponent"),
             ...instanceConfig.options
         });
         instanceType = telemetryConnectorEntityStorage.EntityStorageTelemetryConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "telemetryConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    telemetryModels.TelemetryConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        instanceType,
+        factory: telemetryModels.TelemetryConnectorFactory,
+        component
+    };
 }
 /**
  * Initialise the telemetry component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseTelemetryComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseTelemetryComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === TelemetryComponentType.Service) {
+    if (instanceConfig.type === TelemetryComponentType.Service) {
         component = new telemetryService.TelemetryService({
             telemetryConnectorType: engineCore.getRegisteredInstanceType("telemetryConnector"),
             ...instanceConfig.options
         });
         instanceType = "telemetry-service";
     }
-    else if (type === TelemetryComponentType.RestClient) {
+    else if (instanceConfig.type === TelemetryComponentType.RestClient) {
         component = new telemetryRestClient.TelemetryClient(instanceConfig.options);
         instanceType = "telemetry-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "telemetryComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3369,45 +2748,32 @@ const VaultConnectorType = {
     Hashicorp: "hashicorp"
 };
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialise the vault connector.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseVaultConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Vault Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVaultConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === VaultConnectorType.EntityStorage) {
+    if (instanceConfig.type === VaultConnectorType.EntityStorage) {
         vaultConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
-        connector = new vaultConnectorEntityStorage.EntityStorageVaultConnector(instanceConfig.options);
+        component = new vaultConnectorEntityStorage.EntityStorageVaultConnector(instanceConfig.options);
         instanceType = vaultConnectorEntityStorage.EntityStorageVaultConnector.NAMESPACE;
     }
-    else if (type === VaultConnectorType.Hashicorp) {
-        connector = new vaultConnectorHashicorp.HashicorpVaultConnector(instanceConfig.options);
+    else if (instanceConfig.type === VaultConnectorType.Hashicorp) {
+        component = new vaultConnectorHashicorp.HashicorpVaultConnector(instanceConfig.options);
         instanceType = vaultConnectorHashicorp.HashicorpVaultConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "vaultConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    vaultModels.VaultConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: vaultModels.VaultConnectorFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3451,20 +2817,14 @@ const VerifiableStorageConnectorType = {
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseVerifiableStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Verifiable Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVerifiableStorageConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === VerifiableStorageConnectorType.Iota) {
+    if (instanceConfig.type === VerifiableStorageConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new verifiableStorageConnectorIota.IotaVerifiableStorageConnector({
+        component = new verifiableStorageConnectorIota.IotaVerifiableStorageConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             loggingComponentType: engineCore.getRegisteredInstanceTypeOptional("loggingComponent"),
             ...instanceConfig.options,
@@ -3475,65 +2835,43 @@ async function initialiseVerifiableStorageConnector(engineCore, context, instanc
         });
         instanceType = verifiableStorageConnectorIota.IotaVerifiableStorageConnector.NAMESPACE;
     }
-    else if (type === VerifiableStorageConnectorType.EntityStorage) {
+    else if (instanceConfig.type === VerifiableStorageConnectorType.EntityStorage) {
         verifiableStorageConnectorEntityStorage.initSchema();
         initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.verifiableStorageEntityStorageType, "VerifiableItem");
-        connector = new verifiableStorageConnectorEntityStorage.EntityStorageVerifiableStorageConnector(instanceConfig.options);
+        component = new verifiableStorageConnectorEntityStorage.EntityStorageVerifiableStorageConnector(instanceConfig.options);
         instanceType = verifiableStorageConnectorEntityStorage.EntityStorageVerifiableStorageConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "verifiableStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    verifiableStorageModels.VerifiableStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: verifiableStorageModels.VerifiableStorageConnectorFactory
+    };
 }
 /**
  * Initialise the verifiable storage component.
  * @param engineCore The engine core.
  * @param context The context for the engine.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-async function initialiseVerifiableStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Verifiable Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseVerifiableStorageComponent(engineCore, context, instanceConfig) {
     let component;
     let instanceType;
-    if (type === VerifiableStorageComponentType.Service) {
+    if (instanceConfig.type === VerifiableStorageComponentType.Service) {
         component = new verifiableStorageService.VerifiableStorageService({
             ...instanceConfig.options
         });
         instanceType = "verifiable-storage-service";
     }
-    else if (type === VerifiableStorageComponentType.RestClient) {
+    else if (instanceConfig.type === VerifiableStorageComponentType.RestClient) {
         component = new verifiableStorageRestClient.VerifiableStorageClient(instanceConfig.options);
         instanceType = "verifiable-storage-client";
     }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "verifiableStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
+    return {
+        component,
+        instanceType,
+        factory: core.ComponentFactory
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -3553,27 +2891,19 @@ const WalletConnectorType = {
     Iota: "iota"
 };
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialise a wallet connector.
  * @param engineCore The engine core.
  * @param context The context for the node.
  * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseWalletConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Wallet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
+ * @returns The instance created and the factory for it.
+ */
+async function initialiseWalletConnector(engineCore, context, instanceConfig) {
+    let component;
     let instanceType;
-    if (type === WalletConnectorType.Iota) {
+    if (instanceConfig.type === WalletConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(engineCore.getConfig(), "dltConfig", DltConfigType.Iota);
-        connector = new walletConnectorIota.IotaWalletConnector({
+        component = new walletConnectorIota.IotaWalletConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options,
@@ -3584,51 +2914,21 @@ async function initialiseWalletConnector(engineCore, context, instanceConfig, ov
         });
         instanceType = walletConnectorIota.IotaWalletConnector.NAMESPACE;
     }
-    else if (type === WalletConnectorType.EntityStorage) {
-        connector = new walletConnectorEntityStorage.EntityStorageWalletConnector({
+    else if (instanceConfig.type === WalletConnectorType.EntityStorage) {
+        walletConnectorEntityStorage.initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+        component = new walletConnectorEntityStorage.EntityStorageWalletConnector({
             vaultConnectorType: engineCore.getRegisteredInstanceType("vaultConnector"),
             faucetConnectorType: engineCore.getRegisteredInstanceType("faucetConnector"),
             ...instanceConfig.options
         });
         instanceType = walletConnectorEntityStorage.EntityStorageWalletConnector.NAMESPACE;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    walletModels.WalletConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the wallet storage.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns Nothing.
- * @throws GeneralError if the connector type is unknown.
- */
-async function initialiseWalletStorage(engineCore, context, instanceConfig, overrideInstanceType) {
-    const type = instanceConfig.type;
-    if (type === WalletConnectorType.Iota) ;
-    else if (type === WalletConnectorType.EntityStorage) {
-        walletConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
-    }
-    return undefined;
+    return {
+        component,
+        instanceType,
+        factory: walletModels.WalletConnectorFactory
+    };
 }
 
 exports.AttestationComponentType = AttestationComponentType;
@@ -3739,4 +3039,3 @@ exports.initialiseVaultConnector = initialiseVaultConnector;
 exports.initialiseVerifiableStorageComponent = initialiseVerifiableStorageComponent;
 exports.initialiseVerifiableStorageConnector = initialiseVerifiableStorageConnector;
 exports.initialiseWalletConnector = initialiseWalletConnector;
-exports.initialiseWalletStorage = initialiseWalletStorage;