@fjell/registry 4.4.16 → 4.4.20

package/dist/index.cjs

@@ -1,823 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Logging = require('@fjell/logging');
-
-const LibLogger = Logging.getLogger('@fjell/registry');
-
-const logger$3 = LibLogger.get("Coordinate");
-const createCoordinate = (kta, scopes = [])=>{
-    const ktArray = Array.isArray(kta) ? kta : [
-        kta
-    ];
-    const toString = ()=>{
-        logger$3.debug("toString", {
-            kta,
-            scopes
-        });
-        return `${ktArray.join(', ')} - ${scopes.join(', ')}`;
-    };
-    logger$3.debug("createCoordinate", {
-        kta: ktArray,
-        scopes,
-        toString
-    });
-    return {
-        kta: ktArray,
-        scopes,
-        toString
-    };
-};
-
-const logger$2 = LibLogger.get("Instance");
-const createInstance = (registry, coordinate)=>{
-    logger$2.debug("createInstance", {
-        coordinate,
-        registry
-    });
-    return {
-        coordinate,
-        registry
-    };
-};
-const isInstance = (instance)=>{
-    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.registry !== undefined;
-};
-
-/**
- * Represents a service client (another service making the request)
- */ function _define_property$4(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Internal class for tracking Registry statistics with complex coordinate combinations and client tracking
- */ class RegistryStats {
-    /**
-   * Records a get() call for the specified coordinate and client
-   */ recordGetCall(kta, scopes, client) {
-        this.totalCalls++;
-        const ktaKey = kta.join('.');
-        const scopeKey = this.createScopeKey(scopes || []);
-        const clientKey = this.createClientKey(client);
-        if (!this.coordinateCalls.has(ktaKey)) {
-            this.coordinateCalls.set(ktaKey, new Map());
-        }
-        const scopeMap = this.coordinateCalls.get(ktaKey);
-        if (!scopeMap.has(scopeKey)) {
-            scopeMap.set(scopeKey, new Map());
-        }
-        const clientMap = scopeMap.get(scopeKey);
-        const currentCount = clientMap.get(clientKey) || 0;
-        clientMap.set(clientKey, currentCount + 1);
-    }
-    /**
-   * Gets the current statistics snapshot
-   */ getStatistics() {
-        const coordinateCallRecords = [];
-        let serviceCalls = 0;
-        let applicationCalls = 0;
-        let unidentifiedCalls = 0;
-        for (const [ktaKey, scopeMap] of this.coordinateCalls){
-            for (const [scopeKey, clientMap] of scopeMap){
-                const clientCalls = [];
-                let totalCount = 0;
-                for (const [clientKey, count] of clientMap){
-                    const client = this.parseClientKey(clientKey);
-                    if (client !== null) {
-                        clientCalls.push({
-                            client,
-                            count
-                        });
-                    }
-                    totalCount += count;
-                    // Update client summary
-                    if (clientKey === '__no_client__') {
-                        unidentifiedCalls += count;
-                    } else if (typeof client === 'string') {
-                        applicationCalls += count;
-                    } else if (client !== null) {
-                        serviceCalls += count;
-                    }
-                }
-                coordinateCallRecords.push({
-                    kta: ktaKey.split('.'),
-                    scopes: this.parseScopeKey(scopeKey),
-                    count: totalCount,
-                    clientCalls: [
-                        ...clientCalls
-                    ] // Return a copy
-                });
-            }
-        }
-        return {
-            totalGetCalls: this.totalCalls,
-            coordinateCallRecords: [
-                ...coordinateCallRecords
-            ],
-            clientSummary: {
-                serviceCalls,
-                applicationCalls,
-                unidentifiedCalls
-            }
-        };
-    }
-    /**
-   * Gets call count for a specific coordinate combination
-   */ getCallCount(kta, scopes) {
-        const ktaKey = kta.join('.');
-        const scopeKey = this.createScopeKey(scopes || []);
-        const scopeMap = this.coordinateCalls.get(ktaKey);
-        if (!scopeMap) return 0;
-        const clientMap = scopeMap.get(scopeKey);
-        if (!clientMap) return 0;
-        let total = 0;
-        for (const count of clientMap.values()){
-            total += count;
-        }
-        return total;
-    }
-    /**
-   * Gets call count for a specific coordinate combination from a specific client
-   */ getCallCountByClient(kta, scopes, client) {
-        const ktaKey = kta.join('.');
-        const scopeKey = this.createScopeKey(scopes || []);
-        const clientKey = this.createClientKey(client);
-        const scopeMap = this.coordinateCalls.get(ktaKey);
-        if (!scopeMap) return 0;
-        const clientMap = scopeMap.get(scopeKey);
-        if (!clientMap) return 0;
-        return clientMap.get(clientKey) || 0;
-    }
-    /**
-   * Gets total calls for a specific kta (across all scopes)
-   */ getTotalCallsForKta(kta) {
-        const ktaKey = kta.join('.');
-        const scopeMap = this.coordinateCalls.get(ktaKey);
-        if (!scopeMap) return 0;
-        let total = 0;
-        for (const clientMap of scopeMap.values()){
-            for (const count of clientMap.values()){
-                total += count;
-            }
-        }
-        return total;
-    }
-    /**
-   * Gets all unique kta paths that have been called
-   */ getCalledKtaPaths() {
-        const ktaPaths = [];
-        for (const ktaKey of this.coordinateCalls.keys()){
-            ktaPaths.push(ktaKey.split('.'));
-        }
-        return ktaPaths;
-    }
-    /**
-   * Creates a normalized scope key from scopes array
-   */ createScopeKey(scopes) {
-        if (scopes.length === 0) return '__no_scopes__';
-        return [
-            ...scopes
-        ].sort().join(',');
-    }
-    /**
-   * Parses a scope key back to scopes array
-   */ parseScopeKey(scopeKey) {
-        if (scopeKey === '__no_scopes__') return [];
-        return scopeKey.split(',');
-    }
-    /**
-   * Creates a normalized client key from client identifier
-   */ createClientKey(client) {
-        if (!client) return '__no_client__';
-        if (typeof client === 'string') {
-            return `app:${client}`;
-        }
-        // Service client
-        const coordKey = `${client.coordinate.kta.join('.')};${this.createScopeKey(client.coordinate.scopes)}`;
-        return `service:${client.registryType}:${coordKey}`;
-    }
-    /**
-   * Parses a client key back to client identifier
-   */ parseClientKey(clientKey) {
-        if (clientKey === '__no_client__') return null;
-        if (clientKey.startsWith('app:')) {
-            return clientKey.substring(4);
-        }
-        if (clientKey.startsWith('service:')) {
-            const parts = clientKey.substring(8).split(':');
-            if (parts.length !== 2) return null;
-            const registryType = parts[0];
-            const coordParts = parts[1].split(';');
-            if (coordParts.length !== 2) return null;
-            const kta = coordParts[0].split('.');
-            const scopes = this.parseScopeKey(coordParts[1]);
-            return {
-                registryType,
-                coordinate: {
-                    kta,
-                    scopes
-                }
-            };
-        }
-        return null;
-    }
-    constructor(){
-        _define_property$4(this, "totalCalls", 0);
-        // Map structure: ktaKey -> scopeKey -> clientKey -> count
-        _define_property$4(this, "coordinateCalls", new Map());
-    }
-}
-
-const logger$1 = LibLogger.get("Registry");
-const findScopedInstance = (scopedInstances, requestedScopes)=>{
-    if (!requestedScopes || requestedScopes.length === 0) {
-        var _scopedInstances_;
-        // Return first instance if no scopes specified
-        const firstInstance = (_scopedInstances_ = scopedInstances[0]) === null || _scopedInstances_ === void 0 ? void 0 : _scopedInstances_.instance;
-        if (!firstInstance) {
-            throw new Error('No instances available');
-        }
-        return firstInstance;
-    }
-    // Find instance that matches all requested scopes
-    const matchingInstance = scopedInstances.find((scopedInstance)=>{
-        if (!scopedInstance.scopes) return false;
-        return requestedScopes.every((scope)=>scopedInstance.scopes && scopedInstance.scopes.includes(scope));
-    });
-    if (!matchingInstance) {
-        throw new Error(`No instance found matching scopes: ${requestedScopes.join(', ')}`);
-    }
-    return matchingInstance.instance;
-};
-const createRegistry = (type, registryHub)=>{
-    const instanceTree = {};
-    // Statistics tracking
-    const registryStats = new RegistryStats();
-    /**
-   * Creates a proxied Registry that automatically injects client information for service-to-service calls
-   */ const createProxiedRegistry = (callingCoordinate)=>{
-        const serviceClient = {
-            registryType: type,
-            coordinate: {
-                kta: callingCoordinate.kta,
-                scopes: callingCoordinate.scopes
-            }
-        };
-        return {
-            ...registry,
-            get: (kta, options)=>{
-                // Automatically inject the calling service as the client if no client is specified
-                const clientToUse = (options === null || options === void 0 ? void 0 : options.client) || serviceClient;
-                return registry.get(kta, {
-                    ...options,
-                    client: clientToUse
-                });
-            }
-        };
-    };
-    const createInstance = (kta, scopes, factory)=>{
-        logger$1.debug(`Creating and registering instance for key path and scopes`, kta, scopes, `in registry type: ${type}`);
-        // Create coordinate for the instance
-        const coordinate = createCoordinate(kta, scopes);
-        // Create a proxied registry that automatically tracks this service as the client
-        const proxiedRegistry = createProxiedRegistry(coordinate);
-        // Use factory to create the instance with the proxied registry
-        const instance = factory(coordinate, {
-            registry: proxiedRegistry,
-            registryHub
-        });
-        // Validate the created instance
-        if (!isInstance(instance)) {
-            throw new Error(`Factory did not return a valid instance for: ${kta.join('.')}`);
-        }
-        // Register the instance
-        registerInternal(kta, instance, {
-            scopes
-        });
-        return instance;
-    };
-    const registerInternal = (kta, instance, options)=>{
-        const keyPath = [
-            ...kta
-        ].reverse(); // Work from most specific to least specific
-        let currentLevel = instanceTree;
-        logger$1.debug(`Registering instance for key path and scopes`, keyPath, options === null || options === void 0 ? void 0 : options.scopes, `in registry type: ${type}`);
-        if (!isInstance(instance)) {
-            throw new Error(`Attempting to register a non-instance: ${kta.join('.')}`);
-        }
-        // Navigate to the correct location in the tree
-        for(let i = 0; i < keyPath.length; i++){
-            const keyType = keyPath[i];
-            const isLeaf = i === keyPath.length - 1;
-            if (!currentLevel[keyType]) {
-                currentLevel[keyType] = {
-                    instances: [],
-                    children: isLeaf ? null : {}
-                };
-            }
-            if (isLeaf) {
-                // Add instance to the leaf node
-                currentLevel[keyType].instances.push({
-                    scopes: options === null || options === void 0 ? void 0 : options.scopes,
-                    instance
-                });
-            } else {
-                // Navigate deeper into the tree
-                if (!currentLevel[keyType].children) {
-                    currentLevel[keyType].children = {};
-                }
-                currentLevel = currentLevel[keyType].children;
-            }
-        }
-    };
-    const register = (kta, instance, options)=>{
-        logger$1.debug('Using deprecated register method. Consider using createInstance instead.');
-        registerInternal(kta, instance, options);
-    };
-    const get = (kta, options)=>{
-        // Track statistics with kta, scopes, and client
-        registryStats.recordGetCall(kta, options === null || options === void 0 ? void 0 : options.scopes, options === null || options === void 0 ? void 0 : options.client);
-        const keyPath = [
-            ...kta
-        ].reverse();
-        let currentLevel = instanceTree;
-        // Navigate to the target node
-        for(let i = 0; i < keyPath.length; i++){
-            const keyType = keyPath[i];
-            const isLeaf = i === keyPath.length - 1;
-            if (!currentLevel[keyType]) {
-                throw new Error(`Instance not found for key path: ${kta.join('.')}, Missing key: ${keyType}`);
-            }
-            if (isLeaf) {
-                // Found the target node, extract instance
-                const scopedInstances = currentLevel[keyType].instances;
-                if (scopedInstances.length === 0) {
-                    throw new Error(`No instances registered for key path: ${kta.join('.')}`);
-                }
-                return findScopedInstance(scopedInstances, options === null || options === void 0 ? void 0 : options.scopes);
-            } else {
-                // Continue navigation
-                if (!currentLevel[keyType].children) {
-                    throw new Error(`Instance not found for key path: ${kta.join('.')}, No children for: ${keyType}`);
-                }
-                currentLevel = currentLevel[keyType].children;
-            }
-        }
-        return null;
-    };
-    const getCoordinates = ()=>{
-        const coordinates = [];
-        const traverseTree = (node)=>{
-            for(const keyType in node){
-                const treeNode = node[keyType];
-                // Collect coordinates from instances at this level
-                for (const scopedInstance of treeNode.instances){
-                    coordinates.push(scopedInstance.instance.coordinate);
-                }
-                // Recursively traverse children if they exist
-                if (treeNode.children) {
-                    traverseTree(treeNode.children);
-                }
-            }
-        };
-        traverseTree(instanceTree);
-        return coordinates;
-    };
-    const getStatistics = ()=>{
-        return registryStats.getStatistics();
-    };
-    const registry = {
-        type,
-        registryHub,
-        createInstance,
-        register,
-        get,
-        getCoordinates,
-        getStatistics,
-        instanceTree
-    };
-    return registry;
-};
-
-/**
- * Base class for all registry-related errors
- */ function _define_property$3(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class RegistryError extends Error {
-    getDetails() {
-        const details = [
-            this.message
-        ];
-        if (this.registryType) {
-            details.push(`Registry Type: ${this.registryType}`);
-        }
-        if (this.context) {
-            details.push(`Context: ${JSON.stringify(this.context, null, 2)}`);
-        }
-        return details.join('\n');
-    }
-    constructor(message, registryType, context){
-        super(message), _define_property$3(this, "registryType", void 0), _define_property$3(this, "context", void 0);
-        this.name = this.constructor.name;
-        this.registryType = registryType;
-        this.context = context;
-        // Maintains proper stack trace for where our error was thrown
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-}
-/**
- * Thrown when attempting to create a registry with invalid parameters
- */ class RegistryCreationError extends RegistryError {
-    constructor(type, reason, context){
-        super(`Failed to create registry of type '${type}': ${reason}`, type, context);
-    }
-}
-/**
- * Thrown when a factory function returns an invalid instance
- */ class InvalidFactoryResultError extends RegistryError {
-    constructor(keyPath, factoryResult, registryType){
-        const keyPathStr = keyPath.join('.');
-        super(`Factory did not return a valid instance for: ${keyPathStr}. ` + `Expected instance with 'coordinate' and 'registry' properties, got: ${typeof factoryResult}`, registryType, {
-            keyPath,
-            factoryResult: typeof factoryResult
-        }), _define_property$3(this, "keyPath", void 0), _define_property$3(this, "factoryResult", void 0);
-        this.keyPath = keyPath;
-        this.factoryResult = factoryResult;
-    }
-}
-/**
- * Thrown when attempting to register a non-instance object
- */ class InvalidInstanceRegistrationError extends RegistryError {
-    constructor(keyPath, attemptedRegistration, registryType){
-        const keyPathStr = keyPath.join('.');
-        super(`Attempting to register a non-instance: ${keyPathStr}. ` + `Expected instance with 'coordinate' and 'registry' properties, got: ${typeof attemptedRegistration}`, registryType, {
-            keyPath,
-            attemptedRegistration: typeof attemptedRegistration
-        }), _define_property$3(this, "keyPath", void 0), _define_property$3(this, "attemptedRegistration", void 0);
-        this.keyPath = keyPath;
-        this.attemptedRegistration = attemptedRegistration;
-    }
-}
-
-function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Base class for registry hub-related errors
- */ class RegistryHubError extends RegistryError {
-    constructor(message, hubType, context){
-        const enrichedContext = hubType ? {
-            ...context,
-            hubType
-        } : context;
-        super(message, '', enrichedContext), _define_property$2(this, "hubType", void 0);
-        this.hubType = hubType;
-    }
-}
-/**
- * Thrown when attempting to register a registry with a type that already exists
- */ class DuplicateRegistryTypeError extends RegistryHubError {
-    constructor(type, context){
-        super(`Registry already registered under type: ${type}. ` + `Each registry type must be unique within a registry hub.`, '', {
-            ...context,
-            duplicateType: type
-        }), _define_property$2(this, "duplicateType", void 0);
-        this.duplicateType = type;
-    }
-}
-/**
- * Thrown when attempting to access a registry type that doesn't exist
- */ class RegistryTypeNotFoundError extends RegistryHubError {
-    constructor(requestedType, availableTypes = [], context){
-        let message = `No registry registered under type: ${requestedType}`;
-        if (availableTypes.length > 0) {
-            message += `. Available types: [${availableTypes.join(', ')}]`;
-        }
-        super(message, '', {
-            ...context,
-            requestedType,
-            availableTypes
-        }), _define_property$2(this, "requestedType", void 0), _define_property$2(this, "availableTypes", void 0);
-        this.requestedType = requestedType;
-        this.availableTypes = availableTypes;
-    }
-}
-/**
- * Thrown when a registry factory function fails to create a valid registry
- */ class RegistryFactoryError extends RegistryHubError {
-    constructor(type, factoryError, context){
-        super(`Registry factory failed to create registry of type '${type}': ${factoryError.message}`, '', {
-            ...context,
-            attemptedType: type,
-            originalError: factoryError.message
-        }), _define_property$2(this, "factoryError", void 0), _define_property$2(this, "attemptedType", void 0);
-        this.factoryError = factoryError;
-        this.attemptedType = type;
-    }
-}
-/**
- * Thrown when a factory returns an invalid registry object
- */ class InvalidRegistryFactoryResultError extends RegistryHubError {
-    constructor(type, factoryResult, context){
-        super(`Registry factory returned invalid registry for type '${type}'. ` + `Expected registry with 'type', 'get', 'register', and 'createInstance' properties, ` + `got: ${typeof factoryResult}`, '', {
-            ...context,
-            attemptedType: type,
-            factoryResult: typeof factoryResult
-        }), _define_property$2(this, "factoryResult", void 0), _define_property$2(this, "attemptedType", void 0);
-        this.factoryResult = factoryResult;
-        this.attemptedType = type;
-    }
-}
-
-const logger = LibLogger.get("RegistryHub");
-const createRegistryHub = ()=>{
-    const registries = {};
-    const createRegistry = (type, factory)=>{
-        logger.debug(`Creating new registry with type: ${type}`);
-        if (registries[type]) {
-            throw new DuplicateRegistryTypeError(type);
-        }
-        // Create the registry with a reference to this hub
-        const registry = factory(type, hub);
-        // Ensure the created registry has a reference to this hub if not already set
-        if (!('registryHub' in registry) || registry.registryHub !== hub) {
-            // @ts-expect-error: registryHub is optional and may be readonly, but we want to set it for hub awareness
-            registry.registryHub = hub;
-        }
-        // Register the created registry
-        registries[type] = registry;
-        logger.debug(`Successfully created and registered new registry with type: ${type}`);
-        return registry;
-    };
-    const registerRegistry = (registry)=>{
-        const type = registry.type;
-        logger.debug(`Registering registry with type: ${type}`);
-        if (registries[type]) {
-            throw new DuplicateRegistryTypeError(type);
-        }
-        registries[type] = registry;
-        // Ensure the created registry has a reference to this hub if not already set
-        if (!('registryHub' in registry) || registry.registryHub !== hub) {
-            // @ts-expect-error: registryHub is optional and may be readonly, but we want to set it for hub awareness
-            registry.registryHub = hub;
-        }
-        logger.debug(`Successfully registered registry with type: ${type}`);
-    };
-    const get = (type, kta, options)=>{
-        var _options_scopes;
-        logger.debug(`Looking up instance for type: ${type}, kta: ${kta.join('.')}, scopes: ${(options === null || options === void 0 ? void 0 : (_options_scopes = options.scopes) === null || _options_scopes === void 0 ? void 0 : _options_scopes.join(',')) || 'none'}`);
-        const registry = registries[type];
-        if (!registry) {
-            const availableTypes = Object.keys(registries);
-            throw new RegistryTypeNotFoundError(type, availableTypes);
-        }
-        return registry.get(kta, options);
-    };
-    const getRegistry = (type)=>{
-        return registries[type] || null;
-    };
-    const getRegisteredTypes = ()=>{
-        return Object.keys(registries);
-    };
-    const unregisterRegistry = (type)=>{
-        if (registries[type]) {
-            delete registries[type];
-            logger.debug(`Unregistered registry under type: ${type}`);
-            return true;
-        }
-        return false;
-    };
-    const getAllCoordinates = ()=>{
-        const allCoordinates = [];
-        for(const registryType in registries){
-            const registry = registries[registryType];
-            const coordinates = registry.getCoordinates();
-            coordinates.forEach((coordinate)=>{
-                allCoordinates.push({
-                    coordinate,
-                    registryType
-                });
-            });
-        }
-        logger.debug(`Retrieved ${allCoordinates.length} total coordinates from ${Object.keys(registries).length} registries`);
-        return allCoordinates;
-    };
-    const hub = {
-        createRegistry,
-        registerRegistry,
-        get,
-        getRegistry,
-        getRegisteredTypes,
-        getAllCoordinates,
-        unregisterRegistry
-    };
-    return hub;
-};
-
-function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Base class for instance-related errors
- */ class InstanceError extends RegistryError {
-    constructor(message, keyPath, registryType, context){
-        super(message, registryType, {
-            ...context,
-            keyPath
-        }), _define_property$1(this, "keyPath", void 0);
-        this.keyPath = keyPath;
-    }
-}
-/**
- * Thrown when an instance cannot be found for a given key path
- */ class InstanceNotFoundError extends InstanceError {
-    constructor(keyPath, missingKey, registryType, context){
-        const keyPathStr = keyPath.join('.');
-        let message = `Instance not found for key path: ${keyPathStr}`;
-        if (missingKey) {
-            message += `, Missing key: ${missingKey}`;
-        }
-        super(message, keyPath, registryType, {
-            ...context,
-            missingKey
-        }), _define_property$1(this, "missingKey", void 0);
-        this.missingKey = missingKey;
-    }
-}
-/**
- * Thrown when no instances are registered for a key path that exists in the tree
- */ class NoInstancesRegisteredError extends InstanceError {
-    constructor(keyPath, registryType, context){
-        const keyPathStr = keyPath.join('.');
-        super(`No instances registered for key path: ${keyPathStr}. ` + `The key path exists in the registry tree but contains no instances.`, keyPath, registryType, context);
-    }
-}
-/**
- * Thrown when no instances are available (empty instances array)
- */ class NoInstancesAvailableError extends InstanceError {
-    constructor(keyPath, registryType, context){
-        const keyPathStr = keyPath.join('.');
-        super(`No instances available for key path: ${keyPathStr}. ` + `This typically indicates an internal registry state issue.`, keyPath, registryType, context);
-    }
-}
-/**
- * Thrown when no instance matches the requested scopes
- */ class ScopeNotFoundError extends InstanceError {
-    constructor(keyPath, requestedScopes, availableScopes = [], registryType){
-        const keyPathStr = keyPath.join('.');
-        const scopesStr = requestedScopes.join(', ');
-        const availableScopesStr = availableScopes.map((scopes)=>`[${scopes.join(', ')}]`).join(', ');
-        let message = `No instance found matching scopes: ${scopesStr} for key path: ${keyPathStr}`;
-        if (availableScopes.length > 0) {
-            message += `. Available scopes: ${availableScopesStr}`;
-        }
-        super(message, keyPath, registryType, {
-            requestedScopes,
-            availableScopes
-        }), _define_property$1(this, "requestedScopes", void 0), _define_property$1(this, "availableScopes", void 0);
-        this.requestedScopes = requestedScopes;
-        this.availableScopes = availableScopes;
-    }
-}
-/**
- * Thrown when a key path has no children but children are expected
- */ class NoChildrenAvailableError extends InstanceError {
-    constructor(keyPath, parentKey, registryType, context){
-        const keyPathStr = keyPath.join('.');
-        super(`Instance not found for key path: ${keyPathStr}, No children for: ${parentKey}. ` + `The path cannot be traversed further as '${parentKey}' has no child nodes.`, keyPath, registryType, {
-            ...context,
-            parentKey
-        }), _define_property$1(this, "parentKey", void 0);
-        this.parentKey = parentKey;
-    }
-}
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Base class for coordinate-related errors
- */ class CoordinateError extends RegistryError {
-    constructor(message, kta, scopes, context){
-        super(message, '', {
-            ...context,
-            kta,
-            scopes
-        }), _define_property(this, "kta", void 0), _define_property(this, "scopes", void 0);
-        this.kta = kta;
-        this.scopes = scopes;
-    }
-}
-/**
- * Thrown when coordinate creation fails due to invalid parameters
- */ class InvalidCoordinateError extends CoordinateError {
-    constructor(kta, scopes, reason, context){
-        super(`Invalid coordinate parameters: ${reason}. ` + `KTA: ${JSON.stringify(kta)}, Scopes: [${scopes.join(', ')}]`, kta, scopes, {
-            ...context,
-            reason
-        });
-    }
-}
-/**
- * Thrown when KTA (Key Type Array) is invalid
- */ class InvalidKTAError extends CoordinateError {
-    constructor(kta, reason, context){
-        super(`Invalid KTA (Key Type Array): ${reason}. ` + `Expected string or array of strings, got: ${JSON.stringify(kta)}`, kta, [], {
-            ...context,
-            reason
-        });
-    }
-}
-/**
- * Thrown when scopes array contains invalid values
- */ class InvalidScopesError extends CoordinateError {
-    constructor(scopes, invalidScopes, reason, context){
-        super(`Invalid scopes: ${reason}. ` + `Invalid scope values: ${JSON.stringify(invalidScopes)}`, null, scopes.filter((s)=>typeof s === 'string'), {
-            ...context,
-            reason,
-            invalidScopes
-        }), _define_property(this, "invalidScopes", void 0);
-        this.invalidScopes = invalidScopes;
-    }
-}
-
-exports.CoordinateError = CoordinateError;
-exports.DuplicateRegistryTypeError = DuplicateRegistryTypeError;
-exports.InstanceError = InstanceError;
-exports.InstanceNotFoundError = InstanceNotFoundError;
-exports.InvalidCoordinateError = InvalidCoordinateError;
-exports.InvalidFactoryResultError = InvalidFactoryResultError;
-exports.InvalidInstanceRegistrationError = InvalidInstanceRegistrationError;
-exports.InvalidKTAError = InvalidKTAError;
-exports.InvalidRegistryFactoryResultError = InvalidRegistryFactoryResultError;
-exports.InvalidScopesError = InvalidScopesError;
-exports.NoChildrenAvailableError = NoChildrenAvailableError;
-exports.NoInstancesAvailableError = NoInstancesAvailableError;
-exports.NoInstancesRegisteredError = NoInstancesRegisteredError;
-exports.RegistryCreationError = RegistryCreationError;
-exports.RegistryError = RegistryError;
-exports.RegistryFactoryError = RegistryFactoryError;
-exports.RegistryHubError = RegistryHubError;
-exports.RegistryStats = RegistryStats;
-exports.RegistryTypeNotFoundError = RegistryTypeNotFoundError;
-exports.ScopeNotFoundError = ScopeNotFoundError;
-exports.createCoordinate = createCoordinate;
-exports.createInstance = createInstance;
-exports.createRegistry = createRegistry;
-exports.createRegistryHub = createRegistryHub;
-exports.isInstance = isInstance;
-//# sourceMappingURL=index.cjs.map