@twin.org/node-core 0.0.2-next.1 → 0.0.2-next.10

package/dist/cjs/index.cjs

@@ -3,6 +3,7 @@
 var apiAuthEntityStorageService = require('@twin.org/api-auth-entity-storage-service');
 var core = require('@twin.org/core');
 var crypto = require('@twin.org/crypto');
+var engineServerTypes = require('@twin.org/engine-server-types');
 var engineTypes = require('@twin.org/engine-types');
 var entityStorageModels = require('@twin.org/entity-storage-models');
 var identityModels = require('@twin.org/identity-models');
@@ -10,8 +11,9 @@ var vaultModels = require('@twin.org/vault-models');
 var walletModels = require('@twin.org/wallet-models');
 var promises = require('node:fs/promises');
 var path = require('node:path');
+var rightsManagementRestClient = require('@twin.org/rights-management-rest-client');
 var engineServer = require('@twin.org/engine-server');
-var engineServerTypes = require('@twin.org/engine-server-types');
+var modules = require('@twin.org/modules');
 var dotenv = require('dotenv');
 var engine = require('@twin.org/engine');
 var engineCore = require('@twin.org/engine-core');
@@ -50,7 +52,11 @@ const NodeFeatures = {
     /**
      * NodeUser - generates a user for the node if not provided in config.
      */
-    NodeUser: "node-user"
+    NodeUser: "node-user",
+    /**
+     * NodeWallet - generates a wallet for the node and funds it when there is a faucet available.
+     */
+    NodeWallet: "node-wallet"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -92,13 +98,21 @@ async function fileExists(filename) {
         return false;
     }
 }
+/**
+ * Load the text file.
+ * @param filename The filename of the text file to load.
+ * @returns The contents of the text file if it could not be loaded.
+ */
+async function loadTextFile(filename) {
+    return promises.readFile(filename, "utf8");
+}
 /**
  * Load the JSON file.
  * @param filename The filename of the JSON file to load.
  * @returns The contents of the JSON file or null if it could not be loaded.
  */
 async function loadJsonFile(filename) {
-    const content = await promises.readFile(filename, "utf8");
+    const content = await loadTextFile(filename);
     return JSON.parse(content);
 }
 /**
@@ -137,8 +151,12 @@ async function bootstrap(engineCore, context, envVars) {
     await bootstrapNodeUser(engineCore, context, envVars, features);
     await bootstrapAuth(engineCore, context, envVars);
     await bootstrapBlobEncryption(engineCore, context, envVars);
-    await bootstrapAttestationMethod(engineCore, context, envVars);
-    await bootstrapImmutableProofMethod(engineCore, context, envVars);
+    await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId);
+    await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId);
+    if (core.Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+        await addVerificationMethod(engineCore, context, "rights management", envVars.rightsManagementNegotiationMethodId);
+    }
+    await bootstrapSynchronisedStorage(engineCore, context, envVars);
 }
 /**
  * Bootstrap the node creating any necessary resources.
@@ -153,23 +171,21 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
         // But we have a chicken and egg problem in that we can't create the identity
         // to store the mnemonic in the vault without an identity. We use a temporary identity
         // and then replace it with the new identity later in the process.
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (!core.Is.empty(engineDefaultTypes.vaultConnector)) {
-            const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-            const workingIdentity = envVars.identity ??
-                context.state.nodeIdentity ??
-                `bootstrap-temp-${core.Converter.bytesToHex(core.RandomHelper.generate(16))}`;
-            await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
-            const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
-            const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
-            await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
-            await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
-            context.state.nodeIdentity = finalIdentity;
-            context.stateDirty = true;
-            engineCore.logInfo(core.I18n.formatMessage("node.nodeIdentity", {
-                identity: context.state.nodeIdentity
-            }));
-        }
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+        const workingIdentity = envVars.identity ??
+            context.state.nodeIdentity ??
+            `bootstrap-temp-${core.Converter.bytesToHex(core.RandomHelper.generate(16))}`;
+        await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
+        const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
+        const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
+        await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
+        await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
+        context.state.nodeIdentity = finalIdentity;
+        context.stateDirty = true;
+        engineCore.logInfo(core.I18n.formatMessage("node.nodeIdentity", {
+            identity: context.state.nodeIdentity
+        }));
     }
 }
 /**
@@ -181,12 +197,13 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
+    const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
     // Now create an identity for the node controlled by the address we just funded
-    const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+    const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
     let identityDocument;
     try {
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
         identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
         engineCore.logInfo(core.I18n.formatMessage("node.existingNodeIdentity", { identity: nodeIdentity }));
     }
@@ -196,7 +213,7 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
         identityDocument = await identityConnector.createDocument(nodeIdentity);
         engineCore.logInfo(core.I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
     }
-    if (engineDefaultTypes.identityConnector === engineTypes.IdentityConnectorType.Iota) {
+    if (defaultIdentityConnectorType.startsWith(engineTypes.IdentityConnectorType.Iota)) {
         const didUrn = core.Urn.fromValidString(identityDocument.id);
         const didParts = didUrn.parts();
         const objectId = didParts[3];
@@ -215,23 +232,26 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    const walletConnector = walletModels.WalletConnectorFactory.get(engineDefaultTypes.walletConnector);
-    const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
-    const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
-    if (balance === 0n) {
-        let address0 = addresses[0];
-        if (engineDefaultTypes.walletConnector === engineTypes.WalletConnectorType.Iota) {
-            address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        const walletConnector = walletModels.WalletConnectorFactory.get(defaultWalletConnectorType);
+        const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
+        const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
+        if (balance === 0n) {
+            let address0 = addresses[0];
+            if (defaultWalletConnectorType.startsWith(engineTypes.WalletConnectorType.Iota)) {
+                address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+            }
+            engineCore.logInfo(core.I18n.formatMessage("node.fundingWallet", { address: address0 }));
+            // Add some funds to the wallet from the faucet
+            await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
         }
-        engineCore.logInfo(core.I18n.formatMessage("node.fundingWallet", { address: address0 }));
-        // Add some funds to the wallet from the faucet
-        await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
-    }
-    else {
-        engineCore.logInfo(core.I18n.formatMessage("node.fundedWallet"));
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.fundedWallet"));
+        }
+        return addresses;
     }
-    return addresses;
+    return [];
 }
 /**
  * Bootstrap the identity for the node.
@@ -242,15 +262,17 @@ async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
  * @param addresses The addresses for the wallet.
  */
 async function finaliseWallet(engineCore, envVars, features, finalIdentity, addresses) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    // If we are using entity storage for wallet the identity associated with the
