@twin.org/engine-core 0.0.2-next.9 → 0.0.3-next.2

package/dist/{esm/index.mjs → es/engineCore.js}

@@ -1,91 +1,42 @@
-import { isMainThread } from 'node:worker_threads';
-import { I18n, StringHelper, Is, BaseError, GeneralError, ErrorHelper, Guards, ComponentFactory } from '@twin.org/core';
-import { EntitySchemaFactory } from '@twin.org/entity';
-import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
-import { SilentLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
-import { LoggingService } from '@twin.org/logging-service';
-import { ModuleHelper } from '@twin.org/modules';
-import { readFile, mkdir, writeFile, stat } from 'node:fs/promises';
-import path from 'node:path';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in memory.
- */
-class MemoryStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "MemoryStateStorage";
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * The state object.
-     * @internal
-     */
-    _engineState;
-    /**
-     * Create a new instance of MemoryStateStorage.
-     * @param readonlyMode Whether the file is in read-only mode.
-     * @param state The initial state.
-     */
-    constructor(readonlyMode = false, state) {
-        this._readonlyMode = readonlyMode;
-        this._engineState = state;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-            filename: this._engineState
-        }));
-        return this._engineState;
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`));
-            this._engineState = state;
-        }
-    }
-}
-
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+import { isMainThread } from "node:worker_threads";
+import { ContextIdStore } from "@twin.org/context";
+import { BaseError, ComponentFactory, ErrorHelper, GeneralError, Guards, I18n, Is } from "@twin.org/core";
+import { EntitySchemaFactory } from "@twin.org/entity";
+import { ConsoleLoggingConnector } from "@twin.org/logging-connector-console";
+import { LoggingConnectorFactory, SilentLoggingConnector } from "@twin.org/logging-models";
+import { LoggingService } from "@twin.org/logging-service";
+import { ModuleHelper } from "@twin.org/modules";
+import { MemoryStateStorage } from "./storage/memoryStateStorage.js";
 /**
  * Core for the engine.
  */
-class EngineCore {
+export class EngineCore {
     /**
-     * Name for the engine logger.
+     * Name for the engine logger component, used for direct console logging.
      */
-    static LOGGER_TYPE_NAME = "engine";
+    static LOGGING_COMPONENT_TYPE_NAME = "engine-logging-service";
     /**
-     * Runtime name for the class in camel case.
-     * @internal
+     * Name for the engine logger connector, used for direct console logging.
      */
-    static _CLASS_NAME_CAMEL_CASE = StringHelper.camelCase("EngineCore");
+    static LOGGING_CONNECTOR_TYPE_NAME = "engine-logging-connector";
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "EngineCore";
+    static CLASS_NAME = "EngineCore";
     /**
      * The core context.
      */
     _context;
+    /**
+     * The context ID keys.
+     */
+    _contextIdKeys;
+    /**
+     * The context IDs.
+     */
+    _contextIds;
     /**
      * The state storage interface.
      * @internal
@@ -101,11 +52,6 @@ class EngineCore {
      * @internal
      */
     _skipBootstrap;
-    /**
-     * The logger type name to use.
-     * @internal
-     */
-    _loggerTypeName;
     /**
      * The type initialisers.
      * @internal
@@ -144,8 +90,8 @@ class EngineCore {
         this._skipBootstrap = options.skipBootstrap ?? false;
         this._populateTypeInitialisers = options.populateTypeInitialisers;
         this._customBootstrap = options.customBootstrap;
-        this._loggerTypeName = options.loggerTypeName ?? EngineCore.LOGGER_TYPE_NAME;
         this._typeInitialisers = [];
+        this._contextIdKeys = [];
         this._context = {
             config: options.config,
             registeredInstances: {},
@@ -163,20 +109,67 @@ class EngineCore {
     /**
      * Add a type initialiser.
      * @param type The type to add the initialiser for.
-     * @param typeConfig The type config.
      * @param module The name of the module which contains the initialiser method.
      * @param method The name of the method to call.
      */
-    addTypeInitialiser(type, typeConfig, module, method) {
-        if (!Is.empty(typeConfig)) {
+    addTypeInitialiser(type, module, method) {
+        Guards.stringValue(EngineCore.CLASS_NAME, "type", type);
+        Guards.stringValue(EngineCore.CLASS_NAME, "module", module);
+        Guards.stringValue(EngineCore.CLASS_NAME, "method", method);
+        const currentIndex = this._typeInitialisers.findIndex(t => t.type === type);
+        if (currentIndex >= 0) {
+            this._typeInitialisers[currentIndex].module = module;
+            this._typeInitialisers[currentIndex].method = method;
+        }
+        else {
             this._typeInitialisers.push({
                 type,
-                typeConfig,
                 module,
                 method
             });
         }
     }
+    /**
+     * Get the type config for a specific type.
+     * @param type The type to get the config for.
+     * @returns The type config or undefined if not found.
+     */
+    getTypeConfig(type) {
+        Guards.stringValue(EngineCore.CLASS_NAME, "type", type);
+        return this._context.config.types?.[type];
+    }
+    /**
+     * Add a context ID key to the engine.
+     * @param key The context ID key.
+     */
+    addContextIdKey(key) {
+        if (!this._contextIdKeys.includes(key)) {
+            this._contextIdKeys.push(key);
+        }
+    }
+    /**
+     * Get the context ID keys for the engine.
+     * @returns The context IDs keys.
+     */
+    getContextIdKeys() {
+        return this._contextIdKeys;
+    }
+    /**
+     * Add a context ID to the engine.
+     * @param key The context ID key.
+     * @param value The context ID value.
+     */
+    addContextId(key, value) {
+        this._contextIds ??= {};
+        this._contextIds[key] = value;
+    }
+    /**
+     * Get the context IDs for the engine.
+     * @returns The context IDs or undefined if none are set.
+     */
+    getContextIds() {
+        return this._contextIds;
+    }
     /**
      * Start the engine core.
      * @returns True if the start was successful.
@@ -186,41 +179,60 @@ class EngineCore {
             return false;
         }
         this.setupEngineLogger();
-        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.starting`));
+        await this.logInfo(I18n.formatMessage(`${"engineCore"}.starting`));
         if (this._context.config.debug) {
-            this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.debuggingEnabled`));
+            await this.logInfo(I18n.formatMessage(`${"engineCore"}.debuggingEnabled`));
         }
         let canContinue;
         try {
             canContinue = await this.stateLoad();
             if (canContinue) {
-                for (const { type, typeConfig, module, method } of this._typeInitialisers) {
-                    await this.initialiseTypeConfig(type, typeConfig, module, method);
+                for (const { type, module, method } of this._typeInitialisers) {
+                    await this.initialiseTypeConfig(type, module, method);
                 }
                 await this.bootstrap();
-                this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStarting`));
-                for (const instance of this._context.componentInstances) {
-                    if (Is.function(instance.component.start)) {
-                        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentStarting`, {
-                            element: instance.instanceType
-                        }));
-                        await instance.component.start(this._context.state.nodeIdentity, this._loggerTypeName);
+                await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStarting`));
+                await ContextIdStore.run(this._contextIds ?? {}, async () => {
+                    for (const instance of this._context.componentInstances) {
+                        if (!instance.started) {
+                            const startMethod = instance.component.start?.bind(instance.component);
+                            if (Is.function(startMethod)) {
+                                await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentStarting`, {
+                                    className: instance.component.className(),
+                                    instanceType: instance.instanceType
+                                }));
+                                try {
+                                    await startMethod(EngineCore.LOGGING_COMPONENT_TYPE_NAME);
+                                    instance.started = true;
+                                }
+                                catch (err) {
+                                    await this.logError(new GeneralError(EngineCore.CLASS_NAME, "componentStartFailed", {
+                                        className: instance.component.className(),
+                                        instanceType: instance.instanceType
+                                    }, BaseError.fromError(err)));
+                                    throw err;
+                                }
+                            }
+                        }
                     }
-                }
-                this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsComplete`));
+                });
+                await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsComplete`));
             }
-            this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.started`));
+            await this.logInfo(I18n.formatMessage(`${"engineCore"}.started`));
             this._isStarted = true;
         }
         catch (err) {
             canContinue = false;
-            this.logError(BaseError.fromError(err));
+            await this.logError(BaseError.fromError(err));
         }
         finally {
             if (!(await this.stateSave())) {
                 canContinue = false;
             }
         }
