jitar 0.3.1 → 0.3.3

package/dist/core/reflection/ReflectionHelper.js

@@ -0,0 +1,69 @@
+import ReflectionField from './models/ReflectionField.js';
+import ParameterParser from './ParameterParser.js';
+const CONSTRUCTOR_NAME = 'constructor';
+const FUNCTION_NAME = 'function';
+export default class ReflectionHelper {
+    static createInstance(clazz, args = []) {
+        return new clazz(...args);
+    }
+    static isClassObject(object) {
+        return object.constructor.toString().startsWith('class');
+    }
+    static getObjectClass(object) {
+        return object.constructor;
+    }
+    static getParentClass(clazz) {
+        return Object.getPrototypeOf(clazz);
+    }
+    static getFields(clazz) {
+        const object = this.createInstance(clazz);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+        return [...publicFields, ...propertyFields];
+    }
+    static getObjectFields(object) {
+        const clazz = this.getObjectClass(object);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+        return [...publicFields, ...propertyFields];
+    }
+    static #getPublicFields(object) {
+        const fieldNames = Object.getOwnPropertyNames(object);
+        return fieldNames.map(fieldName => new ReflectionField(fieldName, true, true));
+    }
+    static #getPropertyFields(clazz) {
+        const methods = Object.getOwnPropertyDescriptors(clazz.prototype);
+        const fields = [];
+        for (const name in methods) {
+            const description = methods[name];
+            const hasGetter = description.get !== undefined;
+            const hasSetter = description.set !== undefined;
+            if (hasGetter === false && hasSetter === false) {
+                continue;
+            }
+            fields.push(new ReflectionField(name, hasGetter, hasSetter));
+        }
+        const parentClazz = this.getParentClass(clazz);
+        if (parentClazz.name !== '') {
+            const parentFields = this.#getPropertyFields(parentClazz);
+            return [...fields, ...parentFields];
+        }
+        return fields;
+    }
+    static getConstructorParameters(clazz) {
+        const code = clazz.toString();
+        const hasConstructor = code.includes(CONSTRUCTOR_NAME);
+        if (hasConstructor === false) {
+            const parentClazz = this.getParentClass(clazz);
+            if (parentClazz.name === '') {
+                return [];
+            }
+            return this.getConstructorParameters(parentClazz);
+        }
+        return ParameterParser.parse(code, CONSTRUCTOR_NAME);
+    }
+    static getFunctionParameters(funktion) {
+        const code = funktion.toString();
+        return ParameterParser.parse(code, FUNCTION_NAME);
+    }
+}

package/dist/core/reflection/models/ReflectionField.d.ts

@@ -0,0 +1,8 @@
+export default class ReflectionField {
+    #private;
+    constructor(name: string, canGet: boolean, canSet: boolean);
+    get name(): string;
+    get canGet(): boolean;
+    get canSet(): boolean;
+    get canGetAndSet(): boolean;
+}

package/dist/core/reflection/models/ReflectionField.js

