@omen.foundation/node-microservice-runtime 0.1.33 → 0.1.35

package/dist/dependency.cjs

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BEAMABLE_SERVICES_TOKEN = exports.REQUEST_CONTEXT_TOKEN = exports.ENVIRONMENT_CONFIG_TOKEN = exports.LOGGER_TOKEN = exports.ServiceProvider = exports.DependencyBuilder = exports.ServiceLifetime = void 0;
-require("reflect-metadata");
-var ServiceLifetime;
-(function (ServiceLifetime) {
-    ServiceLifetime["Singleton"] = "singleton";
-    ServiceLifetime["Scoped"] = "scoped";
-    ServiceLifetime["Transient"] = "transient";
-})(ServiceLifetime || (exports.ServiceLifetime = ServiceLifetime = {}));
-function isConstructor(key) {
-    return typeof key === 'function';
-}
-function instantiate(ctor, scope) {
-    var _a;
-    const paramTypes = (_a = Reflect.getMetadata('design:paramtypes', ctor)) !== null && _a !== void 0 ? _a : [];
-    if (paramTypes.length === 0) {
-        return new ctor();
-    }
-    const dependencies = paramTypes.map((param) => {
-        if (param === Object || param === Array || param === Promise) {
-            throw new Error(`Cannot resolve dependency '${param && param.name ? param.name : String(param)}' for ${ctor.name}. ` +
-                'Use ConfigureServices to register a factory explicitly.');
-        }
-        return scope.resolve(param);
-    });
-    return new ctor(...dependencies);
-}
-class DependencyBuilder {
-    constructor() {
-        this.descriptors = new Map();
-    }
-    addSingleton(key, factory) {
-        return this.addDescriptor(key, ServiceLifetime.Singleton, factory);
-    }
-    addSingletonClass(ctor) {
-        return this.addSingleton(ctor, (scope) => instantiate(ctor, scope));
-    }
-    addSingletonInstance(key, instance) {
-        return this.addSingleton(key, () => instance);
-    }
-    addScoped(key, factory) {
-        return this.addDescriptor(key, ServiceLifetime.Scoped, factory);
-    }
-    addScopedClass(ctor) {
-        return this.addScoped(ctor, (scope) => instantiate(ctor, scope));
-    }
-    addTransient(key, factory) {
-        return this.addDescriptor(key, ServiceLifetime.Transient, factory);
-    }
-    addTransientClass(ctor) {
-        return this.addTransient(ctor, (scope) => instantiate(ctor, scope));
-    }
-    tryAddSingleton(key, factory) {
-        if (!this.descriptors.has(key)) {
-            this.addSingleton(key, factory);
-        }
-        return this;
-    }
-    tryAddSingletonInstance(key, instance) {
-        if (!this.descriptors.has(key)) {
-            this.addSingletonInstance(key, instance);
-        }
-        return this;
-    }
-    build() {
-        return new ServiceProvider(this.descriptors);
-    }
-    addDescriptor(key, lifetime, factory) {
-        if (!key) {
-            throw new Error('Dependency registration requires a non-empty key.');
-        }
-        this.descriptors.set(key, { key, lifetime, factory });
-        return this;
-    }
-}
-exports.DependencyBuilder = DependencyBuilder;
-class ServiceProvider {
-    constructor(descriptors) {
-        this.singletons = new Map();
-        this.descriptors = new Map(descriptors);
-    }
-    resolve(key) {
-        const descriptor = this.descriptors.get(key);
-        if (!descriptor && isConstructor(key)) {
-            const implicitDescriptor = {
-                key,
-                lifetime: ServiceLifetime.Transient,
-                factory: (scope) => instantiate(key, scope),
-            };
-            this.descriptors.set(key, implicitDescriptor);
-            return this.resolve(key);
-        }
-        if (!descriptor) {
-            throw new Error(`No service registered for key '${typeof key === 'symbol' ? key.toString() : String(key)}'.`);
-        }
-        switch (descriptor.lifetime) {
-            case ServiceLifetime.Singleton: {
-                if (!this.singletons.has(descriptor.key)) {
-                    const value = descriptor.factory(this);
-                    this.singletons.set(descriptor.key, value);
-                }
-                return this.singletons.get(descriptor.key);
-            }
-            case ServiceLifetime.Scoped:
-                return descriptor.factory(this);
-            case ServiceLifetime.Transient:
-            default:
-                return descriptor.factory(this);
-        }
-    }
-    createScope() {
-        return new ScopedServiceProvider(this.descriptors, this.singletons, this);
-    }
-}
-exports.ServiceProvider = ServiceProvider;
-class ScopedServiceProvider {
-    constructor(descriptors, rootSingletons, rootProvider) {
-        this.scopedInstances = new Map();
-        this.descriptors = descriptors;
-        this.rootSingletons = rootSingletons;
-        this.rootProvider = rootProvider;
-    }
-    resolve(key) {
-        const descriptor = this.descriptors.get(key);
-        if (!descriptor && isConstructor(key)) {
-            const implicitDescriptor = {
-                key,
-                lifetime: ServiceLifetime.Transient,
-                factory: (scope) => instantiate(key, scope),
-            };
-            this.descriptors.set(key, implicitDescriptor);
-            return this.resolve(key);
-        }
-        if (!descriptor) {
-            throw new Error(`No service registered for key '${typeof key === 'symbol' ? key.toString() : String(key)}'.`);
-        }
-        switch (descriptor.lifetime) {
-            case ServiceLifetime.Singleton: {
-                if (!this.rootSingletons.has(descriptor.key)) {
-                    const value = descriptor.factory(this.rootProvider);
-                    this.rootSingletons.set(descriptor.key, value);
-                }
-                return this.rootSingletons.get(descriptor.key);
-            }
-            case ServiceLifetime.Scoped: {
-                if (!this.scopedInstances.has(descriptor.key)) {
-                    const value = descriptor.factory(this);
-                    this.scopedInstances.set(descriptor.key, value);
-                }
-                return this.scopedInstances.get(descriptor.key);
-            }
-            case ServiceLifetime.Transient:
-            default:
-                return descriptor.factory(this);
-        }
-    }
-    setInstance(key, value) {
-        this.scopedInstances.set(key, value);
-    }
-}
-exports.LOGGER_TOKEN = Symbol('beamable:logger');
-exports.ENVIRONMENT_CONFIG_TOKEN = Symbol('beamable:environment');
-exports.REQUEST_CONTEXT_TOKEN = Symbol('beamable:requestContext');
-exports.BEAMABLE_SERVICES_TOKEN = Symbol('beamable:services');

