@twin.org/node-core 0.9.4 → 0.9.5-next.2

package/dist/es/builders/engineEnvBuilder.js

@@ -1,15 +1,17 @@
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+import { cpus } from "node:os";
 import path from "node:path";
 import { Is, Mutex } from "@twin.org/core";
 import { EngineCloneMode } from "@twin.org/engine-models";
-import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AutomationComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataProcessingComponentType, DataspaceControlPlaneComponentType, DataspaceDataPlaneComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, HealthComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, MetricsCollectorComponentType, MetricsProducerComponentType, NftComponentType, NftConnectorType, NotarizationComponentType, NotarizationConnectorType, PlatformComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SchemaVersionMigrationComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TracingComponentType, TracingConnectorType, TrustComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
+import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AutomationActionType, AutomationComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DataspaceControlPlaneComponentType, DataspaceDataPlaneComponentType, DltConfigType, DocumentManagementComponentType, EmailProtocolConnectorType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FacadeType, FaucetConnectorType, FederatedCatalogueComponentType, FederatedCatalogueFilterComponentType, HealthComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MailboxComponentType, MailStorageComponentType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, MetricsCollectorComponentType, MetricsProducerComponentType, NftComponentType, NftConnectorType, NotarizationComponentType, NotarizationConnectorType, PlatformComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPolicyArbiterComponentType, RightsManagementPolicyEnforcementProcessorComponentType, RightsManagementPolicyExecutionActionComponentType, RightsManagementPolicyInformationSourceComponentType, RightsManagementPolicyNegotiatorComponentType, RightsManagementPolicyObligationEnforcerComponentType, RightsManagementPolicyRequesterComponentType, RightsManagementPxpComponentType, SchemaVersionMigrationComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TracingComponentType, TracingConnectorType, TrustComponentType, TrustGeneratorComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
 import { OpenTelemetryExporterTypes } from "@twin.org/logging-connector-opentelemetry";
 import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentelemetry";
 import { OpenTelemetryProcessorTypes } from "@twin.org/tracing-connector-opentelemetry";
-import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
+import { TracingFacade } from "@twin.org/tracing-facades";
+import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT, COMPONENT_FACTORY_TYPE_NAME, DEFAULT_HEALTH_EXCLUDE_CLONE_COMPONENTS, DEFAULT_TRACING_FACADE_COMPONENT_EXCLUDE_TYPES, DEFAULT_TRACING_FACADE_FACTORIES, TRACING_FACADE_NAME } from "../defaults.js";
 import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
