@twin.org/engine-core 0.0.1-next.9 → 0.0.1

package/dist/esm/index.mjs

@@ -1,1183 +1,63 @@
-import path from 'node:path';
-import { StringHelper, Is, GeneralError, I18n, ComponentFactory, BaseError, ErrorHelper, Guards, Coerce, ObjectHelper } from '@twin.org/core';
-import { EntityStorageConnectorType, EntityStorageComponentType, AttestationConnectorType, AttestationComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, BackgroundTaskConnectorType, BlobStorageConnectorType, BlobStorageComponentType, FaucetConnectorType, IdentityConnectorType, IdentityComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, ImmutableProofComponentType, ImmutableStorageConnectorType, LoggingConnectorType, LoggingComponentType, NftConnectorType, NftComponentType, TelemetryConnectorType, TelemetryComponentType, VaultConnectorType, WalletConnectorType } from '@twin.org/engine-models';
-import { CosmosDbEntityStorageConnector } from '@twin.org/entity-storage-connector-cosmosdb';
-import { DynamoDbEntityStorageConnector } from '@twin.org/entity-storage-connector-dynamodb';
-import { FileEntityStorageConnector } from '@twin.org/entity-storage-connector-file';
-import { FirestoreEntityStorageConnector } from '@twin.org/entity-storage-connector-gcp-firestore';
-import { MemoryEntityStorageConnector } from '@twin.org/entity-storage-connector-memory';
-import { ScyllaDBTableConnector } from '@twin.org/entity-storage-connector-scylladb';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { EntityStorageService } from '@twin.org/entity-storage-service';
+import { I18n, StringHelper, Is, ObjectHelper, BaseError, GeneralError, ErrorHelper, Guards } from '@twin.org/core';
+import { EntitySchemaFactory } from '@twin.org/entity';
 import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