-    // address will be wrong, so fix it
-    if (engineDefaultTypes.walletConnector === "entity-storage") {
-        const walletAddress = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("WalletAddress"));
-        const addr = await walletAddress.get(addresses[0]);
-        if (!core.Is.empty(addr)) {
-            addr.identity = finalIdentity;
-            await walletAddress.set(addr);
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        // If we are using entity storage for wallet the identity associated with the
+        // address will be wrong, so fix it
+        if (defaultWalletConnectorType.startsWith(engineTypes.WalletConnectorType.EntityStorage)) {
+            const walletAddress = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("WalletAddress"));
+            const addr = await walletAddress.get(addresses[0]);
+            if (!core.Is.empty(addr)) {
+                addr.identity = finalIdentity;
+                await walletAddress.set(addr);
+            }
         }
     }
 }
@@ -312,8 +334,8 @@ async function finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity)
  */
 async function bootstrapNodeUser(engineCore, context, envVars, features) {
     if (features.includes(NodeFeatures.NodeUser)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+        const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceType("authenticationComponent");
+        if (defaultAuthenticationComponentType.startsWith(engineServerTypes.AuthenticationComponentType.EntityStorage) &&
             core.Is.stringValue(context.state.nodeIdentity)) {
             const authUserEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("AuthenticationUser"));
             const email = envVars.username ?? DEFAULT_NODE_USERNAME;
@@ -356,7 +378,8 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                 }
             }
             // We have create a node user, now we need to create a profile for the user
-            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(engineDefaultTypes.identityProfileConnector);
+            const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(defaultIdentityConnectorType);
             if (identityProfileConnector) {
                 let userProfile;
                 try {
@@ -386,43 +409,6 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
         }
     }
 }