-import { commaSeparatedListToArray, envArray, envBoolean, envCount, envDateTime, envInteger, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
+import { commaSeparatedListToArray, envArray, envBoolean, envChoice, envCount, envDateTime, envInteger, envListToArray, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
@@ -32,7 +34,7 @@ export async function buildEngineConfiguration(envVars) {
         types: {}
     };
     const mutexTimeoutMs = envMs(envVars, "mutexTimeoutDefault");
-    if (!Is.empty(mutexTimeoutMs)) {
+    if (Is.notEmpty(mutexTimeoutMs)) {
         Mutex.setDefaultTimeoutMs(mutexTimeoutMs);
     }
     await configureSchemaMigration(coreConfig, envVars);
@@ -50,7 +52,9 @@ export async function buildEngineConfiguration(envVars) {
     await configureTelemetry(coreConfig, envVars);
     await configureMetricsCollector(coreConfig, envVars);
     await configureTracing(coreConfig, envVars);
+    await configureFacades(coreConfig, envVars);
     await configureMessaging(coreConfig, envVars);
+    await configureMailbox(coreConfig, envVars);
     await configureAutomation(coreConfig, envVars);
     await configureHealth(coreConfig, envVars);
     await configureFaucet(coreConfig, envVars);
@@ -81,163 +85,165 @@ export async function buildEngineConfiguration(envVars) {
 async function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
-    const entityStorageConnectorTypes = commaSeparatedListToArray(envVars.entityStorageConnectorType);
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Memory)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.Memory,
-            options: {
-                config: {
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                }
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.File)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.File,
-            options: {
-                config: {
-                    directory: envVars.storageFileRoot ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                },
-                folderPrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AwsDynamoDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.AwsDynamoDb,
-            options: {
-                config: {
-                    region: envVars.awsDynamodbRegion ?? "",
-                    authMode: envVars.awsDynamodbAuthMode,
-                    accessKeyId: envVars.awsDynamodbAccessKeyId,
-                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                    endpoint: envVars.awsDynamodbEndpoint,
-                    connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout"),
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AzureCosmosDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.AzureCosmosDb,
-            options: {
-                config: {
-                    endpoint: envVars.azureCosmosdbEndpoint ?? "",
-                    key: envVars.azureCosmosdbKey ?? "",
-                    databaseId: envVars.azureCosmosdbDatabaseId ?? "",
-                    containerId: envVars.azureCosmosdbContainerId ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.GcpFirestoreDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.GcpFirestoreDb,
-            options: {
-                config: {
-                    projectId: envVars.gcpFirestoreProjectId ?? "",
-                    credentials: envVars.gcpFirestoreCredentials ?? "",
-                    databaseId: envVars.gcpFirestoreDatabaseId ?? "",
-                    collectionName: envVars.gcpFirestoreCollectionName ?? "",
-                    endpoint: envVars.gcpFirestoreEndpoint ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.ScyllaDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.ScyllaDb,
-            options: {
-                config: {
-                    hosts: commaSeparatedListToArray(envVars.scylladbHosts),
-                    localDataCenter: envVars.scylladbLocalDataCenter ?? "",
-                    keyspace: envVars.scylladbKeyspace ?? "",
-                    port: envInteger(envVars, "scylladbPort"),
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                    pool: {
-                        coreConnectionsPerHost: envCount(envVars, "scylladbPoolCoreConnectionsPerHost"),
-                        maxRequestsPerConnection: envCount(envVars, "scylladbPoolMaxRequestsPerConnection")
-                    }
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MySqlDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.MySqlDb,
-            options: {
-                config: {
-                    host: envVars.mySqlHost ?? "",
-                    port: envInteger(envVars, "mySqlPort"),
-                    user: envVars.mySqlUser ?? "",
-                    password: envVars.mySqlPassword ?? "",
-                    database: envVars.mySqlDatabase ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                    pool: {
-                        connectionLimit: envCount(envVars, "mySqlPoolConnectionLimit"),
-                        maxIdle: envCount(envVars, "mySqlPoolMaxIdle"),
-                        idleTimeout: envMs(envVars, "mySqlPoolIdleTimeout"),
-                        enableKeepAlive: envBoolean(envVars, "mySqlPoolEnableKeepAlive"),
-                        waitForConnections: envBoolean(envVars, "mySqlPoolWaitForConnections"),
-                        queueLimit: envCount(envVars, "mySqlPoolQueueLimit")
-                    }
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MongoDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.MongoDb,
-            options: {
-                config: {
-                    host: envVars.mongoDbHost ?? "",
-                    port: envInteger(envVars, "mongoDbPort"),
-                    user: envVars.mongoDbUser ?? "",
-                    password: envVars.mongoDbPassword ?? "",
-                    database: envVars.mongoDbDatabase ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                    pool: {
-                        maxPoolSize: envCount(envVars, "mongoDbPoolMaxPoolSize"),
-                        minPoolSize: envCount(envVars, "mongoDbPoolMinPoolSize"),
-                        maxIdleTimeMs: envMs(envVars, "mongoDbPoolMaxIdleTime"),
-                        waitQueueTimeoutMs: envMs(envVars, "mongoDbPoolWaitQueueTimeout")
-                    }
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.PostgreSql)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.PostgreSql,
-            options: {
-                config: {
-                    host: envVars.postgreSqlHost ?? "",
-                    port: envInteger(envVars, "postgreSqlPort"),
-                    user: envVars.postgreSqlUser ?? "",
-                    password: envVars.postgreSqlPassword ?? "",
-                    database: envVars.postgreSqlDatabase ?? "",
-                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                    pool: {
-                        max: envCount(envVars, "postgreSqlPoolMax"),
-                        idleTimeout: envSeconds(envVars, "postgreSqlPoolIdleTimeout"),
-                        connectTimeout: envSeconds(envVars, "postgreSqlPoolConnectTimeout"),
-                        maxLifetime: envSeconds(envVars, "postgreSqlPoolMaxLifetime")
+    const entityStorageConnectorTypes = envListToArray(envVars, "entityStorageConnectorType", Object.values(EntityStorageConnectorType));
+    for (const entityStorageConnectorType of entityStorageConnectorTypes) {
+        if (entityStorageConnectorType === EntityStorageConnectorType.Memory) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.Memory,
+                options: {
+                    config: {
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                     }
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.File) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.File,
+                options: {
+                    config: {
+                        directory: envVars.storageFileRoot ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                    },
+                    folderPrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.AwsDynamoDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.AwsDynamoDb,
+                options: {
+                    config: {
+                        region: envVars.awsDynamodbRegion ?? "",
+                        authMode: envVars.awsDynamodbAuthMode,
+                        accessKeyId: envVars.awsDynamodbAccessKeyId,
+                        secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                        endpoint: envVars.awsDynamodbEndpoint,
+                        connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout"),
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.AzureCosmosDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.AzureCosmosDb,
+                options: {
+                    config: {
+                        endpoint: envVars.azureCosmosdbEndpoint ?? "",
+                        key: envVars.azureCosmosdbKey ?? "",
+                        databaseId: envVars.azureCosmosdbDatabaseId ?? "",
+                        containerId: envVars.azureCosmosdbContainerId ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.GcpFirestoreDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.GcpFirestoreDb,
+                options: {
+                    config: {
+                        projectId: envVars.gcpFirestoreProjectId ?? "",
+                        credentials: envVars.gcpFirestoreCredentials ?? "",
+                        databaseId: envVars.gcpFirestoreDatabaseId ?? "",
+                        collectionName: envVars.gcpFirestoreCollectionName ?? "",
+                        endpoint: envVars.gcpFirestoreEndpoint ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.ScyllaDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.ScyllaDb,
+                options: {
+                    config: {
+                        hosts: commaSeparatedListToArray(envVars.scylladbHosts),
+                        localDataCenter: envVars.scylladbLocalDataCenter ?? "",
+                        keyspace: envVars.scylladbKeyspace ?? "",
+                        port: envInteger(envVars, "scylladbPort"),
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                        pool: {
+                            coreConnectionsPerHost: envCount(envVars, "scylladbPoolCoreConnectionsPerHost"),
+                            maxRequestsPerConnection: envCount(envVars, "scylladbPoolMaxRequestsPerConnection")
+                        }
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.MySqlDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.MySqlDb,
+                options: {
+                    config: {
+                        host: envVars.mySqlHost ?? "",
+                        port: envInteger(envVars, "mySqlPort"),
+                        user: envVars.mySqlUser ?? "",
+                        password: envVars.mySqlPassword ?? "",
+                        database: envVars.mySqlDatabase ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                        pool: {
+                            connectionLimit: envCount(envVars, "mySqlPoolConnectionLimit"),
+                            maxIdle: envCount(envVars, "mySqlPoolMaxIdle"),
+                            idleTimeout: envMs(envVars, "mySqlPoolIdleTimeout"),
+                            enableKeepAlive: envBoolean(envVars, "mySqlPoolEnableKeepAlive"),
+                            waitForConnections: envBoolean(envVars, "mySqlPoolWaitForConnections"),
+                            queueLimit: envCount(envVars, "mySqlPoolQueueLimit")
+                        }
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.MongoDb) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.MongoDb,
+                options: {
+                    config: {
+                        host: envVars.mongoDbHost ?? "",
+                        port: envInteger(envVars, "mongoDbPort"),
+                        user: envVars.mongoDbUser ?? "",
+                        password: envVars.mongoDbPassword ?? "",
+                        database: envVars.mongoDbDatabase ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                        pool: {
+                            maxPoolSize: envCount(envVars, "mongoDbPoolMaxPoolSize"),
+                            minPoolSize: envCount(envVars, "mongoDbPoolMinPoolSize"),
+                            maxIdleTimeMs: envMs(envVars, "mongoDbPoolMaxIdleTime"),
+                            waitQueueTimeoutMs: envMs(envVars, "mongoDbPoolWaitQueueTimeout")
+                        }
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
+        else if (entityStorageConnectorType === EntityStorageConnectorType.PostgreSql) {
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.PostgreSql,
+                options: {
+                    config: {
+                        host: envVars.postgreSqlHost ?? "",
+                        port: envInteger(envVars, "postgreSqlPort"),
+                        user: envVars.postgreSqlUser ?? "",
+                        password: envVars.postgreSqlPassword ?? "",
+                        database: envVars.postgreSqlDatabase ?? "",
+                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                        pool: {
+                            max: envCount(envVars, "postgreSqlPoolMax"),
+                            idleTimeout: envSeconds(envVars, "postgreSqlPoolIdleTimeout"),
+                            connectTimeout: envSeconds(envVars, "postgreSqlPoolConnectTimeout"),
+                            maxLifetime: envSeconds(envVars, "postgreSqlPoolMaxLifetime")
+                        }
+                    },
+                    tablePrefix: envVars.entityStorageTablePrefix
+                }
+            });
+        }
     }
     const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
     if (Is.arrayValue(entityStorageConnectorTypes)) {
@@ -257,85 +263,88 @@ async function configureEntityStorage(coreConfig, envVars) {
  */
 async function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
-    const blobStorageConnectorTypes = commaSeparatedListToArray(envVars.blobStorageConnectorType);
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Memory)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.Memory
-        });
-    }
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.File)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.File,
-            options: {
-                config: {
-                    directory: Is.stringValue(envVars.storageFileRoot)
-                        ? path.join(envVars.storageFileRoot, "blob-storage")
-                        : ""
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Ipfs)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.Ipfs,
-            options: {
-                config: {
-                    apiUrl: envVars.ipfsApiUrl ?? "",
-                    bearerToken: envVars.ipfsBearerToken
+    const blobStorageConnectorTypes = envListToArray(envVars, "blobStorageConnectorType", Object.values(BlobStorageConnectorType));
+    for (const blobStorageConnectorType of blobStorageConnectorTypes) {
+        if (blobStorageConnectorType === BlobStorageConnectorType.Memory) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.Memory
+            });
+        }
+        else if (blobStorageConnectorType === BlobStorageConnectorType.File) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.File,
+                options: {
+                    config: {
+                        directory: Is.stringValue(envVars.storageFileRoot)
+                            ? path.join(envVars.storageFileRoot, "blob-storage")
+                            : ""
+                    },
+                    storagePrefix: envVars.blobStoragePrefix
                 }
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AwsS3)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.AwsS3,
-            options: {
-                config: {
-                    region: envVars.awsS3Region ?? "",
-                    bucketName: envVars.awsS3BucketName ?? "",
-                    authMode: envVars.awsS3AuthMode,
-                    accessKeyId: envVars.awsS3AccessKeyId,
-                    secretAccessKey: envVars.awsS3SecretAccessKey,
-                    endpoint: envVars.awsS3Endpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AzureStorage)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.AzureStorage,
-            options: {
-                config: {
-                    accountName: envVars.azureStorageAccountName ?? "",
-                    accountKey: envVars.azureStorageAccountKey ?? "",
-                    containerName: envVars.azureStorageContainerName ?? "",
-                    endpoint: envVars.azureStorageEndpoint ?? ""
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.GcpStorage)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: BlobStorageConnectorType.GcpStorage,
-            options: {
-                config: {
-                    projectId: envVars.gcpStorageProjectId ?? "",
-                    credentials: envVars.gcpStorageCredentials ?? "",
-                    bucketName: envVars.gcpStorageBucketName ?? "",
-                    apiEndpoint: envVars.gcpFirestoreEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
+            });
+        }
+        else if (blobStorageConnectorType === BlobStorageConnectorType.Ipfs) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.Ipfs,
+                options: {
+                    config: {
+                        apiUrl: envVars.ipfsApiUrl ?? "",
+                        bearerToken: envVars.ipfsBearerToken
+                    }
+                }
+            });
+        }
+        else if (blobStorageConnectorType === BlobStorageConnectorType.AwsS3) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.AwsS3,
+                options: {
+                    config: {
+                        region: envVars.awsS3Region ?? "",
+                        bucketName: envVars.awsS3BucketName ?? "",
+                        authMode: envVars.awsS3AuthMode,
+                        accessKeyId: envVars.awsS3AccessKeyId,
+                        secretAccessKey: envVars.awsS3SecretAccessKey,
+                        endpoint: envVars.awsS3Endpoint
+                    },
+                    storagePrefix: envVars.blobStoragePrefix
+                }
+            });
+        }
+        else if (blobStorageConnectorType === BlobStorageConnectorType.AzureStorage) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.AzureStorage,
+                options: {
+                    config: {
+                        accountName: envVars.azureStorageAccountName ?? "",
+                        accountKey: envVars.azureStorageAccountKey ?? "",
+                        containerName: envVars.azureStorageContainerName ?? "",
+                        endpoint: envVars.azureStorageEndpoint ?? ""
+                    },
+                    storagePrefix: envVars.blobStoragePrefix
+                }
+            });
+        }
+        else if (blobStorageConnectorType === BlobStorageConnectorType.GcpStorage) {
+            coreConfig.types.blobStorageConnector.push({
+                type: BlobStorageConnectorType.GcpStorage,
+                options: {
+                    config: {
+                        projectId: envVars.gcpStorageProjectId ?? "",
+                        credentials: envVars.gcpStorageCredentials ?? "",
+                        bucketName: envVars.gcpStorageBucketName ?? "",
+                        apiEndpoint: envVars.gcpFirestoreEndpoint
+                    },
+                    storagePrefix: envVars.blobStoragePrefix
+                }
+            });
+        }
     }
     if (Is.arrayValue(blobStorageConnectorTypes)) {
         const defaultStorageConnectorType = envVars.blobStorageConnectorDefault ?? blobStorageConnectorTypes[0];
         for (const config of coreConfig.types.blobStorageConnector) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
+                break;
             }
         }
     }
@@ -361,7 +370,7 @@ async function configureBlobStorage(coreConfig, envVars) {
  */
 async function configureLogging(coreConfig, envVars) {
     coreConfig.types.loggingConnector ??= [];
-    const loggingConnectorTypes = commaSeparatedListToArray(envVars.loggingConnector);
+    const loggingConnectorTypes = envListToArray(envVars, "loggingConnector", Object.values(LoggingConnectorType));
     let additionalConnectorCount = 0;
     for (const loggingConnector of loggingConnectorTypes) {
         if (loggingConnector === LoggingConnectorType.Console) {
@@ -386,8 +395,7 @@ async function configureLogging(coreConfig, envVars) {
                         retainForMs: envMinToMs(envVars, "loggingRetainFor"),
                         maxEntries: envCount(envVars, "loggingMaxEntries"),
                         retentionIntervalMs: envMinToMs(envVars, "loggingRetentionInterval"),
-                        retentionBatchSize: envCount(envVars, "loggingRetentionBatchSize"),
-                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
+                        retentionBatchSize: envCount(envVars, "loggingRetentionBatchSize")
                     }
                 }
             });
@@ -424,8 +432,7 @@ async function configureLogging(coreConfig, envVars) {
                         directory: envVars.loggingFileDirectory ?? envVars.storageFileRoot ?? "",
                         filename: envVars.loggingFileFilename,
                         maxFileSizeBytes: envCount(envVars, "loggingFileMaxFileSizeBytes"),
-                        maxRetainedFiles: envCount(envVars, "loggingFileMaxRetainedFiles"),
-                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
+                        maxRetainedFiles: envCount(envVars, "loggingFileMaxRetainedFiles")
                     }
                 }
             });
@@ -463,7 +470,8 @@ async function configureLogging(coreConfig, envVars) {
  */
 async function configureVault(coreConfig, envVars) {
     coreConfig.types.vaultConnector ??= [];
-    if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
+    const vaultConnectorType = envChoice(envVars, "vaultConnector", Object.values(VaultConnectorType));
+    if (vaultConnectorType === VaultConnectorType.EntityStorage) {
         coreConfig.types.vaultConnector.push({
             type: VaultConnectorType.EntityStorage,
             options: {
@@ -473,7 +481,7 @@ async function configureVault(coreConfig, envVars) {
             }
         });
     }
-    else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
+    else if (vaultConnectorType === VaultConnectorType.Hashicorp) {
         coreConfig.types.vaultConnector.push({
             type: VaultConnectorType.Hashicorp,
             options: {
@@ -496,7 +504,17 @@ async function configureBackgroundTask(coreConfig, envVars) {
     coreConfig.types.backgroundTaskComponent ??= [];
     if (isBackgroundTasksRequired(envVars)) {
         coreConfig.types.backgroundTaskComponent.push({
-            type: BackgroundTaskComponentType.Service
+            type: BackgroundTaskComponentType.Service,
+            options: {
+                config: {
+                    maxSystemWorkerCount: envCount(envVars, "backgroundTaskMaxSystemWorkerCount", cpus().length * 2),
+                    taskInterval: envMs(envVars, "backgroundTaskInterval"),
+                    retryInterval: envMs(envVars, "backgroundTaskRetryInterval"),
+                    cleanupInterval: envMs(envVars, "backgroundTaskCleanupInterval"),
+                    workerShutdownTimeout: envMs(envVars, "backgroundTaskWorkerShutdownTimeout"),
+                    maxDispatchCount: envCount(envVars, "backgroundTaskMaxDispatchCount")
+                }
+            }
         });
     }
 }
@@ -508,7 +526,8 @@ async function configureBackgroundTask(coreConfig, envVars) {
  */
 async function configureEventBus(coreConfig, envVars) {
     coreConfig.types.eventBusConnector ??= [];
-    if (envVars.eventBusConnector === EventBusConnectorType.Local) {
+    const eventBusConnectorType = envChoice(envVars, "eventBusConnector", Object.values(EventBusConnectorType));
+    if (eventBusConnectorType === EventBusConnectorType.Local) {
         coreConfig.types.eventBusConnector.push({
             type: EventBusConnectorType.Local
         });
@@ -526,16 +545,16 @@ async function configureEventBus(coreConfig, envVars) {
  */
 async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
-    const telemetryConnectorTypes = commaSeparatedListToArray(envVars.telemetryConnector);
+    const telemetryConnectorTypes = envListToArray(envVars, "telemetryConnector", Object.values(TelemetryConnectorType));
     let additionalConnectorCount = 0;
-    for (const telemetryConnector of telemetryConnectorTypes) {
-        if (telemetryConnector === TelemetryConnectorType.Silent) {
+    for (const telemetryConnectorType of telemetryConnectorTypes) {
+        if (telemetryConnectorType === TelemetryConnectorType.Silent) {
             coreConfig.types.telemetryConnector.push({
                 type: TelemetryConnectorType.Silent
             });
             additionalConnectorCount++;
         }
-        else if (telemetryConnector === TelemetryConnectorType.EntityStorage) {
+        else if (telemetryConnectorType === TelemetryConnectorType.EntityStorage) {
             coreConfig.types.telemetryConnector.push({
                 type: TelemetryConnectorType.EntityStorage,
                 options: {
@@ -543,7 +562,9 @@ async function configureTelemetry(coreConfig, envVars) {
                         batchSize: envCount(envVars, "telemetryBatchSize"),
                         batchIntervalMs: envSecToMs(envVars, "telemetryBatchFlushInterval"),
                         maxCacheSize: envCount(envVars, "telemetryMaxCacheSize"),
-                        mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout"),
+                        flushTimeoutMs: envMs(envVars, "telemetryFlushTimeout"),
+                        taskCoalesceMs: envMs(envVars, "telemetryTaskCoalesce"),
+                        taskStallTimeoutMs: envMs(envVars, "telemetryTaskStallTimeout"),
                         metricDefinitionCacheCapacity: envCount(envVars, "telemetryMetricDefinitionCacheCapacity"),
                         metricDefinitionCacheTtiMs: envMs(envVars, "telemetryMetricDefinitionCacheTtiMs")
                     }
@@ -551,7 +572,7 @@ async function configureTelemetry(coreConfig, envVars) {
             });
             additionalConnectorCount++;
         }
-        else if (telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
+        else if (telemetryConnectorType === TelemetryConnectorType.OpenTelemetry) {
             let readers;
             if (envVars.openTelemetryReader === OpenTelemetryReaderTypes.Prometheus) {
                 readers = {
@@ -614,8 +635,10 @@ async function configureMetricsCollector(coreConfig, envVars) {
             cloneMode: EngineCloneMode.Never
         });
         coreConfig.types.metricsProducerComponent ??= [];
-        const metricsProducers = commaSeparatedListToArray(envVars.telemetryMetricsProducers ??
-            [MetricsProducerComponentType.System, MetricsProducerComponentType.Process].join(","));
+        const metricsProducers = envListToArray(envVars, "telemetryMetricsProducers", Object.values(MetricsProducerComponentType), [
+            MetricsProducerComponentType.System,
+            MetricsProducerComponentType.Process
+        ]);
         for (const producerType of metricsProducers) {
             coreConfig.types.metricsProducerComponent.push({
                 type: producerType,
@@ -633,27 +656,28 @@ async function configureMetricsCollector(coreConfig, envVars) {
  */
 async function configureTracing(coreConfig, envVars) {
     coreConfig.types.tracingConnector ??= [];
-    const tracingConnectorTypes = commaSeparatedListToArray(envVars.tracingConnector);
+    const tracingConnectorTypes = envListToArray(envVars, "tracingConnector", Object.values(TracingConnectorType));
     let additionalConnectorCount = 0;
-    for (const tracingConnector of tracingConnectorTypes) {
-        if (tracingConnector === TracingConnectorType.Silent) {
+    for (const tracingConnectorType of tracingConnectorTypes) {
+        if (tracingConnectorType === TracingConnectorType.Silent) {
             coreConfig.types.tracingConnector.push({
                 type: TracingConnectorType.Silent
             });
             additionalConnectorCount++;
         }
-        else if (tracingConnector === TracingConnectorType.EntityStorage) {
+        else if (tracingConnectorType === TracingConnectorType.EntityStorage) {
             coreConfig.types.tracingConnector.push({
-                type: TracingConnectorType.EntityStorage,
-                options: {
-                    config: {
-                        mutexTimeoutMs: envMs(envVars, "tracingMutexTimeout")
-                    }
-                }
+                type: TracingConnectorType.EntityStorage
             });
             additionalConnectorCount++;
         }
-        else if (tracingConnector === TracingConnectorType.OpenTelemetry) {
+        else if (tracingConnectorType === TracingConnectorType.Console) {
+            coreConfig.types.tracingConnector.push({
+                type: TracingConnectorType.Console
+            });
+            additionalConnectorCount++;
+        }
+        else if (tracingConnectorType === TracingConnectorType.OpenTelemetry) {
             const otelTracingConfig = {
                 tracerName: envVars.openTelemetryTracingTracerName,
                 tracerVersion: envVars.openTelemetryTracingTracerVersion
@@ -697,6 +721,80 @@ async function configureTracing(coreConfig, envVars) {
         coreConfig.types.tracingComponent.push({ type: TracingComponentType.Service });
     }
 }
+/**
+ * Configures the facades.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the facade configuration has been applied.
+ */
+async function configureFacades(coreConfig, envVars) {
+    const facadeTypes = envListToArray(envVars, "facade", Object.values(FacadeType));
+    if (!Is.arrayValue(facadeTypes)) {
+        return;
+    }
+    coreConfig.types.facade ??= [];
+    coreConfig.facades ??= {};
+    for (const facadeType of facadeTypes) {
+        if (facadeType === FacadeType.Tracing) {
+            configureTracingFacade(coreConfig.types.facade, coreConfig.facades, envVars);
+        }
+    }
+}
+/**
+ * Configures the tracing facade.
+ * @param facadeTypeConfigs The facade type configs to add to.
+ * @param facades The facades to activate, keyed by the type name of the factory they apply to.
+ * @param envVars The environment variables.
+ */
+function configureTracingFacade(facadeTypeConfigs, facades, envVars) {
+    // The facade records its spans through the tracing subsystem, without it there is nothing to record to.
+    if (!isTracingEnabled(envVars)) {
+        return;
+    }
+    // The facade is meaningless without factories to activate it on, so fall back to the defaults.
+    const configuredFactoryTypeNames = commaSeparatedListToArray(envVars.tracingFacadeFactories);
+    const factoryTypeNames = [
+        ...new Set(Is.arrayValue(configuredFactoryTypeNames)
+            ? configuredFactoryTypeNames
+            : DEFAULT_TRACING_FACADE_FACTORIES)
+    ];
+    const config = {};
+    // Adding to the default excludes. We want to keep default list as a base and only add to it.
+    const excludeParams = commaSeparatedListToArray(envVars.tracingFacadeExcludeParams);
+    if (Is.arrayValue(excludeParams)) {
+        config.excludeParams = [
+            ...new Set([...TracingFacade.DEFAULT_EXCLUDE_PARAMS, ...excludeParams])
+        ];
+    }
+    const excludeMethods = commaSeparatedListToArray(envVars.tracingFacadeExcludeMethods);
+    if (Is.arrayValue(excludeMethods)) {
+        config.excludeMethods = [
+            ...new Set([...TracingFacade.DEFAULT_EXCLUDE_METHODS, ...excludeMethods])
+        ];
+    }
+    const includeObjects = commaSeparatedListToArray(envVars.tracingFacadeIncludeObjects);
+    if (Is.arrayValue(includeObjects)) {
+        config.includeObjects = includeObjects;
+    }
+    facadeTypeConfigs.push({
+        type: FacadeType.Tracing,
+        options: Is.objectValue(config) ? { config } : undefined,
+        cloneMode: EngineCloneMode.Always
+    });
+    const componentExcludeTypes = [
+        ...new Set([
+            ...DEFAULT_TRACING_FACADE_COMPONENT_EXCLUDE_TYPES,
+            ...commaSeparatedListToArray(envVars.tracingFacadeComponentExcludeTypes)
+        ])
+    ];
+    for (const factoryTypeName of factoryTypeNames) {
+        facades[factoryTypeName] ??= [];
+        facades[factoryTypeName].push({
+            name: TRACING_FACADE_NAME,
+            excludeTypes: factoryTypeName === COMPONENT_FACTORY_TYPE_NAME ? componentExcludeTypes : undefined
+        });
+    }
+}
 /**
  * Configures the automation.
  * @param coreConfig The core config.
@@ -709,15 +807,13 @@ async function configureAutomation(coreConfig, envVars) {
         coreConfig.types.automationComponent.push({
             type: AutomationComponentType.Service
         });
-        const automationActionTypes = commaSeparatedListToArray(envVars.automationActionTypes);
-        if (Is.arrayValue(automationActionTypes)) {
-            coreConfig.types.automationAction ??= [];
-            for (const actionType of automationActionTypes) {
-                coreConfig.types.automationAction.push({
-                    type: actionType,
-                    isMultiInstance: true
-                });
-            }
+        const automationActionTypes = envListToArray(envVars, "automationActionTypes", Object.values(AutomationActionType));
+        coreConfig.types.automationAction ??= [];
+        for (const actionType of automationActionTypes) {
+            coreConfig.types.automationAction.push({
+                type: actionType,
+                isMultiInstance: true
+            });
         }
     }
 }
@@ -736,7 +832,8 @@ async function configureHealth(coreConfig, envVars) {
                 config: {
                     healthCheckInterval: envSecToMs(envVars, "healthInterval"),
                     healthCheckApplicationInterval: envSecToMs(envVars, "healthApplicationInterval"),
-                    initialInterval: envSecToMs(envVars, "healthStartupInterval")
+                    initialInterval: envSecToMs(envVars, "healthStartupInterval"),
+                    excludeCloneComponents: envListToArray(envVars, "healthExcludeCloneComponents", undefined, DEFAULT_HEALTH_EXCLUDE_CLONE_COMPONENTS)
                 }
             },
             cloneMode: EngineCloneMode.Never
@@ -820,69 +917,89 @@ async function configureContextIdHandlers(coreConfig, envVars) {
  * @returns A promise that resolves when the messaging configuration has been applied.
  */
 async function configureMessaging(coreConfig, envVars) {
-    if (envBoolean(envVars, "messagingEnabled", false)) {
-        coreConfig.types.messagingEmailConnector ??= [];
-        coreConfig.types.messagingSmsConnector ??= [];
-        coreConfig.types.messagingPushNotificationConnector ??= [];
-        if (envVars.messagingEmailConnector === MessagingEmailConnectorType.EntityStorage) {
-            coreConfig.types.messagingEmailConnector.push({
-                type: MessagingEmailConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingEmailConnector === MessagingEmailConnectorType.Aws) {
-            coreConfig.types.messagingEmailConnector.push({
-                type: MessagingEmailConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint
-                    }
+    coreConfig.types.messagingEmailConnector ??= [];
+    coreConfig.types.messagingSmsConnector ??= [];
+    coreConfig.types.messagingPushNotificationConnector ??= [];
+    const messagingEmailConnectorType = envChoice(envVars, "messagingEmailConnector", Object.values(MessagingEmailConnectorType));
+    if (messagingEmailConnectorType === MessagingEmailConnectorType.EntityStorage) {
+        coreConfig.types.messagingEmailConnector.push({
+            type: MessagingEmailConnectorType.EntityStorage
+        });
+    }
+    else if (messagingEmailConnectorType === MessagingEmailConnectorType.Aws) {
+        coreConfig.types.messagingEmailConnector.push({
+            type: MessagingEmailConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsSesRegion ?? "",
+                    authMode: envVars.awsSesAuthMode,
+                    accessKeyId: envVars.awsSesAccessKeyId,
+                    secretAccessKey: envVars.awsSesSecretAccessKey,
+                    endpoint: envVars.awsSesEndpoint
                 }
-            });
-        }
-        if (envVars.messagingSmsConnector === MessagingSmsConnectorType.EntityStorage) {
-            coreConfig.types.messagingSmsConnector.push({
-                type: MessagingSmsConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingSmsConnector === MessagingSmsConnectorType.Aws) {
-            coreConfig.types.messagingSmsConnector.push({
-                type: MessagingSmsConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint
-                    }
+            }
+        });
+    }
+    else if (messagingEmailConnectorType === MessagingEmailConnectorType.Smtp) {
+        coreConfig.types.messagingEmailConnector.push({
+            type: MessagingEmailConnectorType.Smtp,
+            options: {
+                config: {
+                    host: envVars.smtpHost ?? "",
+                    port: envInteger(envVars, "smtpPort"),
+                    secure: envBoolean(envVars, "smtpSecure"),
+                    username: envVars.smtpUsername,
+                    password: envVars.smtpPassword
                 }
-            });
-        }
-        if (envVars.messagingPushNotificationConnector ===
-            MessagingPushNotificationConnectorType.EntityStorage) {
-            coreConfig.types.messagingPushNotificationConnector.push({
-                type: MessagingPushNotificationConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingPushNotificationConnector === MessagingPushNotificationConnectorType.Aws) {
-            coreConfig.types.messagingPushNotificationConnector.push({
-                type: MessagingPushNotificationConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint,
-                        applicationsSettings: envArray(envVars, "awsMessagingPushNotificationApplications", [])
-                    }
+            }
+        });
+    }
+    const messagingSmsConnectorType = envChoice(envVars, "messagingSmsConnector", Object.values(MessagingSmsConnectorType));
+    if (messagingSmsConnectorType === MessagingSmsConnectorType.EntityStorage) {
+        coreConfig.types.messagingSmsConnector.push({
+            type: MessagingSmsConnectorType.EntityStorage
+        });
+    }
+    else if (messagingSmsConnectorType === MessagingSmsConnectorType.Aws) {
+        coreConfig.types.messagingSmsConnector.push({
+            type: MessagingSmsConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsSesRegion ?? "",
+                    authMode: envVars.awsSesAuthMode,
+                    accessKeyId: envVars.awsSesAccessKeyId,
+                    secretAccessKey: envVars.awsSesSecretAccessKey,
+                    endpoint: envVars.awsSesEndpoint
                 }
-            });
-        }
+            }
+        });
+    }
+    const messagingPushConnectorType = envChoice(envVars, "messagingPushNotificationConnector", Object.values(MessagingPushNotificationConnectorType));
+    if (messagingPushConnectorType === MessagingPushNotificationConnectorType.EntityStorage) {
+        coreConfig.types.messagingPushNotificationConnector.push({
+            type: MessagingPushNotificationConnectorType.EntityStorage
+        });
+    }
+    else if (messagingPushConnectorType === MessagingPushNotificationConnectorType.Aws) {
+        coreConfig.types.messagingPushNotificationConnector.push({
+            type: MessagingPushNotificationConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsSesRegion ?? "",
+                    authMode: envVars.awsSesAuthMode,
+                    accessKeyId: envVars.awsSesAccessKeyId,
+                    secretAccessKey: envVars.awsSesSecretAccessKey,
+                    endpoint: envVars.awsSesEndpoint,
+                    applicationsSettings: envArray(envVars, "awsMessagingPushNotificationApplications", [])
+                }
+            }
+        });
+    }
+    // If any messaging connectors are configured, then we should configure the messaging admin and
+    // service components as well since they are required for the messaging connectors to work.
+    if (coreConfig.types.messagingEmailConnector.length > 0 ||
+        coreConfig.types.messagingSmsConnector.length > 0 ||
+        coreConfig.types.messagingPushNotificationConnector.length > 0) {
         coreConfig.types.messagingAdminComponent ??= [];
         coreConfig.types.messagingAdminComponent.push({
             type: MessagingAdminComponentType.Service
@@ -891,6 +1008,40 @@ async function configureMessaging(coreConfig, envVars) {
         coreConfig.types.messagingComponent.push({ type: MessagingComponentType.Service });
     }
 }
+/**
+ * Configures mailbox components, mail storage components, and email protocol connectors.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the mailbox configuration has been applied.
+ */
+async function configureMailbox(coreConfig, envVars) {
+    coreConfig.types.emailProtocolConnector ??= [];
+    const emailProtocolConnectorTypes = envListToArray(envVars, "emailProtocolConnector", Object.values(EmailProtocolConnectorType));
+    for (const emailProtocolConnectorType of emailProtocolConnectorTypes) {
+        coreConfig.types.emailProtocolConnector.push({
+            type: emailProtocolConnectorType,
+            options: {
+                config: {}
+            },
+            cloneMode: EngineCloneMode.Never,
+            isMultiInstance: true
+        });
+    }
+    // If email protocol connectors are configured, then we should configure the mailbox and mail store
+    // components as well, since they are required for the email protocol connectors to work.
+    if (coreConfig.types.emailProtocolConnector.length > 0) {
+        coreConfig.types.mailStorageComponent ??= [];
+        coreConfig.types.mailStorageComponent.push({
+            type: MailStorageComponentType.Service,
+            cloneMode: EngineCloneMode.Never
+        });
+        coreConfig.types.mailboxComponent ??= [];
+        coreConfig.types.mailboxComponent.push({
+            type: MailboxComponentType.Service,
+            cloneMode: EngineCloneMode.Never
+        });
+    }
+}
 /**
  * Configures the faucet.
  * @param coreConfig The core config.
@@ -899,12 +1050,13 @@ async function configureMessaging(coreConfig, envVars) {
  */
 async function configureFaucet(coreConfig, envVars) {
     coreConfig.types.faucetConnector ??= [];
-    if (envVars.faucetConnector === FaucetConnectorType.EntityStorage) {
+    const faucetConnectorType = envChoice(envVars, "faucetConnector", Object.values(FaucetConnectorType));
+    if (faucetConnectorType === FaucetConnectorType.EntityStorage) {
         coreConfig.types.faucetConnector.push({
             type: FaucetConnectorType.EntityStorage
         });
     }
-    else if (envVars.faucetConnector === FaucetConnectorType.Iota &&
+    else if (faucetConnectorType === FaucetConnectorType.Iota &&
         Is.stringValue(envVars.iotaFaucetEndpoint)) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.faucetConnector.push({
@@ -927,12 +1079,13 @@ async function configureFaucet(coreConfig, envVars) {
  */
 async function configureWallet(coreConfig, envVars) {
     coreConfig.types.walletConnector ??= [];
-    if (envVars.walletConnector === WalletConnectorType.EntityStorage) {
+    const walletConnectorType = envChoice(envVars, "walletConnector", Object.values(WalletConnectorType));
+    if (walletConnectorType === WalletConnectorType.EntityStorage) {
         coreConfig.types.walletConnector.push({
             type: WalletConnectorType.EntityStorage
         });
     }
-    else if (envVars.walletConnector === WalletConnectorType.Iota) {
+    else if (walletConnectorType === WalletConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.walletConnector.push({
             type: WalletConnectorType.Iota,
@@ -950,12 +1103,13 @@ async function configureWallet(coreConfig, envVars) {
  */
 async function configureNft(coreConfig, envVars) {
     coreConfig.types.nftConnector ??= [];
-    if (envVars.nftConnector === NftConnectorType.EntityStorage) {
+    const nftConnectorType = envChoice(envVars, "nftConnector", Object.values(NftConnectorType));
+    if (nftConnectorType === NftConnectorType.EntityStorage) {
         coreConfig.types.nftConnector.push({
             type: NftConnectorType.EntityStorage
         });
     }
-    else if (envVars.nftConnector === NftConnectorType.Iota) {
+    else if (nftConnectorType === NftConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         const config = {
             ...dltConfig?.options?.config,
@@ -981,12 +1135,13 @@ async function configureNft(coreConfig, envVars) {
  */
 async function configureNotarization(coreConfig, envVars) {
     coreConfig.types.notarizationConnector ??= [];
-    if (envVars.notarizationConnector === NotarizationConnectorType.EntityStorage) {
+    const notarizationConnectorType = envChoice(envVars, "notarizationConnector", Object.values(NotarizationConnectorType));
+    if (notarizationConnectorType === NotarizationConnectorType.EntityStorage) {
         coreConfig.types.notarizationConnector.push({
             type: NotarizationConnectorType.EntityStorage
         });
     }
-    else if (envVars.notarizationConnector === NotarizationConnectorType.Iota) {
+    else if (notarizationConnectorType === NotarizationConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.notarizationConnector.push({
             type: NotarizationConnectorType.Iota,
@@ -1017,6 +1172,7 @@ async function configureImmutableProof(coreConfig, envVars) {
                     taskRetryCount: envCount(envVars, "immutableProofTaskRetryCount"),
                     taskRetryInterval: envSecToMs(envVars, "immutableProofTaskRetryInterval"),
                     taskFailureRetainFor: envMinToMs(envVars, "immutableProofTaskFailureRetainFor"),
+                    taskWorkerIdleTimeout: envSecToMs(envVars, "immutableProofTaskWorkerIdleTimeout"),
                     sweepIntervalMinutes: envMinutes(envVars, "immutableProofSweepInterval"),
                     sweepStaleThresholdMs: envMinToMs(envVars, "immutableProofSweepStaleThreshold"),
                     sweepMaxAttempts: envCount(envVars, "immutableProofSweepMaxAttempts"),
@@ -1036,12 +1192,13 @@ async function configureImmutableProof(coreConfig, envVars) {
  */
 async function configureIdentity(coreConfig, envVars) {
     coreConfig.types.identityConnector ??= [];
-    if (envVars.identityConnector === IdentityConnectorType.EntityStorage) {
+    const identityConnectorType = envChoice(envVars, "identityConnector", Object.values(IdentityConnectorType));
+    if (identityConnectorType === IdentityConnectorType.EntityStorage) {
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.EntityStorage
         });
     }
-    else if (envVars.identityConnector === IdentityConnectorType.Iota) {
+    else if (identityConnectorType === IdentityConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.Iota,
@@ -1074,12 +1231,13 @@ async function configureIdentity(coreConfig, envVars) {
  */
 async function configureIdentityResolver(coreConfig, envVars) {
     coreConfig.types.identityResolverConnector ??= [];
-    if (envVars.identityResolverConnector === IdentityResolverConnectorType.EntityStorage) {
+    const identityResolverConnectorType = envChoice(envVars, "identityResolverConnector", Object.values(IdentityResolverConnectorType));
+    if (identityResolverConnectorType === IdentityResolverConnectorType.EntityStorage) {
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.EntityStorage
         });
     }
-    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Iota) {
+    else if (identityResolverConnectorType === IdentityResolverConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.Iota,
@@ -1093,7 +1251,7 @@ async function configureIdentityResolver(coreConfig, envVars) {
             }
         });
     }
-    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Universal) {
+    else if (identityResolverConnectorType === IdentityResolverConnectorType.Universal) {
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.Universal,
             options: {
@@ -1118,7 +1276,8 @@ async function configureIdentityResolver(coreConfig, envVars) {
  */
 async function configureIdentityProfile(coreConfig, envVars) {
     coreConfig.types.identityProfileConnector ??= [];
-    if (envVars.identityProfileConnector === IdentityConnectorType.EntityStorage) {
+    const identityProfileConnectorType = envChoice(envVars, "identityProfileConnector", Object.values(IdentityProfileConnectorType));
+    if (identityProfileConnectorType === IdentityProfileConnectorType.EntityStorage) {
         coreConfig.types.identityProfileConnector.push({
             type: IdentityProfileConnectorType.EntityStorage
         });
@@ -1136,7 +1295,8 @@ async function configureIdentityProfile(coreConfig, envVars) {
  */
 async function configureAttestation(coreConfig, envVars) {
     coreConfig.types.attestationConnector ??= [];
-    if (envVars.attestationConnector === AttestationConnectorType.Nft) {
+    const attestationConnectorType = envChoice(envVars, "attestationConnector", Object.values(AttestationConnectorType));
+    if (attestationConnectorType === AttestationConnectorType.Nft) {
         coreConfig.types.attestationConnector.push({
             type: AttestationConnectorType.Nft
         });
@@ -1198,23 +1358,24 @@ async function configureAuditableItemStream(coreConfig, envVars) {
  * @returns A promise that resolves when the data processing configuration has been applied.
  */
 async function configureDataProcessing(coreConfig, envVars) {
-    if (envBoolean(envVars, "dataProcessingEnabled", false)) {
+    coreConfig.types.dataConverterConnector ??= [];
+    const converterConnectors = envListToArray(envVars, "dataConverterConnectors", Object.values(DataConverterConnectorType));
+    for (const converterConnector of converterConnectors) {
+        coreConfig.types.dataConverterConnector.push({
+            type: converterConnector
+        });
+    }
+    coreConfig.types.dataExtractorConnector ??= [];
+    const extractorConnectors = envListToArray(envVars, "dataExtractorConnectors", Object.values(DataExtractorConnectorType));
+    for (const extractorConnector of extractorConnectors) {
+        coreConfig.types.dataExtractorConnector.push({
+            type: extractorConnector
+        });
+    }
+    if (coreConfig.types.dataConverterConnector.length > 0 ||
+        coreConfig.types.dataExtractorConnector.length > 0) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
-        coreConfig.types.dataConverterConnector ??= [];
-        const converterConnectors = commaSeparatedListToArray(envVars.dataConverterConnectors);
-        for (const converterConnector of converterConnectors) {
-            coreConfig.types.dataConverterConnector.push({
-                type: converterConnector
-            });
-        }
-        coreConfig.types.dataExtractorConnector ??= [];
-        const extractorConnectors = commaSeparatedListToArray(envVars.dataExtractorConnectors);
-        for (const extractorConnector of extractorConnectors) {
-            coreConfig.types.dataExtractorConnector.push({
-                type: extractorConnector
-            });
-        }
     }
 }
 /**
@@ -1249,7 +1410,7 @@ async function configureTrust(coreConfig, envVars) {
             type: TrustComponentType.Service
         });
         coreConfig.types.trustGeneratorComponent ??= [];
-        const trustGeneratorTypes = commaSeparatedListToArray(envVars.trustGenerators);
+        const trustGeneratorTypes = envListToArray(envVars, "trustGenerators", Object.values(TrustGeneratorComponentType));
         for (const trustGeneratorType of trustGeneratorTypes) {
             coreConfig.types.trustGeneratorComponent.push({
                 type: trustGeneratorType,
@@ -1262,12 +1423,11 @@ async function configureTrust(coreConfig, envVars) {
             });
         }
         coreConfig.types.trustVerifierComponent ??= [];
-        const trustVerifierTypes = commaSeparatedListToArray(envVars.trustVerifiers);
+        const trustVerifierTypes = envListToArray(envVars, "trustVerifiers", Object.values(TrustVerifierComponentType));
         for (const trustVerifierType of trustVerifierTypes) {
-            const type = trustVerifierType;
-            if (type === TrustVerifierComponentType.IdentityAllowDeny) {
+            if (trustVerifierType === TrustVerifierComponentType.IdentityAllowDeny) {
                 coreConfig.types.trustVerifierComponent.push({
-                    type,
+                    type: TrustVerifierComponentType.IdentityAllowDeny,
                     options: {
                         config: {
                             allowIdentities: commaSeparatedListToArray(envVars.trustIdentitiesAllow),
@@ -1276,9 +1436,9 @@ async function configureTrust(coreConfig, envVars) {
                     }
                 });
             }
-            else {
+            else if (trustVerifierType === TrustVerifierComponentType.JwtVerifiableCredential) {
                 coreConfig.types.trustVerifierComponent.push({
-                    type
+                    type: TrustVerifierComponentType.JwtVerifiableCredential
                 });
             }
         }
@@ -1356,49 +1516,49 @@ async function configureRightsManagement(coreConfig, envVars) {
             }
         });
         coreConfig.types.rightsManagementPolicyArbiterComponent ??= [];
-        const policyArbiterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyArbiters);
+        const policyArbiterTypes = envListToArray(envVars, "rightsManagementPolicyArbiters", Object.values(RightsManagementPolicyArbiterComponentType));
         for (const policyArbiterType of policyArbiterTypes) {
             coreConfig.types.rightsManagementPolicyArbiterComponent.push({
                 type: policyArbiterType
             });
         }
         coreConfig.types.rightsManagementPolicyObligationEnforcerComponent ??= [];
-        const policyObligationEnforcerTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyObligationEnforcers);
+        const policyObligationEnforcerTypes = envListToArray(envVars, "rightsManagementPolicyObligationEnforcers", Object.values(RightsManagementPolicyObligationEnforcerComponentType));
         for (const policyObligationEnforcerType of policyObligationEnforcerTypes) {
             coreConfig.types.rightsManagementPolicyObligationEnforcerComponent.push({
                 type: policyObligationEnforcerType
             });
         }
         coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent ??= [];
-        const policyEnforcementProcessTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyEnforcementProcessors);
+        const policyEnforcementProcessTypes = envListToArray(envVars, "rightsManagementPolicyEnforcementProcessors", Object.values(RightsManagementPolicyEnforcementProcessorComponentType));
         for (const policyEnforcementProcessorType of policyEnforcementProcessTypes) {
             coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent.push({
                 type: policyEnforcementProcessorType
             });
         }
         coreConfig.types.rightsManagementPolicyExecutionActionComponent ??= [];
-        const policyExecutionActionTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyExecutionActions);
+        const policyExecutionActionTypes = envListToArray(envVars, "rightsManagementPolicyExecutionActions", Object.values(RightsManagementPolicyExecutionActionComponentType));
         for (const policyExecutionActionType of policyExecutionActionTypes) {
             coreConfig.types.rightsManagementPolicyExecutionActionComponent.push({
                 type: policyExecutionActionType
             });
         }
         coreConfig.types.rightsManagementPolicyInformationSourceComponent ??= [];
-        const policyInformationSourceTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyInformationSources);
+        const policyInformationSourceTypes = envListToArray(envVars, "rightsManagementPolicyInformationSources", Object.values(RightsManagementPolicyInformationSourceComponentType));
         for (const policyInformationSourceType of policyInformationSourceTypes) {
             coreConfig.types.rightsManagementPolicyInformationSourceComponent.push({
                 type: policyInformationSourceType
             });
         }
         coreConfig.types.rightsManagementPolicyRequesterComponent ??= [];
-        const policyRequesterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyRequesters);
+        const policyRequesterTypes = envListToArray(envVars, "rightsManagementPolicyRequesters", Object.values(RightsManagementPolicyRequesterComponentType));
         for (const policyRequesterType of policyRequesterTypes) {
             coreConfig.types.rightsManagementPolicyRequesterComponent.push({
                 type: policyRequesterType
             });
         }
         coreConfig.types.rightsManagementPolicyNegotiatorComponent ??= [];
-        const policyNegotiatorTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyNegotiators);
+        const policyNegotiatorTypes = envListToArray(envVars, "rightsManagementPolicyNegotiators", Object.values(RightsManagementPolicyNegotiatorComponentType));
         for (const policyNegotiatorType of policyNegotiatorTypes) {
             coreConfig.types.rightsManagementPolicyNegotiatorComponent.push({
                 type: policyNegotiatorType
@@ -1448,7 +1608,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
                 }
             });
             coreConfig.types.federatedCatalogueFilterComponent ??= [];
-            const filters = commaSeparatedListToArray(envVars.federatedCatalogueFilters);
+            const filters = envListToArray(envVars, "federatedCatalogueFilters", Object.values(FederatedCatalogueFilterComponentType));
             for (const filter of filters) {
                 coreConfig.types.federatedCatalogueFilterComponent.push({
                     type: filter,
@@ -1571,7 +1731,8 @@ export function isTrustRequired(envVars) {
 export function isBackgroundTasksRequired(envVars) {
     return (envBoolean(envVars, "dataspaceEnabled", false) ||
         isImmutableProofRequired(envVars) ||
-        envBoolean(envVars, "healthEnabled", false));
+        envBoolean(envVars, "healthEnabled", false) ||
+        commaSeparatedListToArray(envVars.telemetryConnector).includes(TelemetryConnectorType.EntityStorage));
 }
 /**
  * Checks if the immutable proof subsystem is required.
@@ -1619,7 +1780,8 @@ export function isTaskSchedulerRequired(envVars) {
         envBoolean(envVars, "dataspaceEnabled", false) ||
         isRightsManagementRequired(envVars) ||
         isAuthEntityStorageRequired(envVars) ||
-        isImmutableProofRequired(envVars));
+        isImmutableProofRequired(envVars) ||
+        isMailboxEnabled(envVars));
 }
 /**
  * Checks if the automation subsystem is required.
@@ -1646,6 +1808,20 @@ export function isTelemetryEnabled(envVars) {
  * @returns True if tracing is enabled.
  */
 export function isTracingEnabled(envVars) {
-    return commaSeparatedListToArray(envVars.tracingConnector).some(t => t === TracingConnectorType.EntityStorage || t === TracingConnectorType.OpenTelemetry);
+    return commaSeparatedListToArray(envVars.tracingConnector).some(t => t === TracingConnectorType.EntityStorage ||
+        t === TracingConnectorType.OpenTelemetry ||
+        t === TracingConnectorType.Console);
+}
+/**
+ * Checks if the mailbox subsystem is enabled.
+ * Returns true when any component that depends on the mailbox subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if mailbox is enabled.
+ */
+export function isMailboxEnabled(envVars) {
+    return commaSeparatedListToArray(envVars.emailProtocolConnector).some(t => t === EmailProtocolConnectorType.Imap ||
+        t === EmailProtocolConnectorType.Pop3 ||
+        t === EmailProtocolConnectorType.Gmail ||
+        t === EmailProtocolConnectorType.Outlook);
 }
 //# sourceMappingURL=engineEnvBuilder.js.map