@twin.org/node-core 0.0.2-next.25 → 0.0.2-next.27

package/dist/types/models/ICacheMetadata.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Metadata for cached HTTPS extensions.
+ */
+export interface ICacheMetadata {
+    /**
+     * Timestamp when the file was downloaded.
+     */
+    downloadedAt: number;
+    /**
+     * Original URL of the cached file.
+     */
+    url: string;
+    /**
+     * Size of the cached file in bytes.
+     */
+    size: number;
+}

package/dist/types/models/IEngineEnvironmentVariables.d.ts

@@ -14,6 +14,18 @@ export interface IEngineEnvironmentVariables {
      * The name of the state file.
      */
     stateFilename?: string;
+    /**
+     * Is multi-tenant support enabled, defaults to false.
+     */
+    tenantEnabled?: string;
+    /**
+     * A tenant id to use as a default for the node.
+     */
+    tenantId?: string;
+    /**
+     * A tenant api key to use as a default for the node.
+     */
+    tenantApiKey?: string;
     /**
      * The type of the entity storage to create, comma separate for more than one connector.
      * values: file, memory, aws-dynamodb, azure-cosmosdb, gcp-firestoredb, scylladb, mysql, mongodb, postgresql
@@ -285,11 +297,6 @@ export interface IEngineEnvironmentVariables {
      * Are the messaging components enabled, defaults to false.
      */
     messagingEnabled?: string;
-    /**
-     * An initial set of templates for the messages.
-     * Use the @json: prefix to specify the path to the JSON file.
-     */
-    messagingTemplates?: string;
     /**
      * AWS SES region.
      */

package/dist/types/models/IEngineServerEnvironmentVariables.d.ts

@@ -1,4 +1,4 @@
-import type { IEngineEnvironmentVariables } from "./IEngineEnvironmentVariables";
+import type { IEngineEnvironmentVariables } from "./IEngineEnvironmentVariables.js";
 /**
  * The engine server environment variables.
  */

package/dist/types/models/IModuleProtocol.d.ts

@@ -0,0 +1,18 @@
+import type { ModuleProtocol } from "./moduleProtocol.js";
+/**
+ * The parsed module protocol information.
+ */
+export interface IModuleProtocol {
+    /**
+     * The protocol type.
+     */
+    protocol: ModuleProtocol;
+    /**
+     * The identifier after the protocol (or the original if no protocol).
+     */
+    identifier: string;
+    /**
+     * The original module string.
+     */
+    original: string;
+}

package/dist/types/models/INodeEngineState.d.ts

@@ -0,0 +1,22 @@
+import type { IEngineState } from "@twin.org/engine-models";
+/**
+ * The engine state for the node.
+ */
+export interface INodeEngineState extends IEngineState {
+    /**
+     * The identity for the node.
+     */
+    nodeId?: string;
+    /**
+     * The tenant id for the node.
+     */
+    nodeTenantId?: string;
+    /**
+     * The identity for the organization.
+     */
+    nodeOrganizationId?: string;
+    /**
+     * The identity for the admin user.
+     */
+    nodeAdminUserId?: string;
+}

package/dist/types/models/INodeEnvironmentVariables.d.ts

@@ -1,28 +1,69 @@
-import type { IEngineServerEnvironmentVariables } from "./IEngineServerEnvironmentVariables";
+import type { IEngineServerEnvironmentVariables } from "./IEngineServerEnvironmentVariables.js";
 /**
  * The environment variables for the node.
  */
 export interface INodeEnvironmentVariables extends IEngineServerEnvironmentVariables {
     /**
      * The features that are enabled on the node.
-     * @default [NodeFeatures.NodeIdentity]
+     * @default []
      */
     features?: string;
     /**
      * The identity of the node which, if empty and node-identity feature is enabled it will be generated.
      */
-    identity?: string;
+    nodeIdentity?: string;
     /**
      * The mnemonic for the identity, if empty and node-identity feature is enabled it will be randomly generated.
      */
-    mnemonic?: string;
+    nodeMnemonic?: string;
     /**
-     * If the node-user feature is enabled, this will be the name of the user.
+     * If the node-admin-user feature is enabled, this will be the organization of the user, if one is not provided it will be generated
+     */
+    organizationIdentity?: string;
+    /**
+     * The mnemonic for the organization, if empty and node-admin-user feature is enabled it will be randomly generated.
+     */
+    organizationMnemonic?: string;
+    /**
+     * If the node-admin-user feature is enabled, this will be the identity of the user, if one is not provided it will be generated
+     */
+    adminUserIdentity?: string;
+    /**
+     * The mnemonic for the admin user, if empty and node-admin-user feature is enabled it will be randomly generated.
+     */
+    adminUserMnemonic?: string;
+    /**
+     * If the node-admin-user feature is enabled, this will be the name of the user.
      * @default admin@node
      */
-    username?: string;
+    adminUserName?: string;
+    /**
+     * If the node-admin-user feature is enabled, this will be the password of the user, if empty it will be randomly generated.
+     */
+    adminUserPassword?: string;
+    /**
+     * Maximum size in MB for HTTPS extensions downloads.
+     * @default 10
+     */
+    extensionsMaxSizeMb?: number;
+    /**
+     * Whether to clear the extensions cache on startup.
+     * @default false
+     */
+    extensionsClearCache?: boolean;
+    /**
+     * Custom directory for extensions cache storage.
+     * @default ".tmp"
+     */
+    extensionsCacheDirectory?: string;
+    /**
+     * TTL in hours for HTTPS extensions cache.
+     * @default 24
+     */
+    extensionsCacheTtlHours?: number;
     /**
-     * If the node-user feature is enabled, this will be the password of the user, if empty it will be randomly generated.
+     * Force refresh of all cached extensions.
+     * @default false
      */
-    password?: string;
+    extensionsForceRefresh?: boolean;
 }

package/dist/types/models/INodeOptions.d.ts

@@ -1,7 +1,7 @@
 import type { IEngineCore, IEngineServer, IEngineStateStorage } from "@twin.org/engine-models";
 import type { IEngineConfig } from "@twin.org/engine-types";
-import type { INodeEngineConfig } from "./INodeEngineConfig";
-import type { INodeEnvironmentVariables } from "./INodeEnvironmentVariables";
+import type { INodeEngineConfig } from "./INodeEngineConfig.js";
+import type { INodeEnvironmentVariables } from "./INodeEnvironmentVariables.js";
 /**
  * The options when running the node.
  */
@@ -15,12 +15,18 @@ export interface INodeOptions {
      * The version of the server, defaults to the current version.
      */
     serverVersion?: string;
+    /**
+     * Additional environment variables to set.
+     */
+    envVars?: {
+        [key: string]: string;
+    };
     /**
      * Additional environment variable filenames to load, defaults to .env.
      */
     envFilenames?: string[];
     /**
-     * The prefix for environment variables, defaults to "TWIN_NODE_".
+     * The prefix for environment variables, defaults to "TWIN_".
      */
     envPrefix?: string;
     /**
@@ -71,4 +77,8 @@ export interface INodeOptions {
      * If not provided, a default file-based state storage will be used.
      */
     stateStorage?: IEngineStateStorage;
+    /**
+     * Disables process.exit calls on fatal errors and throws instead.
+     */
+    disableProcessExitOnFailure?: boolean;
 }

package/dist/types/models/IProtocolHandlerResult.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The result from a protocol handler.
+ */
+export interface IProtocolHandlerResult {
+    /**
+     * The resolved path to the module file.
+     */
+    resolvedPath: string;
+    /**
+     * Whether the module was cached.
+     */
+    cached: boolean;
+}

package/dist/types/models/moduleProtocol.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The protocol types for modules.
+ */
+export declare const ModuleProtocol: {
+    /**
+     * Local module (starts with . or / or file://).
+     */
+    readonly Local: "local";
+    /**
+     * NPM package (starts with npm:).
+     */
+    readonly Npm: "npm";
+    /**
+     * HTTPS URL (starts with https://).
+     */
+    readonly Https: "https";
+    /**
+     * HTTP URL (starts with http://).
+     */
+    readonly Http: "http";
+    /**
+     * Default/standard module resolution.
+     */
+    readonly Default: "default";
+};
+/**
+ * The protocol type for a module.
+ */
+export type ModuleProtocol = (typeof ModuleProtocol)[keyof typeof ModuleProtocol];

package/dist/types/models/nodeExtensionMethods.d.ts

@@ -1,6 +1,6 @@
 import type { IEngineCore, IEngineServer } from "@twin.org/engine-models";
-import type { INodeEngineConfig } from "./INodeEngineConfig";
-import type { INodeEnvironmentVariables } from "./INodeEnvironmentVariables";
+import type { INodeEngineConfig } from "./INodeEngineConfig.js";
+import type { INodeEnvironmentVariables } from "./INodeEnvironmentVariables.js";
 /**
  * The type for the initialise method of an extension module.
  * @param envVars The environment variables for the node.

package/dist/types/models/nodeFeatures.d.ts

@@ -3,15 +3,15 @@
  */
 export declare const NodeFeatures: {
     /**
-     * NodeIdentity - generates an identity for the node if not provided in config.
+     * NodeId - generates an identity for the node if not provided in config.
      */
-    readonly NodeIdentity: "node-identity";
+    readonly NodeId: "node-identity";
     /**
-     * NodeUser - generates a user for the node if not provided in config.
+     * NodeAdminUser - generates an admin user for the node if not provided in config.
      */
-    readonly NodeUser: "node-user";
+    readonly NodeAdminUser: "node-admin-user";
     /**
-     * NodeWallet - generates a wallet for the node and funds it when there is a faucet available.
+     * NodeWallet - generates wallets for any identities that need them.
      */
     readonly NodeWallet: "node-wallet";
 };

package/dist/types/node.d.ts

@@ -1,13 +1,21 @@
 import type { IServerInfo } from "@twin.org/api-models";
-import type { INodeEngineConfig } from "./models/INodeEngineConfig";
-import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables";
-import type { INodeOptions } from "./models/INodeOptions";
+import type { Engine } from "@twin.org/engine";
+import type { EngineServer } from "@twin.org/engine-server";
+import type { IEngineServerConfig } from "@twin.org/engine-server-types";
+import type { INodeEngineConfig } from "./models/INodeEngineConfig.js";
+import type { INodeEngineState } from "./models/INodeEngineState.js";
+import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables.js";
+import type { INodeOptions } from "./models/INodeOptions.js";
 /**
  * Run the TWIN Node server.
  * @param nodeOptions Optional configuration options for running the server.
- * @returns A promise that resolves when the server is started.
+ * @returns A promise that resolves when the server is started containing a shutdown method.
  */
-export declare function run(nodeOptions?: INodeOptions): Promise<void>;
+export declare function run(nodeOptions?: INodeOptions): Promise<{
+    engine: Engine<IEngineServerConfig, INodeEngineState>;
+    server: EngineServer;
+    shutdown: () => Promise<void>;
+} | undefined>;
 /**
  * Build the configuration for the TWIN Node server.
  * @param processEnv The environment variables from the process.
@@ -23,9 +31,11 @@ export declare function buildConfiguration(processEnv: {
         [id: string]: string | unknown;
     };
     nodeEngineConfig: INodeEngineConfig;
+    contextIdKeys: string[];
 }>;
 /**
- * Override module imports to use local files where possible.
+ * Override module imports to support protocol-based loading (npm:, https:) and local files.
  * @param executionDirectory The execution directory for resolving local module paths.
+ * @param envVars The environment variables containing extension configuration (optional, uses defaults if not provided).
  */
-export declare function overrideModuleImport(executionDirectory: string): void;
+export declare function overrideModuleImport(executionDirectory: string, envVars?: INodeEnvironmentVariables): void;

package/dist/types/server.d.ts

@@ -1,19 +1,20 @@
 import { Engine } from "@twin.org/engine";
-import { type IEngineState } from "@twin.org/engine-models";
 import { EngineServer } from "@twin.org/engine-server";
 import type { IEngineServerConfig } from "@twin.org/engine-server-types";
-import type { INodeEngineConfig } from "./models/INodeEngineConfig";
-import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables";
-import type { INodeOptions } from "./models/INodeOptions";
+import type { INodeEngineConfig } from "./models/INodeEngineConfig.js";
+import type { INodeEngineState } from "./models/INodeEngineState.js";
+import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables.js";
+import type { INodeOptions } from "./models/INodeOptions.js";
 /**
  * Start the engine server.
  * @param nodeOptions Optional run options for the engine server.
  * @param nodeEngineConfig The configuration for the engine server.
  * @param envVars The environment variables.
+ * @param contextIdKeys The context ID keys.
  * @returns The engine server.
  */
-export declare function start(nodeOptions: INodeOptions | undefined, nodeEngineConfig: INodeEngineConfig, envVars: INodeEnvironmentVariables): Promise<{
-    engine: Engine<IEngineServerConfig, IEngineState>;
+export declare function start(nodeOptions: INodeOptions | undefined, nodeEngineConfig: INodeEngineConfig, envVars: INodeEnvironmentVariables, contextIdKeys?: string[]): Promise<{
+    engine: Engine<IEngineServerConfig, INodeEngineState>;
     server: EngineServer;
     shutdown: () => Promise<void>;
 } | undefined>;

package/dist/types/utils.d.ts

@@ -1,5 +1,8 @@
-import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables";
-import { NodeFeatures } from "./models/nodeFeatures";
+import type { IModuleProtocol } from "./models/IModuleProtocol.js";
+import type { INodeEnvironmentVariables } from "./models/INodeEnvironmentVariables.js";
+import type { IProtocolHandlerResult } from "./models/IProtocolHandlerResult.js";
+import { ModuleProtocol } from "./models/moduleProtocol.js";
+import { NodeFeatures } from "./models/nodeFeatures.js";
 /**
  * Initialise the locales for the application.
  * @param localesDirectory The directory containing the locales.
@@ -52,3 +55,67 @@ export declare function loadJsonFile<T>(filename: string): Promise<T>;
  * @returns The features that are enabled on the node.
  */
 export declare function getFeatures(env: INodeEnvironmentVariables): NodeFeatures[];
+/**
+ * Parse the protocol from a module name.
+ * @param moduleName The module name to parse.
+ * @returns The parsed protocol information.
+ */
+export declare function parseModuleProtocol(moduleName: string): IModuleProtocol;
+/**
+ * Hash a URL to create a safe filename.
+ * @param url The URL to hash.
+ * @returns A hashed filename safe for the filesystem.
+ */
+export declare function hashUrl(url: string): string;
+/**
+ * Get the extensions cache directory.
+ * @param executionDirectory The execution directory.
+ * @param protocol The protocol type for subdirectory organization.
+ * @param cacheDirectory The cache directory base path.
+ * @returns The cache directory path.
+ */
+export declare function getExtensionsCacheDir(executionDirectory: string, protocol: ModuleProtocol, cacheDirectory?: string): string;
+/**
+ * Handle the npm: protocol by installing the package if needed.
+ * @param packageName The npm package name (without npm: prefix).
+ * @param executionDirectory The execution directory.
+ * @param cacheDirectory The cache directory base path.
+ * @returns The resolved path to the installed module.
+ */
+export declare function handleNpmProtocol(packageName: string, executionDirectory: string, cacheDirectory?: string): Promise<IProtocolHandlerResult>;
+/**
+ * Check if a cached file has expired based on TTL and force refresh settings.
+ * @param metadataPath Path to the cache metadata file.
+ * @param ttlHours Time to live in hours.
+ * @param forceRefresh Whether to force refresh regardless of TTL.
+ * @returns True if the cache is expired or should be refreshed.
+ */
+export declare function isCacheExpired(metadataPath: string, ttlHours: number, forceRefresh: boolean): Promise<boolean>;
+/**
+ * Handle the https: protocol by downloading the module if needed.
+ * @param url The HTTPS URL to download from.
+ * @param executionDirectory The execution directory.
+ * @param maxSizeMb The maximum size in MB for the download.
+ * @param cacheDirectory The cache directory base path.
+ * @param ttlHours TTL in hours for cache expiration.
+ * @param forceRefresh Whether to force refresh the cache.
+ * @returns The resolved path to the downloaded module.
+ */
+export declare function handleHttpsProtocol(url: string, executionDirectory: string, maxSizeMb: number, cacheDirectory?: string, ttlHours?: number, forceRefresh?: boolean): Promise<IProtocolHandlerResult>;
+/**
+ * Resolve the main entry point from a package directory using Node.js resolution with fallback.
+ * Uses require.resolve() when possible for standard Node.js behavior, with manual fallback.
+ * @param packagePath The absolute path to the package directory.
+ * @param packageName The package name for require.resolve().
+ * @param fallback The fallback file name if no entry point is found.
+ * @returns The resolved entry point file name (relative to package directory).
+ */
+export declare function resolvePackageEntryPoint(packagePath: string, packageName: string, fallback?: string): Promise<string>;
+/**
+ * Convert a file path to an import-compatible URL for cross-platform module loading.
+ * On Windows, adds the 'file://' protocol prefix required for dynamic imports.
+ * On other platforms, returns the path unchanged.
+ * @param filePath The absolute file path to convert.
+ * @returns A URL string compatible with dynamic import().
+ */
+export declare function createModuleImportUrl(filePath: string): string;

package/docs/changelog.md

@@ -1,5 +1,12 @@
 # @twin.org/node-core - Changelog
 
+## [0.0.2-next.26](https://github.com/twinfoundation/node/compare/node-core-v0.0.2-next.25...node-core-v0.0.2-next.26) (2025-10-10)
+
+
+### Features
+
+* adding npm and https protocols to load extensions ([#45](https://github.com/twinfoundation/node/issues/45)) ([33940b7](https://github.com/twinfoundation/node/commit/33940b7e771a0c5af32c18d442deb26a8631fd02))
+
 ## [0.0.2-next.25](https://github.com/twinfoundation/node/compare/node-core-v0.0.2-next.24...node-core-v0.0.2-next.25) (2025-10-09)
 
 

package/docs/detailed-guide.md

@@ -0,0 +1,129 @@
+# TWIN Node - Detailed Documentation
+
+## Overview
+
+TWIN Node provides the foundational components for running TWIN nodes, including dynamic extension loading, protocol-based module resolution, and lifecycle management.
+
+## Protocol-Based Extension Loading
+
+The TWIN Node supports dynamic extension loading from multiple sources:
+
+### Local Files
+
+Load extensions from your filesystem:
+
+```bash
+TWIN_EXTENSIONS="./my-extension.mjs"
+```
+
+### NPM Packages
+
+Automatically install and load npm packages:
+
+```bash
+TWIN_EXTENSIONS="npm:@twin.org/package"
+```
+
+### HTTPS URLs
+
+Download and cache remote extensions:
+
+```bash
+TWIN_EXTENSIONS="https://example.com/extension.mjs"
+```
+
+## Extension Lifecycle Hooks
+
+Extensions can implement lifecycle hooks to customize node behavior at different stages:
+
+- **`extensionInitialise`** - Called before engine initialization
+- **`extensionInitialiseEngine`** - Called during engine initialization
+- **`extensionInitialiseEngineServer`** - Called during server initialization
+- **`extensionShutdown`** - Called during graceful shutdown
+
+### Example Extension
+
+```javascript
+// my-extension.mjs
+export function extensionInitialise() {
+  console.log('Extension initializing...');
+}
+
+export function extensionInitialiseEngine(engine) {
+  console.log('Configuring engine...');
+  // Add custom components, routes, etc.
+}
+
+export function extensionInitialiseEngineServer(server) {
+  console.log('Configuring server...');
+  // Add middleware, routes, etc.
+}
+
+export function extensionShutdown() {
+  console.log('Extension shutting down...');
+  // Cleanup resources
+}
+```
+
+## Configuration Options
+
+### Cache Management
+
+- `TWIN_EXTENSIONS_CACHE_TTL_HOURS` - TTL for HTTPS extensions cache (default: 24)
+- `TWIN_EXTENSIONS_FORCE_REFRESH` - Force refresh all cached extensions (default: false)
+- `TWIN_EXTENSIONS_CACHE_DIRECTORY` - Custom cache directory (default: ".tmp")
+
+### Security
+
+- `TWIN_EXTENSIONS_MAX_SIZE_MB` - Maximum size for HTTPS downloads (default: 10)
+- `TWIN_EXTENSIONS_CLEAR_CACHE` - Clear cache on startup (default: false)
+
+## API Reference
+
+### Core Functions
+
+#### `overrideModuleImport(executionDirectory, envVars)`
+
+Sets up protocol-based module resolution for extensions.
+
+#### `buildConfiguration(options)`
+
+Builds node configuration from environment variables and options.
+
+#### `start(options)`
+
+Starts the TWIN node with the specified configuration.
+
+### Utility Functions
+
+#### `parseModuleProtocol(moduleName)`
+
+Parses module name to determine protocol type (npm, https, local, etc.).
+
+#### `handleNpmProtocol(packageName, executionDirectory, cacheDirectory)`
+
+Handles installation and resolution of npm packages.
+
+#### `handleHttpsProtocol(url, executionDirectory, maxSizeMb, cacheDirectory, ttlHours, forceRefresh)`
+
+Handles download and caching of HTTPS extensions.
+
+## Security Considerations
+
+- **HTTPS Only**: Remote extensions must use HTTPS protocol
+- **Size Limits**: Downloads are limited by `TWIN_EXTENSIONS_MAX_SIZE_MB`
+- **Cache TTL**: Extensions are automatically refreshed based on TTL
+- **Security Warnings**: Warnings are displayed when loading remote extensions
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Extension not found**: Check that the path/URL is correct and accessible
+2. **Cache issues**: Use `TWIN_EXTENSIONS_FORCE_REFRESH=true` to force refresh
+3. **Size limit exceeded**: Increase `TWIN_EXTENSIONS_MAX_SIZE_MB` if needed
+4. **Network issues**: Ensure HTTPS URLs are accessible and not blocked by firewall
+
+### Debug Mode
+
+Set `NODE_ENV=development` for additional debug output during extension loading.

package/docs/reference/functions/bootstrap.md

@@ -14,7 +14,7 @@ The engine core for the node.
 
 ### context
 
-`IEngineCoreContext`\<`IEngineServerConfig`, `IEngineState`\>
+`IEngineCoreContext`\<`IEngineServerConfig`, [`INodeEngineState`](../interfaces/INodeEngineState.md)\>
 
 The context for the node.
 

package/docs/reference/functions/bootstrapAuth.md

@@ -14,7 +14,7 @@ The engine core for the node.
 
 ### context
 
-`IEngineCoreContext`\<`IEngineServerConfig`, `IEngineState`\>
+`IEngineCoreContext`\<`IEngineServerConfig`, [`INodeEngineState`](../interfaces/INodeEngineState.md)\>
 
 The context for the node.
 

package/docs/reference/functions/bootstrapBlobEncryption.md

@@ -14,7 +14,7 @@ The engine core for the node.
 
 ### context
 
-`IEngineCoreContext`\<`IEngineServerConfig`, `IEngineState`\>
+`IEngineCoreContext`\<`IEngineServerConfig`, [`INodeEngineState`](../interfaces/INodeEngineState.md)\>
 
 The context for the node.
 

package/docs/reference/functions/bootstrapContextIdHandlers.md

@@ -0,0 +1,35 @@
+# Function: bootstrapContextIdHandlers()
+
+> **bootstrapContextIdHandlers**(`engineCore`, `context`, `envVars`, `features`): `Promise`\<`void`\>
+
+Bootstrap the context id handlers creating any necessary resources.
+
+## Parameters
+
+### engineCore
+
+`IEngineCore`
+
+The engine core for the node.
+
+### context
+
+`IEngineCoreContext`\<`IEngineServerConfig`, [`INodeEngineState`](../interfaces/INodeEngineState.md)\>
+
+The context for the node.
+
+### envVars
+
+[`INodeEnvironmentVariables`](../interfaces/INodeEnvironmentVariables.md)
+
+The environment variables for the node.
+
+### features
+
+[`NodeFeatures`](../type-aliases/NodeFeatures.md)[]
+
+The features that are enabled on the node. The features that are enabled on the node.
+
+## Returns
+
+`Promise`\<`void`\>

package/docs/reference/functions/bootstrapImmutableProofMethod.md

@@ -14,7 +14,7 @@ The engine core for the node.
 
 ### context
 
-`IEngineCoreContext`\<`IEngineServerConfig`, `IEngineState`\>
+`IEngineCoreContext`\<`IEngineServerConfig`, [`INodeEngineState`](../interfaces/INodeEngineState.md)\>
 
 The context for the node.