package/dist/dev.cjs

@@ -1,34 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExampleService = void 0;
-require("dotenv/config");
-const decorators_js_1 = require("./decorators.js");
-const runtime_js_1 = require("./runtime.js");
-let ExampleService = class ExampleService {
-    async echo(ctx, message) {
-        return {
-            message,
-            playerId: ctx.userId,
-        };
-    }
-};
-exports.ExampleService = ExampleService;
-__decorate([
-    (0, decorators_js_1.Callable)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String]),
-    __metadata("design:returntype", Promise)
-], ExampleService.prototype, "echo", null);
-exports.ExampleService = ExampleService = __decorate([
-    (0, decorators_js_1.Microservice)('ExampleNodeService')
-], ExampleService);
-void (0, runtime_js_1.runMicroservice)();

package/dist/discovery.cjs

@@ -1,79 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscoveryBroadcaster = void 0;
-const node_dgram_1 = __importDefault(require("node:dgram"));
-const DISCOVERY_PORT = 8624;
-const BROADCAST_PERIOD_MS = 10;
-class DiscoveryBroadcaster {
-    constructor(options) {
-        var _a;
-        this.options = options;
-        this.socket = node_dgram_1.default.createSocket('udp4');
-        this.disposed = false;
-        const message = {
-            processId: process.pid,
-            cid: options.env.cid,
-            pid: options.env.pid,
-            prefix: options.routingKey,
-            serviceName: options.serviceName,
-            healthPort: options.env.healthPort,
-            serviceType: 'service',
-            startedByAccountId: (_a = options.env.accountId) !== null && _a !== void 0 ? _a : 0,
-            isContainer: false,
-            dataPort: 0,
-            containerId: '',
-        };
-        this.payload = Buffer.from(JSON.stringify(message), 'utf8');
-        this.socket.on('error', (err) => {
-            options.logger.warn({ err }, 'Discovery broadcaster socket error.');
-        });
-    }
-    async start() {
-        if (this.disposed) {
-            return;
-        }
-        await new Promise((resolve, reject) => {
-            const onError = (error) => {
-                this.socket.off('error', onError);
-                reject(error);
-            };
-            this.socket.once('error', onError);
-            this.socket.bind(0, undefined, () => {
-                try {
-                    this.socket.setBroadcast(true);
-                    this.socket.off('error', onError);
-                    resolve();
-                }
-                catch (error) {
-                    this.socket.off('error', onError);
-                    reject(error);
-                }
-            });
-        });
-        this.interval = setInterval(() => {
-            this.socket.send(this.payload, DISCOVERY_PORT, '255.255.255.255', (error) => {
-                if (error) {
-                    this.options.logger.debug({ err: error }, 'Discovery broadcast send failed.');
-                }
-            });
-        }, BROADCAST_PERIOD_MS);
-        this.interval.unref();
-    }
-    stop() {
-        this.disposed = true;
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = undefined;
-        }
-        try {
-            this.socket.close();
-        }
-        catch (error) {
-            this.options.logger.debug({ err: error }, 'Error closing discovery broadcaster socket.');
-        }
-    }
-}
-exports.DiscoveryBroadcaster = DiscoveryBroadcaster;