-import { MultiLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
-import { EntityStorageAttestationConnector } from '@twin.org/attestation-connector-entity-storage';
-import { IotaAttestationConnector } from '@twin.org/attestation-connector-iota';
-import { AttestationConnectorFactory } from '@twin.org/attestation-models';
-import { AttestationService } from '@twin.org/attestation-service';
-import { initSchema, AuditableItemGraphService } from '@twin.org/auditable-item-graph-service';
-import { initSchema as initSchema$1, AuditableItemStreamService } from '@twin.org/auditable-item-stream-service';
-import { initSchema as initSchema$2, EntityStorageBackgroundTaskConnector } from '@twin.org/background-task-connector-entity-storage';
-import { BackgroundTaskConnectorFactory } from '@twin.org/background-task-models';
-import { S3BlobStorageConnector } from '@twin.org/blob-storage-connector-aws-s3';
-import { AzureBlobStorageConnector } from '@twin.org/blob-storage-connector-azure';
-import { FileBlobStorageConnector } from '@twin.org/blob-storage-connector-file';
-import { GcpBlobStorageConnector } from '@twin.org/blob-storage-connector-gcp';
-import { IpfsBlobStorageConnector } from '@twin.org/blob-storage-connector-ipfs';
-import { MemoryBlobStorageConnector } from '@twin.org/blob-storage-connector-memory';
-import { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
-import { initSchema as initSchema$3, BlobStorageService } from '@twin.org/blob-storage-service';
-import { EntityStorageFaucetConnector, EntityStorageWalletConnector, initSchema as initSchema$b } from '@twin.org/wallet-connector-entity-storage';
-import { IotaFaucetConnector, IotaWalletConnector } from '@twin.org/wallet-connector-iota';
-import { FaucetConnectorFactory, WalletConnectorFactory } from '@twin.org/wallet-models';
-import { initSchema as initSchema$4, EntityStorageIdentityConnector, EntityStorageIdentityProfileConnector } from '@twin.org/identity-connector-entity-storage';
-import { IotaIdentityConnector } from '@twin.org/identity-connector-iota';
-import { IdentityConnectorFactory, IdentityProfileConnectorFactory } from '@twin.org/identity-models';
-import { IdentityService, IdentityProfileService } from '@twin.org/identity-service';
-import { initSchema as initSchema$5, ImmutableProofService } from '@twin.org/immutable-proof-service';
-import { initSchema as initSchema$6, EntityStorageImmutableStorageConnector } from '@twin.org/immutable-storage-connector-entity-storage';
-import { IotaImmutableStorageConnector } from '@twin.org/immutable-storage-connector-iota';
-import { ImmutableStorageConnectorFactory } from '@twin.org/immutable-storage-models';
-import { initSchema as initSchema$7, EntityStorageLoggingConnector } from '@twin.org/logging-connector-entity-storage';
-import { LoggingService } from '@twin.org/logging-service';
-import { initSchema as initSchema$8, EntityStorageNftConnector } from '@twin.org/nft-connector-entity-storage';
-import { IotaNftConnector } from '@twin.org/nft-connector-iota';
-import { NftConnectorFactory } from '@twin.org/nft-models';
-import { NftService } from '@twin.org/nft-service';
-import { initSchema as initSchema$9, EntityStorageTelemetryConnector } from '@twin.org/telemetry-connector-entity-storage';
-import { TelemetryConnectorFactory } from '@twin.org/telemetry-models';
-import { TelemetryService } from '@twin.org/telemetry-service';
-import { initSchema as initSchema$a, EntityStorageVaultConnector } from '@twin.org/vault-connector-entity-storage';
-import { HashicorpVaultConnector } from '@twin.org/vault-connector-hashicorp';
-import { VaultConnectorFactory } from '@twin.org/vault-models';
-import { readFile, writeFile, stat } from 'node:fs/promises';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the entity storage connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param typeCustom Override the type of connector to use instead of default configuration.
- * @param schema The schema for the entity storage.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
-    const instanceName = StringHelper.kebabCase(schema);
-    let entityStorageConfig;
-    if (Is.stringValue(typeCustom)) {
-        // A custom type has been specified, so look it up
-        entityStorageConfig = context.config.entityStorageConnector?.find(c => c.type === typeCustom || c.overrideInstanceType === typeCustom);
-        if (Is.empty(entityStorageConfig)) {
-            throw new GeneralError("engineCore", "entityStorageCustomMissing", {
-                typeCustom,
-                storageName: instanceName
-            });
-        }
-    }
-    else {
-        // The default entity storage method is either the one with the isDefault flag set
-        // or pick the first one if no default is set.
-        entityStorageConfig =
-            context.config.entityStorageConnector?.find(c => c.isDefault ?? false) ??
-                context.config.entityStorageConnector?.[0];
-        if (Is.empty(entityStorageConfig)) {
-            throw new GeneralError("engineCore", "entityStorageMissing", {
-                storageName: instanceName
-            });
-        }
-    }
-    const type = entityStorageConfig.type;
-    let entityStorageConnector;
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuringEntityStorage", {
-        element: "Entity Storage",
-        storageName: instanceName,
-        storageType: type
-    }));
-    if (type === EntityStorageConnectorType.Memory) {
-        entityStorageConnector = new MemoryEntityStorageConnector({
-            entitySchema: schema
-        });
-    }
-    else if (type === EntityStorageConnectorType.File) {
-        entityStorageConnector = new FileEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                directory: path.join(entityStorageConfig.options.config.directory, instanceName)
-            }
-        });
-    }
-    else if (type === EntityStorageConnectorType.AwsDynamoDb) {
-        entityStorageConnector = new DynamoDbEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === EntityStorageConnectorType.AzureCosmosDb) {
-        entityStorageConnector = new CosmosDbEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                containerId: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === EntityStorageConnectorType.GcpFirestoreDb) {
-        entityStorageConnector = new FirestoreEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                collectionName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === EntityStorageConnectorType.ScyllaDb) {
-        entityStorageConnector = new ScyllaDBTableConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "entityStorageConnector"
-        });
-    }
-    context.componentInstances.push({
-        instanceType: instanceName,
-        component: entityStorageConnector
-    });
-    EntityStorageConnectorFactory.register(instanceName, () => entityStorageConnector);
-}
-/**
- * Initialise the entity storage 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.
- */
-function initialiseEntityStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Entity Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === EntityStorageComponentType.Service) {
-        const kebabName = 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.entityStorageConnector?.some(c => c.type === kebabName || c.overrideInstanceType === kebabName);
-        initialiseEntityStorageConnector(engineCore, context, hasCustom ? kebabName : undefined, instanceConfig.options.entityStorageType);
-        connector = new EntityStorageService({
-            entityStorageType: kebabName,
-            config: {
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = StringHelper.kebabCase(instanceConfig.options.entityStorageType);
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            serviceType: "entityStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    ComponentFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the attestation 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.
- */
-function initialiseAttestationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === AttestationConnectorType.Iota) {
-        connector = new IotaAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
-            ...instanceConfig.options
-        });
-        instanceType = IotaAttestationConnector.NAMESPACE;
-    }
-    else if (type === AttestationConnectorType.EntityStorage) {
-        connector = new EntityStorageAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
-            ...instanceConfig.options
-        });
-        instanceType = EntityStorageAttestationConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "attestationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    AttestationConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseAttestationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === AttestationComponentType.Service) {
-        component = new AttestationService({
-            walletConnectorType: context.defaultTypes.walletConnector,
-            ...instanceConfig.options
-        });
-        instanceType = AttestationService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "attestationComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-/**
- * Initialise the auditable item graph 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.
- */
-function initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Graph Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === AuditableItemGraphComponentType.Service) {
-        initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
-        component = new AuditableItemGraphService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            ...instanceConfig.options
-        });
-        instanceType = AuditableItemGraphService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemGraphComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-/**
- * Initialise the auditable item stream 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.
- */
-function initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Stream Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === AuditableItemStreamComponentType.Service) {
-        initSchema$1();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
-        component = new AuditableItemStreamService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            ...instanceConfig.options
-        });
-        instanceType = AuditableItemStreamService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemStreamComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a background task 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.
- */
-function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Background Task Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === BackgroundTaskConnectorType.EntityStorage) {
-        initSchema$2();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
-        connector = new EntityStorageBackgroundTaskConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = EntityStorageBackgroundTaskConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "backgroundTaskConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    BackgroundTaskConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the blob storage 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.
- */
-function initialiseBlobStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === BlobStorageConnectorType.Ipfs) {
-        connector = new IpfsBlobStorageConnector(instanceConfig.options);
-        instanceType = IpfsBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === BlobStorageConnectorType.File) {
-        connector = new FileBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                directory: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.directory}`
-            }
-        });
-        instanceType = FileBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === BlobStorageConnectorType.Memory) {
-        connector = new MemoryBlobStorageConnector();
-        instanceType = MemoryBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === BlobStorageConnectorType.AwsS3) {
-        connector = new S3BlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
-            }
-        });
-        instanceType = S3BlobStorageConnector.NAMESPACE;
-    }
-    else if (type === BlobStorageConnectorType.GcpStorage) {
-        connector = new GcpBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
-            }
-        });
-        instanceType = GcpBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === BlobStorageConnectorType.AzureStorage) {
-        connector = new AzureBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                containerName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.containerName}`
-            }
-        });
-        instanceType = AzureBlobStorageConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "blobStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    BlobStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseBlobStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === BlobStorageComponentType.Service) {
-        initSchema$3();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
-        component = new BlobStorageService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            ...instanceConfig.options
-        });
-        instanceType = BlobStorageService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "blobStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// 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.
- */
-function initialiseFaucetConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Faucet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === FaucetConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaFaucetConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = IotaFaucetConnector.NAMESPACE;
-    }
-    else if (type === FaucetConnectorType.EntityStorage) {
-        connector = new EntityStorageFaucetConnector(instanceConfig.options);
-        instanceType = EntityStorageFaucetConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "faucetConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    FaucetConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the identity 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.
- */
-function initialiseIdentityConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === IdentityConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaIdentityConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = IotaIdentityConnector.NAMESPACE;
-    }
-    else if (type === IdentityConnectorType.EntityStorage) {
-        initSchema$4({ includeProfile: false });
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new EntityStorageIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            ...instanceConfig.options
-        });
-        instanceType = EntityStorageIdentityConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    IdentityConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseIdentityComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === IdentityComponentType.Service) {
-        component = new IdentityService(instanceConfig.options);
-        instanceType = IdentityService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the identity profile 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.
- */
-function initialiseIdentityProfileConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === IdentityProfileConnectorType.EntityStorage) {
-        initSchema$4({ includeDocument: false });
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
-        connector = new EntityStorageIdentityProfileConnector(instanceConfig.options);
-        instanceType = EntityStorageIdentityProfileConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            serviceType: "identityProfile"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    IdentityProfileConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseIdentityProfileComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === IdentityProfileComponentType.Service) {
-        component = new IdentityProfileService({
-            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
-            ...instanceConfig.options
-        });
-        instanceType = IdentityProfileService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityProfileComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the immutable proof 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.
- */
-function initialiseImmutableProofComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Proof Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === ImmutableProofComponentType.Service) {
-        initSchema$5();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
-        component = new ImmutableProofService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            immutableStorageType: context.defaultTypes.immutableStorageConnector,
-            identityConnectorType: context.defaultTypes.identityConnector,
-            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
-            ...instanceConfig.options
-        });
-        instanceType = ImmutableProofService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "immutableProofComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the immutable storage 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.
- */
-function initialiseImmutableStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === ImmutableStorageConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaImmutableStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = IotaImmutableStorageConnector.NAMESPACE;
-    }
-    else if (type === ImmutableStorageConnectorType.EntityStorage) {
-        initSchema$6();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableStorageEntityStorageType, "ImmutableItem");
-        connector = new EntityStorageImmutableStorageConnector(instanceConfig.options);
-        instanceType = EntityStorageImmutableStorageConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "immutableStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    ImmutableStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the logging connector.
- * @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.
- */
-function initialiseLoggingConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === LoggingConnectorType.Console) {
-        connector = new ConsoleLoggingConnector(instanceConfig.options);
-        instanceType = ConsoleLoggingConnector.NAMESPACE;
-    }
-    else if (type === LoggingConnectorType.EntityStorage) {
-        initSchema$7();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
-        connector = new EntityStorageLoggingConnector(instanceConfig.options);
-        instanceType = EntityStorageLoggingConnector.NAMESPACE;
-    }
-    else if (type === LoggingConnectorType.Multi) {
-        connector = new MultiLoggingConnector(instanceConfig.options);
-        instanceType = MultiLoggingConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "loggingConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    LoggingConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseLoggingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === LoggingComponentType.Service) {
-        component = new LoggingService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = LoggingService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "loggingComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the NFT 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.
- */
-function initialiseNftConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `NFT Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === NftConnectorType.EntityStorage) {
-        initSchema$8();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
-        connector = new EntityStorageNftConnector(instanceConfig.options);
-        instanceType = EntityStorageNftConnector.NAMESPACE;
-    }
-    else if (type === NftConnectorType.Iota) {
-        connector = new IotaNftConnector({
-            ...instanceConfig.options
-        });
-        instanceType = IotaNftConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "nftConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    NftConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseNftComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Nft Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === NftComponentType.Service) {
-        component = new NftService(instanceConfig.options);
-        instanceType = NftService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "nftComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a telemetry 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.
- */
-function initialiseTelemetryConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === TelemetryConnectorType.EntityStorage) {
-        initSchema$9();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
-        connector = new EntityStorageTelemetryConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = EntityStorageTelemetryConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "telemetryConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    TelemetryConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * 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.
- */
-function initialiseTelemetryComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === TelemetryComponentType.Service) {
-        component = new TelemetryService({
-            telemetryConnectorType: context.defaultTypes.telemetryConnector,
-            ...instanceConfig.options
-        });
-        instanceType = TelemetryService.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "telemetryComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// 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.
- */
-function initialiseVaultConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Vault Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === VaultConnectorType.EntityStorage) {
-        initSchema$a();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
-        connector = new EntityStorageVaultConnector(instanceConfig.options);
-        instanceType = EntityStorageVaultConnector.NAMESPACE;
-    }
-    else if (type === VaultConnectorType.Hashicorp) {
-        connector = new HashicorpVaultConnector(instanceConfig.options);
-        instanceType = HashicorpVaultConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "vaultConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    VaultConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
+import { SilentLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
+import { ModuleHelper } from '@twin.org/modules';
+import { readFile, mkdir, writeFile, stat } from 'node:fs/promises';
+import path from 'node:path';
 
 // 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.
+ * Store state in memory.
  */
-function initialiseWalletConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
-        element: `Wallet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === WalletConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new IotaWalletConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = IotaWalletConnector.NAMESPACE;
-    }
-    else if (type === WalletConnectorType.EntityStorage) {
-        connector = new EntityStorageWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
-            ...instanceConfig.options
-        });
-        instanceType = EntityStorageWalletConnector.NAMESPACE;
-    }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
+class MemoryStateStorage {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "MemoryStateStorage";
+    /**
+     * Readonly mode state file is not updated.
+     * @internal
+     */
+    _readonlyMode;
+    /**
+     * The state object.
+     * @internal
+     */
+    _engineState;
+    /**
+     * Create a new instance of MemoryStateStorage.
+     * @param readonlyMode Whether the file is in read-only mode.
+     * @param state The initial state.
+     */
+    constructor(readonlyMode = false, state) {
+        this._readonlyMode = readonlyMode;
+        this._engineState = state;
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    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.
- */
-function initialiseWalletStorage(engineCore, context, instanceConfig, overrideInstanceType) {
-    const type = instanceConfig.type;
-    if (type === WalletConnectorType.Iota) ;
-    else if (type === WalletConnectorType.EntityStorage) {
-        initSchema$b();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+    /**
+     * Method for loading the state.
+     * @param engineCore The engine core to load the state for.
+     * @returns The state of the engine or undefined if it doesn't exist.
+     */
+    async load(engineCore) {
+        engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
+            filename: this._engineState
+        }));
+        return this._engineState;
     }
-    else {
-        throw new GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
+    /**
+     * Method for saving the state.
+     * @param engineCore The engine core to save the state for.
+     * @param state The state of the engine to save.
+     * @returns Nothing.
+     */
+    async save(engineCore, state) {
+        if (!this._readonlyMode) {
+            engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`));
+            this._engineState = state;
+        }
     }
-    return undefined;
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1196,7 +76,6 @@ class EngineCore {
     CLASS_NAME = "EngineCore";
     /**
      * The core context.
-     * @internal
      */
     _context;
     /**
@@ -1214,11 +93,26 @@ class EngineCore {
      * @internal
      */
     _skipBootstrap;
+    /**
+     * The logger type name to use.
+     * @internal
+     */
+    _loggerTypeName;
     /**
      * The type initialisers.
      * @internal
      */
     _typeInitialisers;
+    /**
+     * Is the engine started.
+     * @internal
+     */
+    _isStarted;
+    /**
+     * Add type initialisers to the engine.
+     * @internal
+     */
+    _populateTypeInitialisers;
     /**
      * Method for bootstrapping any data for the engine.
      * @internal
@@ -1233,61 +127,94 @@ class EngineCore {
         options.config = options.config ?? {};
         options.config.debug = options.config.debug ?? false;
         options.config.silent = options.config.silent ?? false;
+        options.config.types ??= {};
         this._skipBootstrap = options.skipBootstrap ?? false;
+        this._populateTypeInitialisers = options.populateTypeInitialisers;
         this._customBootstrap = options.customBootstrap;
+        this._loggerTypeName = options.loggerTypeName ?? EngineCore.LOGGER_TYPE_NAME;
         this._typeInitialisers = [];
         this._context = {
             config: options.config,
             defaultTypes: {},
             componentInstances: [],
-            state: { bootstrappedComponents: [] },
+            state: { componentStates: {} },
             stateDirty: false
         };
         this._stateStorage = options.stateStorage;
-        this.addCoreTypeInitialisers();
+        this._isStarted = false;
+        if (Is.function(this._populateTypeInitialisers)) {
+            this._populateTypeInitialisers(this, this._context);
+        }
     }
     /**
      * Add a type initialiser.
      * @param type The type to add the initialiser for.
      * @param typeConfig The type config.
-     * @param initialiser The initialiser to add.
+     * @param module The name of the module which contains the initialiser method.
+     * @param method The name of the method to call.
      */
-    addTypeInitialiser(type, typeConfig, initialiser) {
+    addTypeInitialiser(type, typeConfig, module, method) {
         if (!Is.empty(typeConfig)) {
             this._typeInitialisers.push({
                 type,
                 typeConfig,
-                initialiser: initialiser
+                module,
+                method
             });
         }
     }
     /**
      * Start the engine core.
-     * @returns Nothing.
+     * @returns True if the start was successful.
      */
     async start() {
+        if (this._isStarted) {
+            return false;
+        }
         this.setupEngineLogger();
         this.logInfo(I18n.formatMessage("engineCore.starting"));
         if (this._context.config.debug) {
             this.logInfo(I18n.formatMessage("engineCore.debuggingEnabled"));
         }
-        if (await this.stateLoad()) {
-            for (const { type, typeConfig, initialiser } of this._typeInitialisers) {
-                this.initialiseTypeConfig(type, typeConfig, initialiser);
-            }
-            const canContinue = await this.bootstrap();
+        let canContinue;
+        try {
+            canContinue = await this.stateLoad();
             if (canContinue) {
+                for (const { type, typeConfig, module, method } of this._typeInitialisers) {
+                    await this.initialiseTypeConfig(type, typeConfig, module, method);
+                }
+                await this.bootstrap();
                 this.logInfo(I18n.formatMessage("engineCore.componentsStarting"));
                 for (const instance of this._context.componentInstances) {
                     if (Is.function(instance.component.start)) {
-                        this.logInfo(I18n.formatMessage("engineCore.componentStarting", { element: instance.instanceType }));
-                        await instance.component.start(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                        const instanceName = this.getInstanceName(instance);
+                        this.logInfo(I18n.formatMessage("engineCore.componentStarting", {
+                            element: instance.instanceType
+                        }));
+                        const componentState = this._context.state.componentStates[instanceName] ?? {};
+                        const lastState = ObjectHelper.clone(componentState);
+                        await instance.component.start(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
+                        if (!ObjectHelper.equal(lastState, componentState)) {
+                            this._context.state.componentStates[instanceName] = componentState;
+                            this._context.stateDirty = true;
+                        }
                     }
                 }
                 this.logInfo(I18n.formatMessage("engineCore.componentsComplete"));
             }
+            this.logInfo(I18n.formatMessage("engineCore.started"));
+            this._isStarted = true;
+        }
+        catch (err) {
+            canContinue = false;
+            this.logError(BaseError.fromError(err));
+        }
+        finally {
+            if (!(await this.stateSave())) {
+                canContinue = false;
+            }
         }
-        this.logInfo(I18n.formatMessage("engineCore.started"));
+        return canContinue;
     }
     /**
      * Stop the engine core.
@@ -1298,9 +225,16 @@ class EngineCore {
         this.logInfo(I18n.formatMessage("engineCore.componentsStopping"));
         for (const instance of this._context.componentInstances) {
             if (Is.function(instance.component.stop)) {
+                const instanceName = this.getInstanceName(instance);
+                const componentState = this._context.state.componentStates[instanceName] ?? {};
+                const lastState = ObjectHelper.clone(componentState);
                 this.logInfo(I18n.formatMessage("engineCore.componentStopping", { element: instance.instanceType }));
                 try {
-                    await instance.component.stop(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                    await instance.component.stop(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
+                    if (!ObjectHelper.equal(lastState, componentState)) {
+                        this._context.state.componentStates[instanceName] = componentState;
+                        this._context.stateDirty = true;
+                    }
                 }
                 catch (err) {
                     this.logError(new GeneralError(this.CLASS_NAME, "componentStopFailed", {
@@ -1309,6 +243,7 @@ class EngineCore {
                 }
             }
         }
+        await this.stateSave();
         this.logInfo(I18n.formatMessage("engineCore.componentsStopped"));
         this.logInfo(I18n.formatMessage("engineCore.stopped"));
     }
@@ -1364,14 +299,63 @@ class EngineCore {
     getDefaultTypes() {
         return this._context.defaultTypes;
     }
+    /**
+     * Get the data required to create a clone of the engine.
+     * @returns The clone data.
+     */
+    getCloneData() {
+        const entitySchemas = {};
+        const entitySchemaNames = EntitySchemaFactory.names();
+        for (const schemaName of entitySchemaNames) {
+            entitySchemas[schemaName] = EntitySchemaFactory.get(schemaName);
+        }
+        const cloneData = {
+            config: this._context.config,
+            state: this._context.state,
+            typeInitialisers: this._typeInitialisers,
+            entitySchemas,
+            loggerTypeName: this._loggerTypeName
+        };
+        return cloneData;
+    }
+    /**
+     * Populate the engine from the clone data.
+     * @param cloneData The clone data to populate from.
+     * @param silent Should the clone be silent.
+     */
+    populateClone(cloneData, silent) {
+        Guards.object(this.CLASS_NAME, "cloneData", cloneData);
+        Guards.object(this.CLASS_NAME, "cloneData.config", cloneData.config);
+        Guards.object(this.CLASS_NAME, "cloneData.state", cloneData.state);
+        Guards.array(this.CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
+        this._loggerTypeName = cloneData.loggerTypeName;
+        this._skipBootstrap = true;
+        if (silent ?? false) {
+            cloneData.config.silent = true;
+        }
+        this._context = {
+            config: cloneData.config,
+            defaultTypes: {},
+            componentInstances: [],
+            state: { componentStates: {} },
+            stateDirty: false
+        };
+        this._typeInitialisers = cloneData.typeInitialisers;
+        for (const schemaName of Object.keys(cloneData.entitySchemas)) {
+            EntitySchemaFactory.register(schemaName, () => cloneData.entitySchemas[schemaName]);
+        }
+        this._stateStorage = new MemoryStateStorage(true, cloneData.state);
+        this._isStarted = false;
+    }
     /**
      * Initialise the types from connector.
      * @param typeKey The key for the default types.
      * @param instanceMethod The function to initialise the instance.
      * @internal
      */
-    initialiseTypeConfig(typeKey, typeConfig, instanceMethod) {
+    async initialiseTypeConfig(typeKey, typeConfig, module, method) {
         if (Is.arrayValue(typeConfig)) {
+            const instanceMethod = await ModuleHelper.getModuleEntry(module, method);
             for (let i = 0; i < typeConfig.length; i++) {
                 const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
                 if (Is.stringValue(instanceType) &&
@@ -1386,21 +370,22 @@ class EngineCore {
      * @internal
      */
     setupEngineLogger() {
-        if (!this._context.config.silent) {
-            const engineLogger = new ConsoleLoggingConnector({
+        const silent = this._context.config.silent ?? false;
+        const engineLogger = silent
+            ? new SilentLoggingConnector()
+            : new ConsoleLoggingConnector({
                 config: {
                     translateMessages: true,
                     hideGroups: true
                 }
             });
-            this._context.componentInstances.push({
-                instanceType: EngineCore.LOGGER_TYPE_NAME,
-                component: engineLogger
-            });
-            LoggingConnectorFactory.register(EngineCore.LOGGER_TYPE_NAME, () => engineLogger);
-            this._engineLoggingConnector = engineLogger;
-            this._context.defaultTypes.loggingConnector = EngineCore.LOGGER_TYPE_NAME;
-        }
+        this._context.componentInstances.push({
+            instanceType: this._loggerTypeName,
+            component: engineLogger
+        });
+        LoggingConnectorFactory.register(this._loggerTypeName, () => engineLogger);
+        this._engineLoggingConnector = engineLogger;
+        this._context.defaultTypes.loggingConnector = this._loggerTypeName;
     }
     /**
      * Load the state.
@@ -1411,9 +396,9 @@ class EngineCore {
         if (this._stateStorage) {
             try {
                 this._context.state = ((await this._stateStorage.load(this)) ?? {
-                    bootstrappedComponents: []
+                    componentStates: {}
                 });
-                this._context.state.bootstrappedComponents ??= [];
+                this._context.state.componentStates ??= {};
                 this._context.stateDirty = false;
                 return true;
             }
@@ -1426,6 +411,7 @@ class EngineCore {
     }
     /**
      * Save the state.
+     * @returns True if the state was saved.
      * @internal
      */
     async stateSave() {
@@ -1433,90 +419,61 @@ class EngineCore {
             try {
                 await this._stateStorage.save(this, this._context.state);
                 this._context.stateDirty = false;
+                return true;
             }
             catch (err) {
                 this.logError(BaseError.fromError(err));
             }
+            return false;
         }
+        return true;
     }
     /**
      * Bootstrap the engine.
-     * @returns True if the engine can continue.
      * @internal
      */
     async bootstrap() {
-        let canContinue = true;
         if (!this._skipBootstrap) {
             this.logInfo(I18n.formatMessage("engineCore.bootstrapStarted"));
-            try {
-                // First bootstrap the components.
-                for (const instance of this._context.componentInstances) {
-                    if (Is.function(instance.component.bootstrap)) {
-                        const bootstrapName = `${instance.component.CLASS_NAME}-${instance.instanceType}`;
-                        if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
-                            this.logInfo(I18n.formatMessage("engineCore.bootstrapping", {
-                                element: bootstrapName
-                            }));
-                            const bootstrapSuccess = await instance.component.bootstrap(EngineCore.LOGGER_TYPE_NAME);
-                            // If the bootstrap method failed then throw an error
-                            if (!bootstrapSuccess) {
-                                throw new GeneralError(this.CLASS_NAME, "bootstrapFailed", {
-                                    component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
-                                });
-                            }
-                            // Otherwise add the component to the bootstrapped list and set the state as dirty
-                            this._context.state.bootstrappedComponents.push(bootstrapName);
-                            this._context.stateDirty = true;
-                        }
+            // First bootstrap the components.
+            for (const instance of this._context.componentInstances) {
+                if (Is.function(instance.component.bootstrap)) {
+                    const instanceName = this.getInstanceName(instance);
+                    this.logInfo(I18n.formatMessage("engineCore.bootstrapping", {
+                        element: instanceName
+                    }));
+                    const componentState = this._context.state.componentStates[instanceName] ?? {};
+                    const lastState = ObjectHelper.clone(componentState);
+                    const bootstrapSuccess = await instance.component.bootstrap(this._loggerTypeName, componentState);
+                    // If the bootstrap method failed then throw an error
+                    if (!bootstrapSuccess) {
+                        throw new GeneralError(this.CLASS_NAME, "bootstrapFailed", {
+                            component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
+                        });
+                    }
+                    if (!ObjectHelper.equal(lastState, componentState)) {
+                        this._context.state.componentStates[instanceName] = componentState;
+                        this._context.stateDirty = true;
                     }
                 }
-                // Now perform any custom bootstrap operations
-                if (canContinue && Is.function(this._customBootstrap)) {
-                    await this._customBootstrap(this, this._context);
-                }
-            }
-            catch (err) {
-                canContinue = false;
-                this.logError(BaseError.fromError(err));
             }
-            finally {
-                await this.stateSave();
-                if (canContinue) {
-                    this.logInfo(I18n.formatMessage("engineCore.bootstrapComplete"));
-                }
+            // Now perform any custom bootstrap operations
+            if (Is.function(this._customBootstrap)) {
+                await this._customBootstrap(this, this._context);
             }
+            this.logInfo(I18n.formatMessage("engineCore.bootstrapComplete"));
         }
-        return canContinue;
     }
     /**
-     * Add the core type initializers.
+     * Get the instance name.
+     * @param instance The instance to get the name for.
+     * @param instance.instanceType The instance type.
+     * @param instance.component The component.
+     * @returns The instance name.
      * @internal
      */
-    addCoreTypeInitialisers() {
-        this.addTypeInitialiser("loggingConnector", this._context.config.loggingConnector, initialiseLoggingConnector);
-        this.addTypeInitialiser("loggingComponent", this._context.config.loggingComponent, initialiseLoggingComponent);
-        this.addTypeInitialiser("backgroundTaskConnector", this._context.config.backgroundTaskConnector, initialiseBackgroundTaskConnector);
-        this.addTypeInitialiser("telemetryConnector", this._context.config.telemetryConnector, initialiseTelemetryConnector);
-        this.addTypeInitialiser("telemetryComponent", this._context.config.telemetryComponent, initialiseTelemetryComponent);
-        this.addTypeInitialiser("entityStorageComponent", this._context.config.entityStorageComponent, initialiseEntityStorageComponent);
-        this.addTypeInitialiser("vaultConnector", this._context.config.vaultConnector, initialiseVaultConnector);
-        this.addTypeInitialiser("blobStorageConnector", this._context.config.blobStorageConnector, initialiseBlobStorageConnector);
-        this.addTypeInitialiser("blobStorageComponent", this._context.config.blobStorageComponent, initialiseBlobStorageComponent);
-        this.addTypeInitialiser("immutableStorageConnector", this._context.config.immutableStorageConnector, initialiseImmutableStorageConnector);
-        this.addTypeInitialiser("walletConnector", this._context.config.walletConnector, initialiseWalletStorage);
-        this.addTypeInitialiser("faucetConnector", this._context.config.faucetConnector, initialiseFaucetConnector);
-        this.addTypeInitialiser("walletConnector", this._context.config.walletConnector, initialiseWalletConnector);
-        this.addTypeInitialiser("identityConnector", this._context.config.identityConnector, initialiseIdentityConnector);
-        this.addTypeInitialiser("identityComponent", this._context.config.identityComponent, initialiseIdentityComponent);
-        this.addTypeInitialiser("identityProfileConnector", this._context.config.identityProfileConnector, initialiseIdentityProfileConnector);
-        this.addTypeInitialiser("identityProfileComponent", this._context.config.identityProfileComponent, initialiseIdentityProfileComponent);
-        this.addTypeInitialiser("nftConnector", this._context.config.nftConnector, initialiseNftConnector);
-        this.addTypeInitialiser("nftComponent", this._context.config.nftComponent, initialiseNftComponent);
-        this.addTypeInitialiser("immutableProofComponent", this._context.config.immutableProofComponent, initialiseImmutableProofComponent);
-        this.addTypeInitialiser("attestationConnector", this._context.config.attestationConnector, initialiseAttestationConnector);
-        this.addTypeInitialiser("attestationComponent", this._context.config.attestationComponent, initialiseAttestationComponent);
-        this.addTypeInitialiser("auditableItemGraphComponent", this._context.config.auditableItemGraphComponent, initialiseAuditableItemGraphComponent);
-        this.addTypeInitialiser("auditableItemStreamComponent", this._context.config.auditableItemStreamComponent, initialiseAuditableItemStreamComponent);
+    getInstanceName(instance) {
+        return `${instance.component.CLASS_NAME}-${instance.instanceType}`;
     }
 }
 
@@ -1581,6 +538,10 @@ class FileStateStorage {
                 engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
                     filename: this._filename
                 }));
+                try {
+                    await mkdir(path.dirname(this._filename), { recursive: true });
+                }
+                catch { }
                 await writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
             }
             catch (err) {
@@ -1605,581 +566,4 @@ class FileStateStorage {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in memory.
- */
-class MemoryStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "MemoryStateStorage";
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * The state object.
-     * @internal
-     */
-    _engineState;
-    /**
-     * Create a new instance of MemoryStateStorage.
-     * @param readonlyMode Whether the file is in read-only mode.
-     */
-    constructor(readonlyMode = false) {
-        this._readonlyMode = readonlyMode;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-            filename: this._engineState
-        }));
-        return this._engineState;
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`));
-            this._engineState = state;
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Build the engine core configuration from environment variables.
- * @param envVars The environment variables.
- * @returns The config for the core.
- */
-function buildEngineCoreConfiguration(envVars) {
-    envVars.stateFilename ??= "engine-state.json";
-    envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
-    envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
-    envVars.attestationAssertionMethodId ??= "attestation-assertion";
-    envVars.immutableProofHashKeyId ??= "immutable-proof-hash";
-    envVars.immutableProofAssertionMethodId ??= "immutable-proof-assertion";
-    envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
-    const coreConfig = {
-        debug: Coerce.boolean(envVars.debug) ?? false,
-        loggingConnector: [],
-        loggingComponent: [{ type: LoggingComponentType.Service }],
-        entityStorageConnector: [],
-        blobStorageConnector: [],
-        blobStorageComponent: [
-            {
-                type: BlobStorageComponentType.Service,
-                options: {
-                    config: {
-                        vaultKeyId: envVars.blobStorageEncryptionKey
-                    }
-                }
-            }
-        ],
-        backgroundTaskConnector: [],
-        telemetryConnector: [],
-        telemetryComponent: [{ type: TelemetryComponentType.Service }],
-        vaultConnector: [],
-        walletConnector: [],
-        faucetConnector: [],
-        immutableStorageConnector: [],
-        nftConnector: [],
-        nftComponent: [{ type: NftComponentType.Service }],
-        identityConnector: [],
-        identityComponent: [{ type: IdentityComponentType.Service }],
-        identityProfileConnector: [],
-        identityProfileComponent: [{ type: IdentityProfileComponentType.Service }],
-        immutableProofComponent: [
-            {
-                type: ImmutableProofComponentType.Service,
-                options: {
-                    config: {
-                        assertionMethodId: envVars.immutableProofAssertionMethodId,
-                        proofHashKeyId: envVars.immutableProofHashKeyId
-                    }
-                }
-            }
-        ],
-        attestationConnector: [],
-        attestationComponent: [
-            {
-                type: AttestationComponentType.Service
-            }
-        ],
-        auditableItemGraphComponent: [{ type: AuditableItemGraphComponentType.Service }],
-        auditableItemStreamComponent: [{ type: AuditableItemStreamComponentType.Service }]
-    };
-    configureEntityStorageConnectors(coreConfig, envVars);
-    configureBlobStorageConnectors(coreConfig, envVars);
-    configureVaultConnectors(coreConfig, envVars);
-    configureLogging(coreConfig, envVars);
-    configureBackgroundTaskConnectors(coreConfig, envVars);
-    configureTelemetryConnectors(coreConfig, envVars);
-    configureFaucetConnectors(coreConfig, envVars);
-    configureWalletConnectors(coreConfig, envVars);
-    configureNftConnectors(coreConfig, envVars);
-    configureImmutableStorageConnectors(coreConfig, envVars);
-    configureIdentityConnectors(coreConfig, envVars);
-    configureIdentityProfileConnectors(coreConfig, envVars);
-    configureAttestationConnectors(coreConfig, envVars);
-    return coreConfig;
-}
-/**
- * Configures the entity storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureEntityStorageConnectors(coreConfig, envVars) {
-    coreConfig.entityStorageConnector ??= [];
-    if ((Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === EntityStorageConnectorType.Memory) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.Memory
-        });
-    }
-    if ((Coerce.boolean(envVars.entityFileEnable) ?? false) ||
-        envVars.entityStorageConnectorType === EntityStorageConnectorType.File) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.File,
-            options: { config: { directory: envVars.storageFileRoot } }
-        });
-    }
-    if (Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.AwsDynamoDb,
-            options: {
-                config: {
-                    region: envVars.awsDynamodbRegion,
-                    accessKeyId: envVars.awsDynamodbAccessKeyId,
-                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                    endpoint: envVars.awsDynamodbEndpoint
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.azureCosmosdbKey)) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.AzureCosmosDb,
-            options: {
-                config: {
-                    endpoint: envVars.azureCosmosdbEndpoint,
-                    key: envVars.azureCosmosdbKey,
-                    databaseId: envVars.azureCosmosdbDatabaseId,
-                    containerId: envVars.azureCosmosdbContainerId
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.gcpFirestoreCredentials)) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.GcpFirestoreDb,
-            options: {
-                config: {
-                    projectId: envVars.gcpFirestoreProjectId,
-                    credentials: envVars.gcpFirestoreCredentials,
-                    databaseId: envVars.gcpFirestoreDatabaseId,
-                    collectionName: envVars.gcpFirestoreCollectionName,
-                    endpoint: envVars.gcpFirestoreApiEndpoint
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.scylladbHosts)) {
-        coreConfig.entityStorageConnector.push({
-            type: EntityStorageConnectorType.ScyllaDb,
-            options: {
-                config: {
-                    hosts: envVars.scylladbHosts.split(","),
-                    localDataCenter: envVars.scylladbLocalDataCenter,
-                    keyspace: envVars.scylladbKeyspace
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    const defaultStorageConnector = envVars.entityStorageConnectorType;
-    if (Is.stringValue(defaultStorageConnector)) {
-        for (const config of coreConfig.entityStorageConnector) {
-            if (config.type === defaultStorageConnector) {
-                config.isDefault = true;
-            }
-        }
-    }
-}
-/**
- * Configures the blob storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureBlobStorageConnectors(coreConfig, envVars) {
-    coreConfig.blobStorageConnector ??= [];
-    if ((Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === BlobStorageConnectorType.Memory) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.Memory
-        });
-    }
-    if ((Coerce.boolean(envVars.blobFileEnable) ?? false) ||
-        envVars.blobStorageConnectorType === BlobStorageConnectorType.File) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.File,
-            options: {
-                config: { directory: envVars.storageFileRoot },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.ipfsApiUrl)) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.Ipfs,
-            options: {
-                config: {
-                    apiUrl: envVars.ipfsApiUrl,
-                    bearerToken: envVars.ipfsBearerToken
-                }
-            }
-        });
-    }
-    if (Is.stringValue(envVars.awsS3AccessKeyId)) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.AwsS3,
-            options: {
-                config: {
-                    region: envVars.awsS3Region,
-                    bucketName: envVars.awsS3BucketName,
-                    accessKeyId: envVars.awsS3AccessKeyId,
-                    secretAccessKey: envVars.awsS3SecretAccessKey,
-                    endpoint: envVars.awsS3Endpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.azureStorageAccountKey)) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.AzureStorage,
-            options: {
-                config: {
-                    accountName: envVars.azureStorageAccountName,
-                    accountKey: envVars.azureStorageAccountKey,
-                    containerName: envVars.azureStorageContainerName,
-                    endpoint: envVars.azureStorageEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.gcpStorageCredentials)) {
-        coreConfig.blobStorageConnector.push({
-            type: BlobStorageConnectorType.GcpStorage,
-            options: {
-                config: {
-                    projectId: envVars.gcpStorageProjectId,
-                    credentials: envVars.gcpStorageCredentials,
-                    bucketName: envVars.gcpStorageBucketName,
-                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
-    if (Is.stringValue(defaultStorageConnectorType)) {
-        for (const config of coreConfig.blobStorageConnector) {
-            if (config.type === defaultStorageConnectorType) {
-                config.isDefault = true;
-            }
-        }
-    }
-}
-/**
- * Configures the logging connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureLogging(coreConfig, envVars) {
-    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
-    for (const loggingConnector of loggingConnectors) {
-        if (loggingConnector === LoggingConnectorType.Console) {
-            coreConfig.loggingConnector?.push({
-                type: LoggingConnectorType.Console,
-                options: {
-                    config: {
-                        translateMessages: true,
-                        hideGroups: true
-                    }
-                }
-            });
-        }
-        else if (loggingConnector === LoggingConnectorType.EntityStorage) {
-            coreConfig.loggingConnector?.push({
-                type: LoggingConnectorType.EntityStorage
-            });
-        }
-    }
-    if (loggingConnectors.length > 1) {
-        coreConfig.loggingConnector?.push({
-            type: LoggingConnectorType.Multi,
-            isDefault: true,
-            options: {
-                loggingConnectorTypes: loggingConnectors
-            }
-        });
-    }
-}
-/**
- * Configures the vault connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureVaultConnectors(coreConfig, envVars) {
-    coreConfig.vaultConnector ??= [];
-    if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
-        coreConfig.vaultConnector.push({
-            type: VaultConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
-        coreConfig.vaultConnector.push({
-            type: VaultConnectorType.Hashicorp,
-            options: {
-                config: { endpoint: envVars.hashicorpVaultEndpoint, token: envVars.hashicorpVaultToken }
-            }
-        });
-    }
-}
-/**
- * Configures the background task connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureBackgroundTaskConnectors(coreConfig, envVars) {
-    coreConfig.backgroundTaskConnector ??= [];
-    if (envVars.backgroundTaskConnector === BackgroundTaskConnectorType.EntityStorage) {
-        coreConfig.backgroundTaskConnector.push({
-            type: BackgroundTaskConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the telemetry connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureTelemetryConnectors(coreConfig, envVars) {
-    coreConfig.telemetryConnector ??= [];
-    if (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage) {
-        coreConfig.telemetryConnector.push({
-            type: TelemetryConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the faucet connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureFaucetConnectors(coreConfig, envVars) {
-    coreConfig.faucetConnector ??= [];
-    if (envVars.faucetConnector === FaucetConnectorType.EntityStorage) {
-        coreConfig.faucetConnector.push({
-            type: FaucetConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.faucetConnector === FaucetConnectorType.Iota) {
-        coreConfig.faucetConnector.push({
-            type: FaucetConnectorType.Iota,
-            options: {
-                config: {
-                    endpoint: envVars.iotaFaucetEndpoint,
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the wallet connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureWalletConnectors(coreConfig, envVars) {
-    coreConfig.walletConnector ??= [];
-    if (envVars.walletConnector === WalletConnectorType.EntityStorage) {
-        coreConfig.walletConnector.push({
-            type: WalletConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.walletConnector === WalletConnectorType.Iota) {
-        coreConfig.walletConnector.push({
-            type: WalletConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the NFT connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureNftConnectors(coreConfig, envVars) {
-    coreConfig.nftConnector ??= [];
-    if (envVars.nftConnector === NftConnectorType.EntityStorage) {
-        coreConfig.nftConnector.push({
-            type: NftConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.nftConnector === NftConnectorType.Iota) {
-        coreConfig.nftConnector.push({
-            type: NftConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the immutable storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureImmutableStorageConnectors(coreConfig, envVars) {
-    coreConfig.immutableStorageConnector ??= [];
-    if (envVars.immutableStorageConnector === ImmutableStorageConnectorType.EntityStorage) {
-        coreConfig.immutableStorageConnector.push({
-            type: ImmutableStorageConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.immutableStorageConnector === ImmutableStorageConnectorType.Iota) {
-        coreConfig.immutableStorageConnector.push({
-            type: ImmutableStorageConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the identity connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureIdentityConnectors(coreConfig, envVars) {
-    coreConfig.identityConnector ??= [];
-    if (envVars.identityConnector === IdentityConnectorType.EntityStorage) {
-        coreConfig.identityConnector.push({
-            type: IdentityConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.identityConnector === IdentityConnectorType.Iota) {
-        coreConfig.identityConnector.push({
-            type: IdentityConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the identity profile connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureIdentityProfileConnectors(coreConfig, envVars) {
-    coreConfig.identityProfileConnector ??= [];
-    if (envVars.identityProfileConnector === IdentityConnectorType.EntityStorage) {
-        coreConfig.identityProfileConnector.push({
-            type: IdentityProfileConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the attestation connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureAttestationConnectors(coreConfig, envVars) {
-    coreConfig.attestationConnector ??= [];
-    if (envVars.attestationConnector === AttestationConnectorType.EntityStorage) {
-        coreConfig.attestationConnector.push({
-            type: AttestationConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.attestationConnector === AttestationConnectorType.Iota) {
-        coreConfig.attestationConnector.push({
-            type: AttestationConnectorType.Iota
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Environment variable helper.
- */
-class EnvHelper {
-    /**
-     * Get the environment variable as an object with camel cased names.
-     * @param envVars The environment variables.
-     * @param prefix The prefix of the environment variables.
-     * @returns The object with camel cased names.
-     */
-    static envToJson(envVars, prefix) {
-        const result = {};
-        for (const envVar in envVars) {
-            if (envVar.startsWith(prefix) && Is.stringValue(process.env[envVar])) {
-                const camelCaseName = StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
-                ObjectHelper.propertySet(result, camelCaseName, process.env[envVar]);
-            }
-        }
-        return result;
-    }
-}
-
-export { EngineCore, EnvHelper, FileStateStorage, MemoryStateStorage, buildEngineCoreConfiguration, initialiseEntityStorageConnector };
+export { EngineCore, FileStateStorage, MemoryStateStorage };