@@ -0,0 +1,14 @@
+export default class ReflectionField {
+    #name;
+    #canGet;
+    #canSet;
+    constructor(name, canGet, canSet) {
+        this.#name = name;
+        this.#canGet = canGet;
+        this.#canSet = canSet;
+    }
+    get name() { return this.#name; }
+    get canGet() { return this.#canGet; }
+    get canSet() { return this.#canSet; }
+    get canGetAndSet() { return this.#canGet && this.#canSet; }
+}

package/dist/core/reflection/models/ReflectionParameter.d.ts

@@ -0,0 +1,7 @@
+export default class ReflectionParameter {
+    #private;
+    constructor(name: string, defaultValue?: string);
+    get name(): string;
+    get defaultValue(): string | undefined;
+    get isOptional(): boolean;
+}

package/dist/core/reflection/models/ReflectionParameter.js

@@ -0,0 +1,11 @@
+export default class ReflectionParameter {
+    #name;
+    #defaultValue;
+    constructor(name, defaultValue) {
+        this.#name = name;
+        this.#defaultValue = defaultValue;
+    }
+    get name() { return this.#name; }
+    get defaultValue() { return this.#defaultValue; }
+    get isOptional() { return this.#defaultValue !== undefined; }
+}

package/dist/core/types/Component.d.ts

@@ -0,0 +1,5 @@
+type Component = {
+    name: string;
+    source?: string;
+};
+export default Component;

package/dist/core/types/Component.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/FlexObject.d.ts

@@ -0,0 +1,4 @@
+type FlexObject = {
+    [key: string]: unknown;
+};
+export default FlexObject;

package/dist/core/types/FlexObject.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/Module.d.ts

@@ -0,0 +1,3 @@
+import FlexObject from './FlexObject.js';
+type Module = FlexObject;
+export default Module;

package/dist/core/types/Module.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/SegmentImplementation.d.ts

@@ -0,0 +1,6 @@
+type SegmentImplementation = {
+    access: string;
+    version: string;
+    executable: Function;
+};
+export default SegmentImplementation;

package/dist/core/types/SegmentImplementation.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/SegmentModule.d.ts

@@ -0,0 +1,5 @@
+import SegmentProcedure from './SegmentProcedure.js';
+type SegmentModule = {
+    procedures: SegmentProcedure[];
+};
+export default SegmentModule;

package/dist/core/types/SegmentModule.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types/SegmentProcedure.d.ts

@@ -0,0 +1,7 @@
+import SegmentImplementation from './SegmentImplementation.js';
+type SegmentProcedure = {
+    module: string;
+    name: string;
+    implementations: SegmentImplementation[];
+};
+export default SegmentProcedure;

package/dist/core/types/SegmentProcedure.js

@@ -0,0 +1 @@
+export {};

package/dist/core/utils/FqnBuilder.d.ts

@@ -0,0 +1,3 @@
+export default class FqnBuilder {
+    static build(module: string, name: string): string;
+}

package/dist/core/utils/FqnBuilder.js

@@ -0,0 +1,5 @@
+export default class FqnBuilder {
+    static build(module, name) {
+        return module !== '' ? `${module}/${name}` : name;
+    }
+}

package/dist/hooks.d.ts

@@ -0,0 +1,2 @@
+export * from './runtime/hooks/dependencies.js';
+export * from './runtime/hooks/runtime.js';

package/dist/hooks.js

@@ -0,0 +1,2 @@
+export * from './runtime/hooks/dependencies.js';
+export * from './runtime/hooks/runtime.js';

package/dist/lib.d.ts

@@ -0,0 +1,35 @@
+export { default as HealthCheck } from './runtime/interfaces/HealthCheck.js';
+export { default as Middleware } from './runtime/interfaces/Middleware.js';
+export { default as NextHandler } from './runtime/types/NextHandler.js';
+export { default as Version } from './core/Version.js';
+export { default as Forbidden } from './core/errors/Forbidden.js';
+export { default as BadRequest } from './core/errors/BadRequest.js';
+export { default as NotFound } from './core/errors/NotFound.js';
+export { default as NotImplemented } from './core/errors/NotImplemented.js';
+export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
+export { default as Teapot } from './core/errors/Teapot.js';
+export { default as Unauthorized } from './core/errors/Unauthorized.js';
+export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
+export { default as LocalRepository } from './runtime/LocalRepository.js';
+export { default as LocalNode } from './runtime/LocalNode.js';
+export { default as Proxy } from './runtime/Proxy.js';
+export { default as ValueSerializer } from './runtime/serialization/ValueSerializer.js';
+export { default as ClientId } from './runtime/ClientId.js';
+export { default as RemoteNode } from './runtime/RemoteNode.js';
+export { default as LocalGateway } from './runtime/LocalGateway.js';
+export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
+export { default as FileManager } from './runtime/interfaces/FileManager.js';
+export { default as File } from './runtime/models/File.js';
+export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';
+export { default as Gateway } from './runtime/Gateway.js';
+export { default as Node } from './runtime/Node.js';
+export { default as NodeMonitor } from './runtime/NodeMonitor.js';
+export { default as RemoteGateway } from './runtime/RemoteGateway.js';
+export { default as Repository } from './runtime/Repository.js';
+export { default as Runtime } from './runtime/Runtime.js';
+export { default as RemoteRepository } from './runtime/RemoteRepository.js';
+export { default as CorsMiddleware } from './runtime/middleware/CorsMiddleware.js';
+export { default as ModuleImporter } from './runtime/types/ModuleImporter.js';
+export { default as ModuleLoader } from './runtime/utils/ModuleLoader.js';
+export * from './client.js';
+export * from './hooks.js';

package/dist/lib.js

@@ -0,0 +1,30 @@
+export { default as Version } from './core/Version.js';
+export { default as Forbidden } from './core/errors/Forbidden.js';
+export { default as BadRequest } from './core/errors/BadRequest.js';
+export { default as NotFound } from './core/errors/NotFound.js';
+export { default as NotImplemented } from './core/errors/NotImplemented.js';
+export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
+export { default as Teapot } from './core/errors/Teapot.js';
+export { default as Unauthorized } from './core/errors/Unauthorized.js';
+export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
+export { default as LocalRepository } from './runtime/LocalRepository.js';
+export { default as LocalNode } from './runtime/LocalNode.js';
+export { default as Proxy } from './runtime/Proxy.js';
+export { default as ValueSerializer } from './runtime/serialization/ValueSerializer.js';
+export { default as ClientId } from './runtime/ClientId.js';
+export { default as RemoteNode } from './runtime/RemoteNode.js';
+export { default as LocalGateway } from './runtime/LocalGateway.js';
+export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
+export { default as File } from './runtime/models/File.js';
+export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';
+export { default as Gateway } from './runtime/Gateway.js';
+export { default as Node } from './runtime/Node.js';
+export { default as NodeMonitor } from './runtime/NodeMonitor.js';
+export { default as RemoteGateway } from './runtime/RemoteGateway.js';
+export { default as Repository } from './runtime/Repository.js';
+export { default as Runtime } from './runtime/Runtime.js';
+export { default as RemoteRepository } from './runtime/RemoteRepository.js';
+export { default as CorsMiddleware } from './runtime/middleware/CorsMiddleware.js';
+export { default as ModuleLoader } from './runtime/utils/ModuleLoader.js';
+export * from './client.js';
+export * from './hooks.js';

package/dist/runtime/ClientId.d.ts

@@ -0,0 +1,4 @@
+export default class ClientId {
+    static generate(): string;
+    static validate(clientId: string): boolean;
+}

package/dist/runtime/ClientId.js

@@ -0,0 +1,11 @@
+const CLIENT_ID_PREFIX = 'CLIENT_';
+const CLIENT_ID_REGEX = /^CLIENT_\d+$/;
+let lastClientId = 0;
+export default class ClientId {
+    static generate() {
+        return `${CLIENT_ID_PREFIX}${lastClientId++}`;
+    }
+    static validate(clientId) {
+        return CLIENT_ID_REGEX.test(clientId);
+    }
+}

package/dist/runtime/Gateway.d.ts

@@ -0,0 +1,5 @@
+import Node from './Node.js';
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default abstract class Gateway extends ProcedureRuntime {
+    abstract addNode(node: Node): Promise<void>;
+}

package/dist/runtime/Gateway.js

@@ -0,0 +1,3 @@
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Gateway extends ProcedureRuntime {
+}

package/dist/runtime/LocalGateway.d.ts

@@ -0,0 +1,14 @@
+import Version from '../core/Version.js';
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+import Repository from './Repository.js';
+export default class LocalGateway extends Gateway {
+    #private;
+    get nodes(): Node[];
+    getProcedureNames(): string[];
+    hasProcedure(fqn: string): boolean;
+    addNode(node: Node): Promise<void>;
+    removeNode(node: Node): void;
+    setBaseUrl(repository: Repository): Promise<void>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/runtime/LocalGateway.js

@@ -0,0 +1,61 @@
+import ProcedureNotFound from '../core/errors/ProcedureNotFound.js';
+import Gateway from './Gateway.js';
+import NodeBalancer from './NodeBalancer.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+const NO_SEGMENTS = [];
+export default class LocalGateway extends Gateway {
+    #nodes = new Set();
+    #balancers = new Map();
+    get nodes() {
+        return [...this.#nodes.values()];
+    }
+    getProcedureNames() {
+        const procedureNames = this.nodes.map(node => node.getProcedureNames());
+        const uniqueNames = new Set(procedureNames.flat());
+        return [...uniqueNames.values()];
+    }
+    hasProcedure(fqn) {
+        const procedureNames = this.getProcedureNames();
+        return procedureNames.includes(fqn);
+    }
+    async addNode(node) {
+        this.#nodes.add(node);
+        for (const name of node.getProcedureNames()) {
+            const balancer = this.#getOrCreateBalancer(name);
+            balancer.addNode(node);
+        }
+    }
+    removeNode(node) {
+        this.#nodes.delete(node);
+        for (const name of node.getProcedureNames()) {
+            const balancer = this.#getBalancer(name);
+            if (balancer === undefined) {
+                continue;
+            }
+            balancer.removeNode(node);
+        }
+    }
+    async setBaseUrl(repository) {
+        const clientId = await repository.registerClient(NO_SEGMENTS);
+        const moduleLocation = await repository.getModuleLocation(clientId);
+        ModuleLoader.setBaseUrl(moduleLocation);
+    }
+    #getBalancer(fqn) {
+        return this.#balancers.get(fqn);
+    }
+    #getOrCreateBalancer(fqn) {
+        let balancer = this.#getBalancer(fqn);
+        if (balancer === undefined) {
+            balancer = new NodeBalancer();
+            this.#balancers.set(fqn, balancer);
+        }
+        return balancer;
+    }
+    async run(fqn, version, args, headers) {
+        const balancer = this.#getBalancer(fqn);
+        if (balancer === undefined) {
+            throw new ProcedureNotFound(fqn);
+        }
+        return balancer.run(fqn, version, args, headers);
+    }
+}

package/dist/runtime/LocalNode.d.ts

@@ -0,0 +1,18 @@
+import Segment from '../core/Segment.js';
+import Version from '../core/Version.js';
+import Module from '../core/types/Module.js';
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+import Repository from './Repository.js';
+export default class LocalNode extends Node {
+    #private;
+    getProcedureNames(): string[];
+    loadSegment(name: string): Promise<void>;
+    addSegment(segment: Segment): void;
+    getSegment(id: string): Segment | undefined;
+    hasProcedure(fqn: string): boolean;
+    setGateway(gateway: Gateway): Promise<void>;
+    setRepository(repository: Repository, segmentNames: string[]): Promise<void>;
+    import(url: string, base?: string): Promise<Module>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/runtime/LocalNode.js

@@ -0,0 +1,75 @@
+import ProcedureNotFound from '../core/errors/ProcedureNotFound.js';
+import SegmentBuilder from '../core/SegmentBuilder.js';
+import RepositoryNotAvailable from './errors/RepositoryNotAvaiable.js';
+import LocalGateway from './LocalGateway.js';
+import Node from './Node.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+import UrlRewriter from './utils/UrlRewriter.js';
+export default class LocalNode extends Node {
+    #segments = new Map();
+    #gateway;
+    #repository;
+    #clientId = '';
+    getProcedureNames() {
+        const names = new Set();
+        for (const segment of this.#segments.values()) {
+            const procedures = segment.getPublicProcedures();
+            procedures.forEach(procedure => names.add(procedure.fqn));
+        }
+        return [...names.values()];
+    }
+    async loadSegment(name) {
+        const segmentFile = `${name}.segment.local.js`;
+        const module = await this.import(segmentFile);
+        const segment = SegmentBuilder.build(name, module);
+        this.addSegment(segment);
+    }
+    addSegment(segment) {
+        this.#segments.set(segment.id, segment);
+    }
+    getSegment(id) {
+        return this.#segments.get(id);
+    }
+    hasProcedure(fqn) {
+        const procedureNames = this.getProcedureNames();
+        return procedureNames.includes(fqn);
+    }
+    #getProcedureSegment(fqn) {
+        for (const segment of this.#segments.values()) {
+            if (segment.hasProcedure(fqn)) {
+                return segment;
+            }
+        }
+        return undefined;
+    }
+    async setGateway(gateway) {
+        if (gateway instanceof LocalGateway || this.url !== undefined) {
+            await gateway.addNode(this);
+        }
+        this.#gateway = gateway;
+    }
+    async setRepository(repository, segmentNames) {
+        this.#clientId = await repository.registerClient(segmentNames);
+        await repository.setRuntime(this);
+        const moduleLocation = await repository.getModuleLocation(this.#clientId);
+        ModuleLoader.setBaseUrl(moduleLocation);
+        this.#repository = repository;
+    }
+    async import(url, base) {
+        if (this.#repository === undefined) {
+            throw new RepositoryNotAvailable();
+        }
+        if (base !== undefined) {
+            url = UrlRewriter.addBase(url, base);
+        }
+        return this.#repository.importModule(this.#clientId, url);
+    }
+    async run(fqn, version, args, headers) {
+        const segment = this.#getProcedureSegment(fqn);
+        const runner = segment ?? this.#gateway;
+        if (runner === undefined) {
+            throw new ProcedureNotFound(fqn);
+        }
+        return runner.run(fqn, version, args, headers);
+    }
+}

package/dist/runtime/LocalRepository.d.ts

@@ -0,0 +1,17 @@
+import Module from '../core/types/Module.js';
+import LocalNode from './LocalNode.js';
+import Repository from './Repository.js';
+import FileManager from './interfaces/FileManager.js';
+import File from './models/File.js';
+export default class LocalRepository extends Repository {
+    #private;
+    constructor(fileManager: FileManager, assets: string[], url?: string);
+    loadSegment(name: string): Promise<void>;
+    registerSegment(name: string, files: string[]): Promise<void>;
+    registerClient(segmentFilenames: string[]): Promise<string>;
+    setRuntime(runtime: LocalNode): Promise<void>;
+    loadAsset(filename: string): Promise<File>;
+    getModuleLocation(clientId: string): Promise<string>;
+    loadModule(clientId: string, filename: string): Promise<File>;
+    importModule(clientId: string, filename: string): Promise<Module>;
+}

package/dist/runtime/LocalRepository.js

@@ -0,0 +1,94 @@
+import ClientId from './ClientId.js';
+import Repository from './Repository.js';
+import File from './models/File.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+import ClientNotFound from './errors/ClientNotFound.js';
+import FileNotFound from './errors/FileNotFound.js';
+import InvalidClientId from './errors/InvalidClientId.js';
+import InvalidSegmentFile from './errors/InvalidSegmentFile.js';
+import { setRuntime } from '../hooks.js';
+export default class LocalRepository extends Repository {
+    #fileManager;
+    #segments = new Map();
+    #clients = new Map();
+    #assets;
+    constructor(fileManager, assets, url) {
+        super(url);
+        this.#fileManager = fileManager;
+        this.#assets = assets;
+    }
+    async loadSegment(name) {
+        const filename = `./${name}.segment.repository.js`;
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+        const module = await ModuleLoader.load(location);
+        const files = module.files;
+        if (files === undefined) {
+            throw new InvalidSegmentFile(location);
+        }
+        this.registerSegment(name, files);
+    }
+    async registerSegment(name, files) {
+        files.forEach((file) => this.#segments.set(file, name));
+    }
+    async registerClient(segmentFilenames) {
+        const clientId = ClientId.generate();
+        this.#clients.set(clientId, segmentFilenames);
+        return clientId;
+    }
+    async setRuntime(runtime) {
+        setRuntime(runtime);
+    }
+    async loadAsset(filename) {
+        if (this.#assets.includes(filename) === false) {
+            throw new FileNotFound(filename);
+        }
+        return this.#loadFile(filename);
+    }
+    async getModuleLocation(clientId) {
+        return this.#fileManager.getRootLocation();
+    }
+    async loadModule(clientId, filename) {
+        this.#validateClientId(clientId);
+        const segmentFilename = this.#segments.get(filename);
+        if (segmentFilename === undefined) {
+            return this.#getNodeModule(filename, false);
+        }
+        return this.#hasClientSegmentFile(clientId, segmentFilename)
+            ? this.#getNodeModule(filename, true)
+            : this.#getRemoteModule(filename);
+    }
+    async importModule(clientId, filename) {
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+        return ModuleLoader.import(location);
+    }
+    #validateClientId(clientId) {
+        if (ClientId.validate(clientId) === false) {
+            throw new InvalidClientId(clientId);
+        }
+        if (this.#clients.has(clientId) === false) {
+            throw new ClientNotFound(clientId);
+        }
+    }
+    #hasClientSegmentFile(clientId, segmentFilename) {
+        const clientSegmentFiles = this.#clients.get(clientId);
+        if (clientSegmentFiles === undefined) {
+            throw new ClientNotFound(clientId);
+        }
+        return clientSegmentFiles.some(clientSegmentFilename => segmentFilename.endsWith(clientSegmentFilename));
+    }
+    async #getNodeModule(filename, isSegmented) {
+        if (isSegmented) {
+            filename = filename.replace('.js', '.local.js');
+        }
+        const file = await this.#loadFile(filename);
+        const code = file.content.toString();
+        return new File(filename, 'application/javascript', code);
+    }
+    async #getRemoteModule(filename) {
+        const remoteFilename = filename.replace('.js', '.remote.js');
+        return this.#loadFile(remoteFilename);
+    }
+    async #loadFile(filename) {
+        return this.#fileManager.load(filename);
+    }
+}

package/dist/runtime/Node.d.ts

@@ -0,0 +1,3 @@
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default abstract class Node extends ProcedureRuntime {
+}

package/dist/runtime/Node.js

@@ -0,0 +1,3 @@
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Node extends ProcedureRuntime {
+}

package/dist/runtime/NodeBalancer.d.ts

@@ -0,0 +1,9 @@
+import Version from '../core/Version.js';
+import Node from './Node.js';
+export default class NodeBalancer {
+    #private;
+    addNode(node: Node): void;
+    removeNode(node: Node): void;
+    getNextNode(): Node | undefined;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/runtime/NodeBalancer.js

@@ -0,0 +1,34 @@
+import NoNodeAvailable from './errors/NoNodeAvailable.js';
+export default class NodeBalancer {
+    #nodes = [];
+    #currentIndex = 0;
+    addNode(node) {
+        if (this.#nodes.includes(node)) {
+            return;
+        }
+        this.#nodes.push(node);
+    }
+    removeNode(node) {
+        const index = this.#nodes.indexOf(node);
+        if (index === -1) {
+            return;
+        }
+        this.#nodes.splice(index, 1);
+    }
+    getNextNode() {
+        if (this.#nodes.length === 0) {
+            return;
+        }
+        if (this.#currentIndex >= this.#nodes.length) {
+            this.#currentIndex = 0;
+        }
+        return this.#nodes[this.#currentIndex++];
+    }
+    async run(fqn, version, args, headers) {
+        const node = this.getNextNode();
+        if (node === undefined) {
+            throw new NoNodeAvailable(fqn);
+        }
+        return node.run(fqn, version, args, headers);
+    }
+}

package/dist/runtime/NodeMonitor.d.ts

@@ -0,0 +1,7 @@
+import LocalGateway from './LocalGateway.js';
+export default class NodeMonitor {
+    #private;
+    constructor(gateway: LocalGateway, frequency?: number);
+    start(): void;
+    stop(): void;
+}