package/dist/docs.cjs

@@ -1,206 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateOpenApiDocument = generateOpenApiDocument;
-const urls_js_1 = require("./utils/urls.js");
-const JSON_CONTENT_TYPE = 'application/json';
-const ADMIN_TAG = 'Administration';
-const SCOPE_SECURITY_SCHEME = {
-    type: 'apiKey',
-    name: 'X-DE-SCOPE',
-    in: 'header',
-    description: "Customer and project scope. This should contain the '<customer-id>.<project-id>'. Required for all microservice calls.",
-};
-const BEAM_SCOPE_SECURITY_SCHEME = {
-    type: 'apiKey',
-    name: 'X-BEAM-SCOPE',
-    in: 'header',
-    description: "Customer and project scope. This should contain the '<customer-id>.<project-id>'. Required for all microservice calls. Alternative to X-DE-SCOPE.",
-};
-const USER_SECURITY_SCHEME = {
-    type: 'http',
-    scheme: 'bearer',
-    bearerFormat: 'Bearer <Access Token>',
-    description: 'Bearer authentication with a player access token in the Authorization header.',
-};
-function generateOpenApiDocument(service, env) {
-    const serverBase = buildServiceBaseUrl(env, service);
-    const doc = {
-        openapi: '3.0.1',
-        info: {
-            title: service.name,
-            version: '0.0.0',
-        },
-        servers: serverBase ? [{ url: serverBase }] : [],
-        paths: {},
-        components: {
-            securitySchemes: {
-                scope: SCOPE_SECURITY_SCHEME,
-                beamScope: BEAM_SCOPE_SECURITY_SCHEME,
-                user: USER_SECURITY_SCHEME,
-            },
-            schemas: {},
-        },
-    };
-    for (const callable of service.callables) {
-        const normalizedRoute = normalizeRoute(callable.route);
-        const pathKey = `/${normalizedRoute}`;
-        const payload = buildRequestSchema(callable.handler);
-        const securityEntry = { scope: [], beamScope: [] };
-        if (callable.metadata.requireAuth) {
-            securityEntry.user = [];
-        }
-        const operation = {
-            operationId: callable.name,
-            summary: callable.name,
-            tags: callable.metadata.tags.length > 0 ? callable.metadata.tags : ['Callables'],
-            responses: {
-                '200': {
-                    description: 'Success',
-                    content: {
-                        [JSON_CONTENT_TYPE]: {
-                            schema: {
-                                oneOf: [{ type: 'object' }, { type: 'array' }, { type: 'string' }, { type: 'number' }, { type: 'boolean' }, { type: 'null' }],
-                            },
-                        },
-                    },
-                },
-            },
-            security: [securityEntry],
-            'x-beamable-access': callable.metadata.access,
-        };
-        if (callable.metadata.requiredScopes.length > 0) {
-            operation['x-beamable-required-scopes'] = callable.metadata.requiredScopes;
-        }
-        if (payload) {
-            operation.requestBody = {
-                required: payload.required,
-                content: {
-                    [JSON_CONTENT_TYPE]: {
-                        schema: payload.schema,
-                    },
-                },
-            };
-        }
-        doc.paths[pathKey] = {
-            post: operation,
-        };
-    }
-    addAdminOperations(doc);
-    return JSON.parse(JSON.stringify(doc));
-}
-function buildRequestSchema(handler) {
-    if (typeof handler !== 'function') {
-        return {
-            required: false,
-            schema: {
-                type: 'object',
-                properties: {
-                    payload: {
-                        type: 'array',
-                        description: 'Callable arguments in invocation order.',
-                    },
-                },
-                additionalProperties: false,
-            },
-        };
-    }
-    const expectedParams = handler.length;
-    const payloadCount = Math.max(expectedParams - 1, 0);
-    if (payloadCount <= 0) {
-        return undefined;
-    }
-    return {
-        required: true,
-        schema: {
-            type: 'object',
-            properties: {
-                payload: {
-                    type: 'array',
-                    minItems: payloadCount,
-                    description: 'Callable arguments in invocation order.',
-                },
-            },
-            required: ['payload'],
-            additionalProperties: false,
-        },
-    };
-}
-function buildServiceBaseUrl(env, service) {
-    const host = (0, urls_js_1.hostToHttpUrl)(env.host).replace(/\/$/, '');
-    return `${host}/basic/${env.cid}.${env.pid}.${service.qualifiedName}/`;
-}
-function normalizeRoute(route) {
-    if (!route) {
-        return '';
-    }
-    return route.replace(/^\/+/, '');
-}
-function addAdminOperations(doc) {
-    const requiredScopeSecurity = { scope: [], beamScope: [] };
-    doc.paths['/admin/HealthCheck'] = {
-        post: {
-            operationId: 'adminHealthCheck',
-            summary: 'HealthCheck',
-            tags: [ADMIN_TAG],
-            responses: {
-                '200': {
-                    description: 'The word "responsive" if all is well.',
-                    content: {
-                        [JSON_CONTENT_TYPE]: {
-                            schema: {
-                                type: 'string',
-                                example: 'responsive',
-                            },
-                        },
-                    },
-                },
-            },
-            security: [requiredScopeSecurity],
-        },
-    };
-    const adminSecurity = { scope: ['admin'], beamScope: ['admin'] };
-    doc.paths['/admin/Docs'] = {
-        post: {
-            operationId: 'adminDocs',
-            summary: 'Docs',
-            description: 'Generates an OpenAPI/Swagger 3.0 document that describes the available service endpoints.',
-            tags: [ADMIN_TAG],
-            responses: {
-                '200': {
-                    description: 'Swagger JSON document.',
-                    content: {
-                        [JSON_CONTENT_TYPE]: {
-                            schema: {
-                                type: 'object',
-                            },
-                        },
-                    },
-                },
-            },
-            security: [adminSecurity],
-            'x-beamable-required-scopes': ['admin'],
-        },
-    };
-    doc.paths['/admin/Metadata'] = {
-        post: {
-            operationId: 'adminMetadata',
-            summary: 'Metadata',
-            description: 'Fetch various Beamable SDK metadata for the Microservice.',
-            tags: [ADMIN_TAG],
-            responses: {
-                '200': {
-                    description: 'Service metadata.',
-                    content: {
-                        [JSON_CONTENT_TYPE]: {
-                            schema: {
-                                type: 'object',
-                            },
-                        },
-                    },
-                },
-            },
-            security: [adminSecurity],
-            'x-beamable-required-scopes': ['admin'],
-        },
-    };
-}