-/**
- * Bootstrap the attestation verification methods.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- */
-async function bootstrapAttestationMethod(engineCore, context, envVars, features) {
-    if (core.Is.stringValue(context.state.nodeIdentity) &&
-        core.Is.arrayValue(context.config.types.identityConnector) &&
-        core.Is.stringValue(envVars.attestationVerificationMethodId)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.attestationVerificationMethodId}`;
-        let createVm = true;
-        try {
-            identityModels.DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add attestation verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(core.I18n.formatMessage("node.addingAttestation", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.existingAttestation", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
 /**
  * Bootstrap the immutable proof verification methods.
  * @param engineCore The engine core for the node.
@@ -430,36 +416,7 @@ async function bootstrapAttestationMethod(engineCore, context, envVars, features
  * @param envVars The environment variables for the node.
  * @param features The features that are enabled on the node.
  */
-async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (core.Is.stringValue(context.state.nodeIdentity) &&
-        core.Is.arrayValue(context.config.types.identityConnector) &&
-        core.Is.stringValue(envVars.immutableProofVerificationMethodId)) {
-        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`;
-        let createVm = true;
-        try {
-            identityModels.DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add AIG verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(core.I18n.formatMessage("node.addingImmutableProof", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.existingImmutableProof", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
+async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) { }
 /**
  * Bootstrap the keys for blob encryption.
  * @param engineCore The engine core for the node.
@@ -470,18 +427,28 @@ async function bootstrapImmutableProofMethod(engineCore, context, envVars, featu
 async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
     if ((core.Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
         core.Is.stringValue(context.state.nodeIdentity)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
         // Create a new key for encrypting blobs
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`;
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKeyId}`;
         let existingKey;
         try {
             existingKey = await vaultConnector.getKey(keyName);
         }
         catch { }
         if (core.Is.empty(existingKey)) {
-            engineCore.logInfo(core.I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
-            await vaultConnector.createKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305);
+            if (core.Is.stringBase64(envVars.blobStorageSymmetricEncryptionKey)) {
+                engineCore.logInfo(core.I18n.formatMessage("node.addingBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305, core.Converter.base64ToBytes(envVars.blobStorageSymmetricEncryptionKey));
+            }
+            else {
+                engineCore.logInfo(core.I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
+                const key = await vaultConnector.createKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305);
+                engineCore.logInfo(core.I18n.formatMessage("node.createdBlobEncryptionKey", {
+                    keyName,
+                    keyValue: core.Converter.bytesToBase64(key)
+                }));
+            }
         }
         else {
             engineCore.logInfo(core.I18n.formatMessage("node.existingBlobEncryptionKey", { keyName }));
@@ -496,11 +463,13 @@ async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
  * @param features The features that are enabled on the node.
  */
 async function bootstrapAuth(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+    const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceTypeOptional("authenticationComponent");
+    if (core.Is.stringValue(defaultAuthenticationComponentType) &&
+        defaultAuthenticationComponentType.startsWith(engineServerTypes.AuthenticationComponentType.EntityStorage) &&
         core.Is.stringValue(context.state.nodeIdentity)) {
         // Create a new JWT signing key and a user login for the node
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
         const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
         let existingKey;
         try {
@@ -516,6 +485,76 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
         }
     }
 }
+/**
+ * Bootstrap the synchronised storage blob encryption and verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapSynchronisedStorage(engineCore, context, envVars, features) {
+    if (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) {
+        // Add the verification method to the identity if it doesn't exist
+        await addVerificationMethod(engineCore, context, "synchronised storage", envVars.synchronisedStorageVerificationMethodId);
+        // If this is a trusted node we need to add the blob encryption key pair
+        if (core.Is.stringValue(envVars.synchronisedStorageBlobStorageEncryptionKeyId) &&
+            core.Is.stringBase64(envVars.synchronisedStorageBlobStorageKey)) {
+            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+            const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId;
+            let existingKey;
+            try {
+                existingKey = await vaultConnector.getKey(keyName);
+            }
+            catch { }
+            if (core.Is.empty(existingKey)) {
+                engineCore.logInfo(core.I18n.formatMessage("node.addingSynchronisedStorageBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305, core.Converter.base64ToBytes(envVars.synchronisedStorageBlobStorageKey));
+            }
+            else {
+                engineCore.logInfo(core.I18n.formatMessage("node.existingSynchronisedStorageBlobEncryptionKey", { keyName }));
+            }
+        }
+    }
+}
+/**
+ * Add a verification method if it doesn't exist.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param verificationMethodTitle The verification method title.
+ * @param verificationMethodId The verification method ID.
+ */
+async function addVerificationMethod(engineCore, context, verificationMethodTitle, verificationMethodId) {
+    if (core.Is.stringValue(context.state.nodeIdentity) &&
+        core.Is.arrayValue(context.config.types.identityConnector) &&
+        core.Is.stringValue(verificationMethodId)) {
+        const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+        const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${verificationMethodId}`;
+        let exists = false;
+        try {
+            identityModels.DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            engineCore.logInfo(core.I18n.formatMessage("node.addingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", verificationMethodId);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+        }
+    }
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -533,7 +572,10 @@ function buildEngineConfiguration(envVars) {
     envVars.attestationVerificationMethodId ??= "attestation-assertion";
     envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
     envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    envVars.blobStorageEncryptionKeyId ??= "blob-encryption";
+    envVars.synchronisedStorageBlobStorageEncryptionKeyId ??= "synchronised-storage-blob-encryption";
+    envVars.synchronisedStorageVerificationMethodId ??= "synchronised-storage-assertion";
+    envVars.rightsManagementNegotiationMethodId ??= "policy-negotiation-assertion";
     const coreConfig = {
         debug: core.Coerce.boolean(envVars.debug) ?? false,
         types: {}
@@ -544,6 +586,7 @@ function buildEngineConfiguration(envVars) {
     configureDlt(coreConfig, envVars);
     configureLogging(coreConfig, envVars);
     configureBackgroundTask(coreConfig, envVars);
+    configureTaskScheduler(coreConfig, envVars);
     configureEventBus(coreConfig, envVars);
     configureTelemetry(coreConfig, envVars);
     configureMessaging(coreConfig, envVars);
@@ -559,9 +602,10 @@ function buildEngineConfiguration(envVars) {
     configureAuditableItemGraph(coreConfig);
     configureAuditableItemStream(coreConfig);
     configureDocumentManagement(coreConfig);
-    configureFederatedCatalogue(coreConfig, envVars);
     configureRightsManagement(coreConfig, envVars);
-    configureTaskScheduler(coreConfig, envVars);
+    configureSynchronisedStorage(coreConfig, envVars);
+    configureFederatedCatalogue(coreConfig, envVars);
+    configureDataSpaceConnector(coreConfig, envVars);
     return coreConfig;
 }
 /**
@@ -581,14 +625,13 @@ function getIotaConfig(coreConfig) {
 function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
-    if ((core.Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
-        envVars.entityStorageConnectorType === engineTypes.EntityStorageConnectorType.Memory) {
+    const entityStorageConnectorTypes = envVars.entityStorageConnectorType?.split(",") ?? [];
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.Memory)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.Memory
         });
     }
-    if ((core.Coerce.boolean(envVars.entityFileEnable) ?? false) ||
-        envVars.entityStorageConnectorType === engineTypes.EntityStorageConnectorType.File) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.File)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.File,
             options: {
@@ -597,7 +640,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.AwsDynamoDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.AwsDynamoDb,
             options: {
@@ -611,7 +654,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.azureCosmosdbKey)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.AzureCosmosDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.AzureCosmosDb,
             options: {
@@ -625,7 +668,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.gcpFirestoreCredentials)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.GcpFirestoreDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.GcpFirestoreDb,
             options: {
@@ -640,41 +683,27 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.scylladbHosts)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.ScyllaDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.ScyllaDb,
             options: {
                 config: {
-                    hosts: envVars.scylladbHosts.split(",") ?? "",
+                    hosts: envVars.scylladbHosts?.split(",") ?? [],
                     localDataCenter: envVars.scylladbLocalDataCenter ?? "",
-                    keyspace: envVars.scylladbKeyspace ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.mySqlHost)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.MySqlDb,
-            options: {
-                config: {
-                    host: envVars.mySqlHost,
-                    port: envVars.mySqlPort ?? 3306,
-                    user: envVars.mySqlUser ?? "",
-                    password: envVars.mySqlPassword ?? "",
-                    database: envVars.mySqlDatabase ?? ""
+                    keyspace: envVars.scylladbKeyspace ?? "",
+                    port: core.Coerce.integer(envVars.scylladbPort)
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
         });
     }
-    if (core.Is.stringValue(envVars.mySqlHost)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.MySqlDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.MySqlDb,
             options: {
                 config: {
-                    host: envVars.mySqlHost,
-                    port: envVars.mySqlPort ?? 3306,
+                    host: envVars.mySqlHost ?? "",
+                    port: core.Coerce.integer(envVars.mySqlPort),
                     user: envVars.mySqlUser ?? "",
                     password: envVars.mySqlPassword ?? "",
                     database: envVars.mySqlDatabase ?? ""
@@ -683,13 +712,13 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.mongoDbHost)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.MongoDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.MongoDb,
             options: {
                 config: {
-                    host: envVars.mongoDbHost,
-                    port: envVars.mongoDbPort,
+                    host: envVars.mongoDbHost ?? "",
+                    port: core.Coerce.integer(envVars.mongoDbPort),
                     user: envVars.mongoDbUser ?? "",
                     password: envVars.mongoDbPassword ?? "",
                     database: envVars.mongoDbDatabase ?? ""
@@ -698,13 +727,13 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.postgreSqlHost)) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.PostgreSql)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.PostgreSql,
             options: {
                 config: {
-                    host: envVars.postgreSqlHost,
-                    port: envVars.postgreSqlPort,
+                    host: envVars.postgreSqlHost ?? "",
+                    port: core.Coerce.integer(envVars.postgreSqlPort),
                     user: envVars.postgreSqlUser ?? "",
                     password: envVars.postgreSqlPassword ?? "",
                     database: envVars.postgreSqlDatabase ?? ""
@@ -713,11 +742,21 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    const defaultStorageConnector = envVars.entityStorageConnectorType;
-    if (core.Is.stringValue(defaultStorageConnector)) {
+    const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.Synchronised)) {
+        // For synchronised storage we use the default connector as the one we wrap for real DB operations
+        coreConfig.types.entityStorageConnector.push({
+            type: engineTypes.EntityStorageConnectorType.Synchronised,
+            options: {
+                entityStorageConnectorType: defaultEntityStorageConnectorType
+            }
+        });
+    }
+    if (core.Is.arrayValue(entityStorageConnectorTypes)) {
         for (const config of coreConfig.types.entityStorageConnector) {
-            if (config.type === defaultStorageConnector) {
+            if (config.type === defaultEntityStorageConnectorType) {
                 config.isDefault = true;
+                break;
             }
         }
     }
@@ -729,14 +768,13 @@ function configureEntityStorage(coreConfig, envVars) {
  */
 function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
-    if ((core.Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.Memory) {
+    const blobStorageConnectorTypes = envVars.blobStorageConnectorType?.split(",") ?? [];
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.Memory)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.Memory
         });
     }
-    if ((core.Coerce.boolean(envVars.blobFileEnable) ?? false) ||
-        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.File) {
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.File)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.File,
             options: {
@@ -749,18 +787,18 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.ipfsApiUrl)) {
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.Ipfs)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.Ipfs,
             options: {
                 config: {
-                    apiUrl: envVars.ipfsApiUrl,
+                    apiUrl: envVars.ipfsApiUrl ?? "",
                     bearerToken: envVars.ipfsBearerToken
                 }
             }
         });
     }
-    if (core.Is.stringValue(envVars.awsS3AccessKeyId)) {
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.AwsS3)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.AwsS3,
             options: {
@@ -775,7 +813,7 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.azureStorageAccountKey)) {
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.AzureStorage)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.AzureStorage,
             options: {
@@ -789,7 +827,7 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (core.Is.stringValue(envVars.gcpStorageCredentials)) {
+    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.GcpStorage)) {
         coreConfig.types.blobStorageConnector.push({
             type: engineTypes.BlobStorageConnectorType.GcpStorage,
             options: {
@@ -803,12 +841,20 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
-    if (core.Is.stringValue(defaultStorageConnectorType)) {
+    if (core.Is.arrayValue(blobStorageConnectorTypes)) {
+        const defaultStorageConnectorType = envVars.blobStorageConnectorDefault ?? blobStorageConnectorTypes[0];
         for (const config of coreConfig.types.blobStorageConnector) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
             }
+            // If this blob storage connector is the one to use for public access
+            // then add it as a feature
+            if (core.Is.stringValue(envVars.blobStorageConnectorPublic) &&
+                config.type === envVars.blobStorageConnectorPublic) {
+                config.features ??= [];
+                config.features.push("public");
+                break;
+            }
         }
     }
     if (coreConfig.types.blobStorageConnector.length > 0) {
@@ -818,7 +864,7 @@ function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? envVars.blobStorageEncryptionKey
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -1313,51 +1359,168 @@ function configureDocumentManagement(coreConfig, envVars) {
     }
 }
 /**
- * Configures the federated catalogue.
+ * Configures the rights management.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureFederatedCatalogue(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent)) {
-        coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: engineTypes.FederatedCatalogueComponentType.Service,
+function configureRightsManagement(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+        coreConfig.types.rightsManagementPapComponent ??= [];
+        coreConfig.types.rightsManagementPapComponent.push({
+            type: engineTypes.RightsManagementPapComponentType.Service
+        });
+        coreConfig.types.rightsManagementPmpComponent ??= [];
+        coreConfig.types.rightsManagementPmpComponent.push({
+            type: engineTypes.RightsManagementPmpComponentType.Service
+        });
+        coreConfig.types.rightsManagementPipComponent ??= [];
+        coreConfig.types.rightsManagementPipComponent.push({
+            type: engineTypes.RightsManagementPipComponentType.Service,
+            options: {
+                informationModulesConfig: core.Is.arrayValue(envVars.rightsManagementInformationSources)
+                    ? envVars.rightsManagementInformationSources
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPxpComponent ??= [];
+        coreConfig.types.rightsManagementPxpComponent.push({
+            type: engineTypes.RightsManagementPxpComponentType.Service,
+            options: {
+                actionModulesConfig: core.Is.arrayValue(envVars.rightsManagementExecutionActions)
+                    ? envVars.rightsManagementExecutionActions
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPdpComponent ??= [];
+        coreConfig.types.rightsManagementPdpComponent.push({
+            type: engineTypes.RightsManagementPdpComponentType.Service
+        });
+        coreConfig.types.rightsManagementPepComponent ??= [];
+        coreConfig.types.rightsManagementPepComponent.push({
+            type: engineTypes.RightsManagementPepComponentType.Service,
+            options: {
+                processorModulesConfig: core.Is.arrayValue(envVars.rightsManagementEnforcementProcessors)
+                    ? envVars.rightsManagementEnforcementProcessors
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPnpComponent ??= [];
+        coreConfig.types.rightsManagementPnpComponent.push({
+            type: engineTypes.RightsManagementPnpComponentType.Service,
+            options: {
+                negotiatorModulesConfig: core.Is.arrayValue(envVars.rightsManagementNegotiators)
+                    ? envVars.rightsManagementNegotiators
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPnapComponent ??= [];
+        coreConfig.types.rightsManagementPnapComponent.push({
+            type: engineTypes.RightsManagementPnapComponentType.Service
+        });
+        coreConfig.types.rightsManagementPnrpComponent ??= [];
+        coreConfig.types.rightsManagementPnrpComponent.push({
+            type: engineTypes.RightsManagementPnrpComponentType.Service,
             options: {
                 config: {
-                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                    negotiationMethodId: envVars.rightsManagementNegotiationMethodId ?? "",
+                    negotiationComponentCreator: async (url) => new rightsManagementRestClient.PolicyNegotiationPointClient({ endpoint: url })
                 }
             }
         });
     }
 }
 /**
- * Configures the rights management.
+ * Configures the task scheduler.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureRightsManagement(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
-        coreConfig.types.rightsManagementPapComponent ??= [];
-        coreConfig.types.rightsManagementPapComponent.push({
-            type: engineTypes.RightsManagementPapComponentType.Service
+function configureTaskScheduler(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
+        coreConfig.types.taskSchedulerComponent ??= [];
+        coreConfig.types.taskSchedulerComponent.push({
+            type: engineTypes.TaskSchedulerComponentType.Service
         });
-        coreConfig.types.rightsManagementComponent ??= [];
-        coreConfig.types.rightsManagementComponent.push({
-            type: engineTypes.RightsManagementComponentType.Service
+    }
+}
+/**
+ * Configures the synchronised storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureSynchronisedStorage(coreConfig, envVars) {
+    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
+        // Check if the config provides a custom verifiable storage key id
+        let verifiableStorageKeyId = core.Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
+        if (!core.Is.stringValue(verifiableStorageKeyId)) {
+            // No custom key so default to the network setting
+            verifiableStorageKeyId = envVars.iotaNetwork;
+        }
+        coreConfig.types.synchronisedStorageComponent ??= [];
+        coreConfig.types.synchronisedStorageComponent.push({
+            type: engineTypes.SynchronisedStorageComponentType.Service,
+            options: {
+                config: {
+                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
+                    synchronisedStorageMethodId: envVars.synchronisedStorageVerificationMethodId,
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId,
+                    entityUpdateIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
+                    consolidationIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
+                    consolidationBatchSize: core.Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
+                    maxConsolidations: core.Coerce.number(envVars.synchronisedStorageMaxConsolidations)
+                }
+            }
         });
+        // If there is a trusted url set, we need to add a client
+        // and give it a feature of trusted so that when the synchronised
+        // storage is created it can pickup the correct component
+        if (core.Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
+            coreConfig.types.synchronisedStorageComponent.push({
+                type: engineTypes.SynchronisedStorageComponentType.RestClient,
+                options: {
+                    endpoint: envVars.synchronisedStorageTrustedUrl
+                },
+                features: ["trusted"]
+            });
+        }
     }
 }
 /**
- * Configures the task scheduler.
+ * Configures the federated catalogue.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureTaskScheduler(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
-        coreConfig.types.taskSchedulerComponent ??= [];
-        coreConfig.types.taskSchedulerComponent.push({
-            type: engineTypes.TaskSchedulerComponentType.Default
+function configureFederatedCatalogue(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
+        coreConfig.types.federatedCatalogueComponent ??= [];
+        coreConfig.types.federatedCatalogueComponent.push({
+            type: engineTypes.FederatedCatalogueComponentType.Service,
+            options: {
+                config: {
+                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
+                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the data space connector.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureDataSpaceConnector(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
+        coreConfig.types.dataSpaceConnectorComponent ??= [];
+        coreConfig.types.dataSpaceConnectorComponent.push({
+            type: engineTypes.DataSpaceConnectorComponentType.Service,
+            options: {
+                config: {
+                    dataSpaceConnectorAppDescriptors: core.Is.arrayValue(envVars.dataSpaceConnectorApps)
+                        ? envVars.dataSpaceConnectorApps
+                        : undefined
+                }
+            }
         });
     }
 }
@@ -1400,9 +1563,10 @@ function configureDlt(coreConfig, envVars) {
  * @param coreEngineConfig The core engine config.
  * @param serverInfo The server information.
  * @param openApiSpecPath The path to the open api spec.
+ * @param favIconPath The path to the favicon.
  * @returns The the config for the core and the server.
  */
-function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath) {
+function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath, favIconPath) {
     envVars.authSigningKeyId ??= "auth-signing";
     const webServerOptions = {
         port: core.Coerce.number(envVars.port),
@@ -1429,7 +1593,8 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
                     options: {
                         config: {
                             serverInfo,
-                            openApiSpecPath
+                            openApiSpecPath,
+                            favIconPath
                         }
                     }
                 }
@@ -1546,16 +1711,19 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
  * @returns The engine server.
  */
 async function start(nodeOptions, engineServerConfig, envVars) {
-    envVars.storageFileRoot ??= "";
-    if ((envVars.entityStorageConnectorType === engineTypes.EntityStorageConnectorType.File ||
-        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.File ||
+    const entityStorageConnectorType = envVars.entityStorageConnectorType?.split(",") ?? [];
+    const blobStorageConnectorType = envVars.blobStorageConnectorType?.split(",") ?? [];
+    // If the blob storage or entity storage is configured with file connectors
+    // then we need to make sure the storageFileRoot is set
+    if ((entityStorageConnectorType.includes(engineTypes.EntityStorageConnectorType.File) ||
+        blobStorageConnectorType.includes(engineTypes.BlobStorageConnectorType.File) ||
         core.Is.empty(nodeOptions?.stateStorage)) &&
         !core.Is.stringValue(envVars.storageFileRoot)) {
         throw new core.GeneralError("node", "storageFileRootNotSet", {
             storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
         });
     }
-    // Create the engine instance using file state storage and custom bootstrap.
+    // Create the engine instance using file state storage unless one is configured in options
     const engine$1 = new engine.Engine({
         config: engineServerConfig,
         stateStorage: nodeOptions?.stateStorage ?? new engineCore.FileStateStorage(envVars.stateFilename ?? ""),
@@ -1599,7 +1767,7 @@ async function run(nodeOptions) {
         nodeOptions ??= {};
         const serverInfo = {
             name: nodeOptions?.serverName ?? "TWIN Node Server",
-            version: nodeOptions?.serverVersion ?? "0.0.2-next.1" // x-release-please-version
+            version: nodeOptions?.serverVersion ?? "0.0.2-next.10" // x-release-please-version
         };
         console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
         if (!core.Is.stringValue(nodeOptions?.executionDirectory)) {
@@ -1612,15 +1780,24 @@ async function run(nodeOptions) {
         console.info("Locales Directory:", nodeOptions.localesDirectory);
         await initialiseLocales(nodeOptions.localesDirectory);
         if (core.Is.empty(nodeOptions?.openApiSpecFile)) {
-            const specFile = path.resolve(path.join(nodeOptions.executionDirectory, "docs", "open-api", "spec.json"));
+            const specFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "docs", "open-api", "spec.json"));
             console.info("Default OpenAPI Spec File:", specFile);
             if (await fileExists(specFile)) {
                 nodeOptions ??= {};
                 nodeOptions.openApiSpecFile = specFile;
             }
         }
+        if (core.Is.empty(nodeOptions?.favIconFile)) {
+            const favIconFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "static", "favicon.png"));
+            console.info("Default Favicon File:", favIconFile);
+            if (await fileExists(favIconFile)) {
+                nodeOptions ??= {};
+                nodeOptions.favIconFile = favIconFile;
+            }
+        }
         nodeOptions.envPrefix ??= "TWIN_NODE_";
         console.info("Environment Prefix:", nodeOptions.envPrefix);
+        overrideModuleImport(nodeOptions.executionDirectory ?? "");
         const { engineServerConfig, nodeEnvVars: envVars } = await buildConfiguration(process.env, nodeOptions, serverInfo);
         console.info();
         const startResult = await start(nodeOptions, engineServerConfig, envVars);
@@ -1657,7 +1834,8 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     if (core.Is.arrayValue(options?.envFilenames)) {
         const output = dotenv__namespace.config({
-            path: options?.envFilenames
+            path: options?.envFilenames,
+            quiet: true
         });
         // We don't want to throw an error if the default environment file is not found.
         // Only if we have custom environment files.
@@ -1672,12 +1850,18 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     // Expand any environment variables that use the @file: syntax
     const keys = Object.keys(envVars);
     for (const key of keys) {
-        if (core.Is.stringValue(envVars[key]) && envVars[key].startsWith("@file:")) {
+        if (core.Is.stringValue(envVars[key]) &&
+            (envVars[key].startsWith("@text:") || envVars[key].startsWith("@json:"))) {
             const filePath = envVars[key].slice(6).trim();
             const embeddedFile = path.resolve(path.join(options.executionDirectory ?? "", filePath));
-            console.info(`Expanding Environment Variable: ${key} from file: ${embeddedFile}`);
-            const fileContent = await loadJsonFile(embeddedFile);
-            envVars[key] = fileContent;
+            if (envVars[key].startsWith("@text:")) {
+                console.info(`Expanding Environment Variable: ${key} from text file: ${embeddedFile}`);
+                envVars[key] = await loadTextFile(embeddedFile);
+            }
+            else if (envVars[key].startsWith("@json:")) {
+                console.info(`Expanding Environment Variable: ${key} from JSON file: ${embeddedFile}`);
+                envVars[key] = await loadJsonFile(embeddedFile);
+            }
         }
     }
     // Extend the environment variables with any additional custom configuration.
@@ -1687,7 +1871,7 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     // Build the engine configuration from the environment variables.
     const coreConfig = buildEngineConfiguration(envVars);
-    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile);
+    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile, options?.favIconFile);
     // Merge any custom configuration provided in the options.
     if (core.Is.arrayValue(options?.configFilenames)) {
         for (const configFile of options.configFilenames) {
@@ -1708,15 +1892,49 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     return { engineServerConfig, nodeEnvVars: envVars };
 }
+/**
+ * Override module imports to use local files where possible.
+ * @param executionDirectory The execution directory for resolving local module paths.
+ */
+function overrideModuleImport(executionDirectory) {
+    modules.ModuleHelper.overrideImport(async (moduleName) => {
+        // If the module path for example when dynamically loading
+        // modules looks like a local file then we try to resolve
+        // using the local file system
+        const isLocal = modules.ModuleHelper.isLocalModule(moduleName);
+        if (isLocal) {
+            // See if we can just resolve the filename locally
+            let localFilename = path.resolve(moduleName);
+            let exists = await fileExists(localFilename);
+            if (!exists) {
+                // Doesn't exist in the current directory, try the execution directory
+                localFilename = path.resolve(executionDirectory, moduleName);
+                exists = await fileExists(localFilename);
+            }
+            if (exists) {
+                // If the module exists then we can load it, otherwise
+                // we fallback to regular handling to see if that can import it
+                return {
+                    module: await import(process.platform === "win32" ? `file://${localFilename}` : localFilename),
+                    useDefault: false
+                };
+            }
+        }
+        // The filename doesn't look like a local module, so just use default handling
+        return {
+            useDefault: true
+        };
+    });
+}
 
 exports.NodeFeatures = NodeFeatures;
 exports.bootstrap = bootstrap;
-exports.bootstrapAttestationMethod = bootstrapAttestationMethod;
 exports.bootstrapAuth = bootstrapAuth;
 exports.bootstrapBlobEncryption = bootstrapBlobEncryption;
 exports.bootstrapImmutableProofMethod = bootstrapImmutableProofMethod;
 exports.bootstrapNodeIdentity = bootstrapNodeIdentity;
 exports.bootstrapNodeUser = bootstrapNodeUser;
+exports.bootstrapSynchronisedStorage = bootstrapSynchronisedStorage;
 exports.buildConfiguration = buildConfiguration;
 exports.buildEngineConfiguration = buildEngineConfiguration;
 exports.buildEngineServerConfiguration = buildEngineServerConfiguration;
@@ -1725,5 +1943,7 @@ exports.getExecutionDirectory = getExecutionDirectory;
 exports.getFeatures = getFeatures;
 exports.initialiseLocales = initialiseLocales;
 exports.loadJsonFile = loadJsonFile;
+exports.loadTextFile = loadTextFile;
+exports.overrideModuleImport = overrideModuleImport;
 exports.run = run;
 exports.start = start;