+        if (!canContinue) {
+            await this.stop();
+        }
         return canContinue;
     }
     /**
@@ -228,26 +240,34 @@ class EngineCore {
      * @returns Nothing.
      */
     async stop() {
-        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.stopping`));
-        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStopping`));
-        for (const instance of this._context.componentInstances) {
-            if (Is.function(instance.component.stop)) {
-                this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentStopping`, {
-                    element: instance.instanceType
-                }));
-                try {
-                    await instance.component.stop(this._context.state.nodeIdentity, this._loggerTypeName);
-                }
-                catch (err) {
-                    this.logError(new GeneralError(EngineCore._CLASS_NAME, "componentStopFailed", {
-                        component: instance.instanceType
-                    }, BaseError.fromError(err)));
+        await this.logInfo(I18n.formatMessage(`${"engineCore"}.stopping`));
+        await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStopping`));
+        await ContextIdStore.run(this._contextIds ?? {}, async () => {
+            for (const instance of this._context.componentInstances) {
+                if (instance.started) {
+                    instance.started = false;
+                    const stopMethod = instance.component.stop?.bind(instance.component);
+                    if (Is.function(stopMethod)) {
+                        await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentStopping`, {
+                            className: instance.component.className(),
+                            instanceType: instance.instanceType
+                        }));
+                        try {
+                            await stopMethod(EngineCore.LOGGING_COMPONENT_TYPE_NAME);
+                        }
+                        catch (err) {
+                            await this.logError(new GeneralError(EngineCore.CLASS_NAME, "componentStopFailed", {
+                                className: instance.component.className(),
+                                instanceType: instance.instanceType
+                            }, BaseError.fromError(err)));
+                        }
+                    }
                 }
             }
-        }
+        });
         await this.stateSave();
-        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStopped`));
-        this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.stopped`));
+        await this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStopped`));
+        await this.logInfo(I18n.formatMessage(`${"engineCore"}.stopped`));
     }
     /**
      * Is the engine started.
@@ -274,9 +294,9 @@ class EngineCore {
      * Log info.
      * @param message The message to log.
      */