package/dist/env.cjs

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEnvironmentConfig = loadEnvironmentConfig;
-exports.ensureWritableTempDirectory = ensureWritableTempDirectory;
-const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const routing_js_1 = require("./routing.js");
-function getBoolean(name, defaultValue = false) {
-    const raw = process.env[name];
-    if (!raw) {
-        return defaultValue;
-    }
-    return ['1', 'true', 'yes', 'on'].includes(raw.toLowerCase());
-}
-function getNumber(name, defaultValue) {
-    const raw = process.env[name];
-    if (!raw) {
-        return defaultValue;
-    }
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) ? parsed : defaultValue;
-}
-function resolveHealthPort() {
-    const preferred = getNumber('HEALTH_PORT', 6565);
-    if (preferred > 0) {
-        return preferred;
-    }
-    const base = 45000;
-    const span = 2000;
-    const candidate = base + (process.pid % span);
-    return candidate;
-}
-function isInContainer() {
-    try {
-        const fs = require('fs');
-        if (fs.existsSync('/.dockerenv')) {
-            return true;
-        }
-    }
-    catch {
-    }
-    const hostname = process.env.HOSTNAME || '';
-    if (hostname && /^[a-f0-9]{12}$/i.test(hostname)) {
-        return true;
-    }
-    if (process.env.DOTNET_RUNNING_IN_CONTAINER === 'true' ||
-        process.env.CONTAINER === 'beamable' ||
-        !!process.env.ECS_CONTAINER_METADATA_URI ||
-        !!process.env.KUBERNETES_SERVICE_HOST) {
-        return true;
-    }
-    return false;
-}
-function resolveRoutingKey() {
-    var _a;
-    const raw = (_a = process.env.NAME_PREFIX) !== null && _a !== void 0 ? _a : process.env.ROUTING_KEY;
-    if (raw && raw.trim().length > 0) {
-        return raw.trim();
-    }
-    if (isInContainer()) {
-        return undefined;
-    }
-    try {
-        return (0, routing_js_1.getDefaultRoutingKeyForMachine)();
-    }
-    catch (error) {
-        throw new Error(`Unable to determine routing key automatically. Set NAME_PREFIX environment variable. ${error.message}`);
-    }
-}
-function resolveSdkVersionExecution() {
-    var _a;
-    return (_a = process.env.BEAMABLE_SDK_VERSION_EXECUTION) !== null && _a !== void 0 ? _a : '';
-}
-function resolveLogLevel() {
-    var _a;
-    const candidate = (_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : 'info';
-    const allowed = new Set(['fatal', 'error', 'warn', 'info', 'debug', 'trace']);
-    return allowed.has(candidate.toLowerCase()) ? candidate.toLowerCase() : 'info';
-}
-function resolveWatchToken() {
-    const value = process.env.WATCH_TOKEN;
-    if (value === undefined) {
-        return false;
-    }
-    return getBoolean('WATCH_TOKEN', false);
-}
-function resolveBeamInstanceCount() {
-    return getNumber('BEAM_INSTANCE_COUNT', 1);
-}
-function loadEnvironmentConfig() {
-    var _a, _b, _c, _d, _e, _f;
-    const cid = (_a = process.env.CID) !== null && _a !== void 0 ? _a : '';
-    const pid = (_b = process.env.PID) !== null && _b !== void 0 ? _b : '';
-    const host = (_c = process.env.HOST) !== null && _c !== void 0 ? _c : '';
-    if (!cid || !pid || !host) {
-        throw new Error('Missing required Beamable environment variables (CID, PID, HOST).');
-    }
-    const config = {
-        cid,
-        pid,
-        host,
-        secret: (_d = process.env.SECRET) !== null && _d !== void 0 ? _d : undefined,
-        refreshToken: (_e = process.env.REFRESH_TOKEN) !== null && _e !== void 0 ? _e : undefined,
-        routingKey: resolveRoutingKey(),
-        accountId: getNumber('USER_ACCOUNT_ID', 0) || undefined,
-        accountEmail: (_f = process.env.USER_EMAIL) !== null && _f !== void 0 ? _f : undefined,
-        logLevel: resolveLogLevel(),
-        healthPort: resolveHealthPort(),
-        disableCustomInitializationHooks: getBoolean('DISABLE_CUSTOM_INITIALIZATION_HOOKS', false),
-        watchToken: resolveWatchToken(),
-        sdkVersionExecution: resolveSdkVersionExecution(),
-        beamInstanceCount: resolveBeamInstanceCount(),
-        logTruncateLimit: getNumber('LOG_TRUNCATE_LIMIT', 1000),
-    };
-    return config;
-}
-function ensureWritableTempDirectory() {
-    var _a;
-    const candidate = (_a = process.env.LOG_PATH) !== null && _a !== void 0 ? _a : (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'beamable-node-runtime');
-    if (!(0, node_fs_1.existsSync)(candidate)) {
-        return candidate;
-    }
-    return candidate;
-}

package/dist/errors.cjs

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidConfigurationError = exports.SerializationError = exports.UnknownRouteError = exports.UnauthorizedUserError = exports.MissingScopesError = exports.TimeoutError = exports.AuthenticationError = exports.BeamableRuntimeError = void 0;
-class BeamableRuntimeError extends Error {
-    constructor(code, message, cause) {
-        var _a;
-        super(message);
-        this.code = code;
-        if (cause !== undefined) {
-            this.cause = cause;
-        }
-        this.name = this.constructor.name;
-        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
-    }
-}
-exports.BeamableRuntimeError = BeamableRuntimeError;
-class AuthenticationError extends BeamableRuntimeError {
-    constructor(message, cause) {
-        super('AUTHENTICATION_FAILED', message, cause);
-    }
-}
-exports.AuthenticationError = AuthenticationError;
-class TimeoutError extends BeamableRuntimeError {
-    constructor(message, cause) {
-        super('TIMEOUT', message, cause);
-    }
-}
-exports.TimeoutError = TimeoutError;
-class MissingScopesError extends BeamableRuntimeError {
-    constructor(requiredScopes) {
-        super('MISSING_SCOPES', `Missing required scopes: ${Array.from(requiredScopes).join(', ')}`);
-    }
-}
-exports.MissingScopesError = MissingScopesError;
-class UnauthorizedUserError extends BeamableRuntimeError {
-    constructor(route) {
-        super('UNAUTHORIZED_USER', `Route "${route}" requires an authenticated user.`);
-    }
-}
-exports.UnauthorizedUserError = UnauthorizedUserError;
-class UnknownRouteError extends BeamableRuntimeError {
-    constructor(route) {
-        super('UNKNOWN_ROUTE', `No callable registered for route "${route}".`);
-    }
-}
-exports.UnknownRouteError = UnknownRouteError;
-class SerializationError extends BeamableRuntimeError {
-    constructor(message, cause) {
-        super('SERIALIZATION_ERROR', message, cause);
-    }
-}
-exports.SerializationError = SerializationError;
-class InvalidConfigurationError extends BeamableRuntimeError {
-    constructor(message, cause) {
-        super('INVALID_CONFIGURATION', message, cause);
-    }
-}
-exports.InvalidConfigurationError = InvalidConfigurationError;