@fjell/registry 4.4.4 → 4.4.6

package/dist/index.cjs

@@ -7,166 +7,555 @@ const Logging = require('@fjell/logging');
 const LibLogger = Logging.getLogger('@fjell/registry');
 
 const logger$3 = LibLogger.get("Coordinate");
-const createCoordinate = (kta, scopes)=>{
+const createCoordinate = (kta, scopes = [])=>{
+    const ktArray = Array.isArray(kta) ? kta : [
+        kta
+    ];
     const toString = ()=>{
         logger$3.debug("toString", {
             kta,
             scopes
         });
-        return `${kta.join(', ')} - ${scopes.join(', ')}`;
+        return `${ktArray.join(', ')} - ${scopes.join(', ')}`;
     };
     logger$3.debug("createCoordinate", {
-        kta,
+        kta: ktArray,
         scopes,
         toString
     });
     return {
-        kta,
+        kta: ktArray,
         scopes,
         toString
     };
 };
 
-const logger$2 = LibLogger.get("Definition");
-const createDefinition = (coordinate)=>{
-    logger$2.debug("createDefinition", {
-        coordinate
-    });
-    return {
-        coordinate
-    };
-};
-
-const logger$1 = LibLogger.get("Instance");
-const createInstance = (definition, registry)=>{
-    logger$1.debug("createInstance", {
-        definition,
+const logger$2 = LibLogger.get("Instance");
+const createInstance = (registry, coordinate)=>{
+    logger$2.debug("createInstance", {
+        coordinate,
         registry
     });
     return {
-        definition,
+        coordinate,
         registry
     };
 };
 const isInstance = (instance)=>{
-    return instance !== null && instance !== undefined && instance.definition !== undefined && instance.registry !== undefined;
+    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.registry !== undefined;
 };
 
-const logger = LibLogger.get("Registry");
-const isScopedInstance = (instance)=>{
-    // eslint-disable-next-line no-undefined
-    return instance.instance !== undefined;
-};
-const retrieveScopedInstance = (scopedInstanceArray, scopes)=>{
-    let instance;
-    if (scopes) {
-        var _scopedInstanceArray_find;
-        instance = (_scopedInstanceArray_find = scopedInstanceArray.find((sl)=>{
-            return sl.scopes && scopes && scopes.every((scope)=>sl.scopes && sl.scopes.includes(scope));
-        })) === null || _scopedInstanceArray_find === void 0 ? void 0 : _scopedInstanceArray_find.instance;
-    } else {
-        var _scopedInstanceArray_;
-        instance = (_scopedInstanceArray_ = scopedInstanceArray[0]) === null || _scopedInstanceArray_ === void 0 ? void 0 : _scopedInstanceArray_.instance;
+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;
     }
-    if (!instance) {
-        throw new Error(`No Scoped Instance for ${scopes === null || scopes === void 0 ? void 0 : scopes.join(', ')}`);
+    // 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 instance;
+    return matchingInstance.instance;
 };
-const createRegistry = ()=>{
-    // TODO: My use of Generics has Boxes be into a corner where I can't reference AbstractLib without the types
-    const libTree = {};
-    const register = (kta, instance, options)=>{
-        const ktaArray = [
+const createRegistry = (type, registryHub)=>{
+    const instanceTree = {};
+    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);
+        // Use factory to create the instance with the new context parameter
+        const instance = factory(coordinate, {
+            registry,
+            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
-        ];
-        let currentTree = libTree;
-        logger.debug(`Registering lib for KTA and scopes`, ktaArray, options === null || options === void 0 ? void 0 : options.scopes);
+        ].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 as an instance: ${ktaArray.join('.')}`);
-        }
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0) {
-                    if (!currentTree[kt]) {
-                        currentTree[kt] = [
-                            [],
-                            null
-                        ];
-                    }
-                    currentTree[kt][0].push({
-                        scopes: options === null || options === void 0 ? void 0 : options.scopes,
-                        instance
-                    });
-                } else {
-                    if (!currentTree[kt]) {
-                        const newTree = {};
-                        currentTree[kt] = [
-                            [],
-                            newTree
-                        ];
-                        currentTree = newTree;
-                    } else if (!currentTree[kt][1]) {
-                        const newTree = {};
-                        currentTree[kt][1] = newTree;
-                        currentTree = newTree;
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
-                }
+            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 {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${ktaArray.join('.')}`);
+                // 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)=>{
-        const ktaArray = [
+        const keyPath = [
             ...kta
-        ];
-        let currentTree = libTree;
-        let instance = null;
-        // logger.debug(`Getting lib for KTA and scopes`, ktaArray, options?.scopes);
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0 && currentTree[kt]) {
-                    const element = currentTree[kt];
-                    const scopedInstanceArray = element[0];
-                    if (scopedInstanceArray.length > 0 && isScopedInstance(scopedInstanceArray[0])) {
-                        instance = retrieveScopedInstance(scopedInstanceArray, options === null || options === void 0 ? void 0 : options.scopes);
-                        // eslint-disable-next-line max-depth
-                        if (!instance) {
-                            var _options_scopes;
-                            throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Scopes: ${options === null || options === void 0 ? void 0 : (_options_scopes = options.scopes) === null || _options_scopes === void 0 ? void 0 : _options_scopes.join(', ')}`);
-                        }
-                    } else {
-                        throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Last Key not a instance: ${kt}`);
-                    }
-                } else {
-                    if (!currentTree[kt]) {
-                        throw new Error(`Lib not found for kta: ${JSON.stringify(ktaArray)}, Subtree Not Found: ${kt}`);
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
+        ].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 {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${JSON.stringify(ktaArray)}`);
+                // 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 instance;
+        return null;
     };
-    return {
+    const registry = {
+        type,
+        registryHub,
+        createInstance,
         register,
         get,
-        // TODO: Remove this once we have a better way to test
-        libTree
+        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 hub = {
+        createRegistry,
+        registerRegistry,
+        get,
+        getRegistry,
+        getRegisteredTypes,
+        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.RegistryTypeNotFoundError = RegistryTypeNotFoundError;
+exports.ScopeNotFoundError = ScopeNotFoundError;
 exports.createCoordinate = createCoordinate;
-exports.createDefinition = createDefinition;
 exports.createInstance = createInstance;
 exports.createRegistry = createRegistry;
+exports.createRegistryHub = createRegistryHub;
 exports.isInstance = isInstance;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from './Coordinate';
-export * from './Definition';
 export * from './Instance';
 export * from './Registry';
+export * from './RegistryHub';
+export * from './types';
+export * from './errors';