-    logInfo(message) {
-        this._engineLoggingComponent?.log({
-            source: EngineCore._CLASS_NAME,
+    async logInfo(message) {
+        await this._engineLoggingComponent?.log({
+            source: EngineCore.CLASS_NAME,
             level: "info",
             message
         });
@@ -285,7 +305,7 @@ class EngineCore {
      * Log error.
      * @param error The error to log.
      */
-    logError(error) {
+    async logError(error) {
         const formattedErrors = ErrorHelper.localizeErrors(error);
         for (const formattedError of formattedErrors) {
             let message = Is.stringValue(formattedError.source)
@@ -294,8 +314,8 @@ class EngineCore {
             if (this._context.config.debug && Is.stringValue(formattedError.stack)) {
                 message += `\n${formattedError.stack}`;
             }
-            this._engineLoggingComponent?.log({
-                source: EngineCore._CLASS_NAME,
+            await this._engineLoggingComponent?.log({
+                source: EngineCore.CLASS_NAME,
                 level: "error",
                 message
             });
@@ -330,10 +350,10 @@ class EngineCore {
      * @throws If a matching instance was not found.
      */
     getRegisteredInstanceType(componentConnectorType, features) {
-        Guards.stringValue(EngineCore._CLASS_NAME, "componentConnectorType", componentConnectorType);
+        Guards.stringValue(EngineCore.CLASS_NAME, "componentConnectorType", componentConnectorType);
         const registeredType = this.getRegisteredInstanceTypeOptional(componentConnectorType, features);
         if (!Is.stringValue(registeredType)) {
-            throw new GeneralError(EngineCore._CLASS_NAME, "instanceTypeNotFound", {
+            throw new GeneralError(EngineCore.CLASS_NAME, "instanceTypeNotFound", {
                 type: componentConnectorType,
                 features: (features ?? ["default"]).join(",")
             });
@@ -354,7 +374,12 @@ class EngineCore {
                 registeredType = registeredTypes.find(t => t.features?.every(f => features.includes(f)))?.type;
             }
             else {
-                registeredType = registeredTypes[0]?.type;
+                // First look for the default entry
+                registeredType = registeredTypes.find(t => t.isDefault)?.type;
+                // Can't find a default so just use the first entry
+                if (!Is.stringValue(registeredType)) {
+                    registeredType = registeredTypes[0]?.type;
+                }
             }
         }
         return registeredType;
@@ -374,7 +399,7 @@ class EngineCore {
             state: this._context.state,
             typeInitialisers: this._typeInitialisers,
             entitySchemas,
-            loggerTypeName: this._loggerTypeName
+            contextIdKeys: this._contextIdKeys
         };
         return cloneData;
     }
@@ -384,11 +409,10 @@ class EngineCore {
      * @param silent Should the clone be silent.
      */
     populateClone(cloneData, silent) {
-        Guards.object(EngineCore._CLASS_NAME, "cloneData", cloneData);
-        Guards.object(EngineCore._CLASS_NAME, "cloneData.config", cloneData.config);
-        Guards.object(EngineCore._CLASS_NAME, "cloneData.state", cloneData.state);
-        Guards.array(EngineCore._CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
-        this._loggerTypeName = cloneData.loggerTypeName;
+        Guards.object(EngineCore.CLASS_NAME, "cloneData", cloneData);
+        Guards.object(EngineCore.CLASS_NAME, "cloneData.config", cloneData.config);
+        Guards.object(EngineCore.CLASS_NAME, "cloneData.state", cloneData.state);
+        Guards.array(EngineCore.CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
         this._skipBootstrap = true;
         this._isClone = true;
         if (silent ?? false) {
@@ -402,6 +426,7 @@ class EngineCore {
             stateDirty: false
         };
         this._typeInitialisers = cloneData.typeInitialisers;
+        this._contextIdKeys.push(...cloneData.contextIdKeys);
         for (const schemaName of Object.keys(cloneData.entitySchemas)) {
             EntitySchemaFactory.register(schemaName, () => cloneData.entitySchemas[schemaName]);
         }
@@ -414,25 +439,36 @@ class EngineCore {
      * @param instanceMethod The function to initialise the instance.
      * @internal
      */
-    async initialiseTypeConfig(typeKey, typeConfig, module, method) {
+    async initialiseTypeConfig(typeKey, module, method) {
+        const typeConfig = this._context.config.types?.[typeKey];
         if (Is.arrayValue(typeConfig)) {
             const instanceMethod = await ModuleHelper.getModuleEntry(module, method);
             for (let i = 0; i < typeConfig.length; i++) {
-                const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
-                if (Is.stringValue(instanceType)) {
+                await this.logInfo(I18n.formatMessage("engineCore.configuring", {
+                    componentType: typeKey,
+                    configType: typeConfig[i].type
+                }));
+                const result = await instanceMethod(this, this._context, typeConfig[i]);
+                if (Is.stringValue(result.instanceType) && Is.object(result.component)) {
+                    const finalInstanceType = typeConfig[i].overrideInstanceType ?? result.instanceType;
+                    this._context.componentInstances.push({
+                        instanceType: finalInstanceType,
+                        component: result.component,
+                        started: false
+                    });
+                    result.factory?.register(finalInstanceType, () => result.component);
                     this._context.registeredInstances[typeKey] ??= [];
-                    if (typeConfig[i].isDefault ?? false) {
-                        this._context.registeredInstances[typeKey].unshift({
-                            type: instanceType,
-                            features: typeConfig[i].features
-                        });
-                    }
-                    else {
-                        this._context.registeredInstances[typeKey].push({
-                            type: instanceType,
-                            features: typeConfig[i].features
-                        });
-                    }
+                    this._context.registeredInstances[typeKey].push({
+                        type: finalInstanceType,
+                        isDefault: typeConfig[i].isDefault,
+                        features: typeConfig[i].features
+                    });
+                }
+                else {
+                    throw new GeneralError("engineCore", "componentUnknownType", {
+                        type: typeConfig[i].type,
+                        componentType: typeKey
+                    });
                 }
             }
         }
@@ -452,23 +488,24 @@ class EngineCore {
                 }
             });
         this._context.componentInstances.push({
-            instanceType: this._loggerTypeName,
-            component: engineLoggerConnector
+            instanceType: EngineCore.LOGGING_CONNECTOR_TYPE_NAME,
+            component: engineLoggerConnector,
+            started: false
         });
-        LoggingConnectorFactory.register(this._loggerTypeName, () => engineLoggerConnector);
+        LoggingConnectorFactory.register(EngineCore.LOGGING_CONNECTOR_TYPE_NAME, () => engineLoggerConnector);
         this._context.registeredInstances.loggingConnector = [
             {
-                type: this._loggerTypeName
+                type: EngineCore.LOGGING_CONNECTOR_TYPE_NAME
             }
         ];
         const engineLoggerComponent = new LoggingService({
-            loggingConnectorType: this._loggerTypeName
+            loggingConnectorType: EngineCore.LOGGING_CONNECTOR_TYPE_NAME
         });
         this._engineLoggingComponent = engineLoggerComponent;
-        ComponentFactory.register("logging-service", () => engineLoggerComponent);
+        ComponentFactory.register(EngineCore.LOGGING_COMPONENT_TYPE_NAME, () => engineLoggerComponent);
         this._context.registeredInstances.loggingComponent = [
             {
-                type: "logging-service"
+                type: EngineCore.LOGGING_COMPONENT_TYPE_NAME
             }
         ];
     }
@@ -485,7 +522,7 @@ class EngineCore {
                 return true;
             }
             catch (err) {
-                this.logError(BaseError.fromError(err));
+                await this.logError(BaseError.fromError(err));
                 return false;
             }
         }
@@ -504,7 +541,7 @@ class EngineCore {
                 return true;
             }
             catch (err) {
-                this.logError(BaseError.fromError(err));
+                await this.logError(BaseError.fromError(err));
             }
             return false;
         }
@@ -516,130 +553,32 @@ class EngineCore {
      */
     async bootstrap() {
         if (!this._skipBootstrap) {
-            this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapStarted`));
+            await this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapStarted`));
             // First bootstrap the components.
             for (const instance of this._context.componentInstances) {
-                if (Is.function(instance.component.bootstrap)) {
-                    const instanceName = this.getInstanceName(instance);
-                    this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapping`, {
-                        element: instanceName
+                const bootstrapMethod = instance.component.bootstrap?.bind(instance.component);
+                if (Is.function(bootstrapMethod)) {
+                    await this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapping`, {
+                        className: instance.component.className(),
+                        instanceType: instance.instanceType
                     }));
-                    const bootstrapSuccess = await instance.component.bootstrap(this._loggerTypeName);
+                    const bootstrapSuccess = await bootstrapMethod(EngineCore.LOGGING_COMPONENT_TYPE_NAME);
                     // If the bootstrap method failed then throw an error
                     if (!bootstrapSuccess) {
-                        throw new GeneralError(EngineCore._CLASS_NAME, "bootstrapFailed", {
-                            component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
+                        throw new GeneralError(EngineCore.CLASS_NAME, "bootstrapFailed", {
+                            className: instance.component.className(),
+                            instanceType: instance.instanceType
                         });
                     }
                 }
             }
             // Now perform any custom bootstrap operations
-            if (Is.function(this._customBootstrap)) {
-                await this._customBootstrap(this, this._context);
-            }
-            this.logInfo(I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapComplete`));
-        }
-    }
-    /**
-     * Get the instance name.
-     * @param instance The instance to get the name for.
-     * @param instance.instanceType The instance type.
-     * @param instance.component The component.
-     * @returns The instance name.
-     * @internal
-     */
-    getInstanceName(instance) {
-        return `${instance.component.CLASS_NAME}-${instance.instanceType}`;
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in a file.
- */
-class FileStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "FileStateStorage";
-    /**
-     * The filename to store the state.
-     * @internal
-     */
-    _filename;
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * Create a new instance of FileStateStorage.
-     * @param filename The filename to store the state.
-     * @param readonlyMode Whether the file is in read-only mode.
-     */
-    constructor(filename, readonlyMode = false) {
-        Guards.stringValue(this.CLASS_NAME, "filename", filename);
-        this._filename = filename;
-        this._readonlyMode = readonlyMode;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        try {
-            engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-                filename: this._filename
-            }));
-            if (await this.fileExists(this._filename)) {
-                const content = await readFile(this._filename, "utf8");
-                return JSON.parse(content.toString());
+            const customBootstrap = this._customBootstrap;
+            if (Is.function(customBootstrap)) {
+                await customBootstrap.call(this, this, this._context);
             }
-        }
-        catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "loadingError", { filename: this._filename }, BaseError.fromError(err));
-        }
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            try {
-                engineCore.logInfo(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
-                    filename: this._filename
-                }));
-                try {
-                    await mkdir(path.dirname(this._filename), { recursive: true });
-                }
-                catch { }
-                await writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
-            }
-            catch (err) {
-                throw new GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, BaseError.fromError(err));
-            }
-        }
-    }
-    /**
-     * Does the specified file exist.
-     * @param filename The filename to check for existence.
-     * @returns True if the file exists.
-     * @internal
-     */
-    async fileExists(filename) {
-        try {
-            const stats = await stat(filename);
-            return stats.isFile();
-        }
-        catch {
-            return false;
+            await this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapComplete`));
         }
     }
 }
-
-export { EngineCore, FileStateStorage, MemoryStateStorage };
+//# sourceMappingURL=engineCore.js.map