@fjell/registry 4.4.5 → 4.4.7

package/dist/errors/CoordinateError.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const RegistryError = require('./RegistryError.cjs');
+
+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.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.InvalidCoordinateError = InvalidCoordinateError;
+exports.InvalidKTAError = InvalidKTAError;
+exports.InvalidScopesError = InvalidScopesError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZUVycm9yLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/errors/CoordinateError.d.ts

@@ -0,0 +1,28 @@
+import { RegistryError } from './RegistryError';
+/**
+ * Base class for coordinate-related errors
+ */
+export declare abstract class CoordinateError extends RegistryError {
+    readonly kta?: any;
+    readonly scopes?: string[];
+    constructor(message: string, kta?: any, scopes?: string[], context?: Record<string, any>);
+}
+/**
+ * Thrown when coordinate creation fails due to invalid parameters
+ */
+export declare class InvalidCoordinateError extends CoordinateError {
+    constructor(kta: any, scopes: string[], reason: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when KTA (Key Type Array) is invalid
+ */
+export declare class InvalidKTAError extends CoordinateError {
+    constructor(kta: any, reason: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when scopes array contains invalid values
+ */
+export declare class InvalidScopesError extends CoordinateError {
+    readonly invalidScopes: any[];
+    constructor(scopes: any[], invalidScopes: any[], reason: string, context?: Record<string, any>);
+}

package/dist/errors/CoordinateError.js

@@ -0,0 +1,63 @@
+import { RegistryError } from './RegistryError.js';
+
+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;
+    }
+}
+
+export { CoordinateError, InvalidCoordinateError, InvalidKTAError, InvalidScopesError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZUVycm9yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/errors/InstanceError.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const RegistryError = require('./RegistryError.cjs');
+
+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 instance-related errors
+ */ class InstanceError extends RegistryError.RegistryError {
+    constructor(message, keyPath, registryType, context){
+        super(message, registryType, {
+            ...context,
+            keyPath
+        }), _define_property(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(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(this, "requestedScopes", void 0), _define_property(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(this, "parentKey", void 0);
+        this.parentKey = parentKey;
+    }
+}
+
+exports.InstanceError = InstanceError;
+exports.InstanceNotFoundError = InstanceNotFoundError;
+exports.NoChildrenAvailableError = NoChildrenAvailableError;
+exports.NoInstancesAvailableError = NoInstancesAvailableError;
+exports.NoInstancesRegisteredError = NoInstancesRegisteredError;
+exports.ScopeNotFoundError = ScopeNotFoundError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VFcnJvci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/errors/InstanceError.d.ts

@@ -0,0 +1,42 @@
+import { RegistryError } from './RegistryError';
+/**
+ * Base class for instance-related errors
+ */
+export declare abstract class InstanceError extends RegistryError {
+    readonly keyPath: string[];
+    constructor(message: string, keyPath: string[], registryType?: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when an instance cannot be found for a given key path
+ */
+export declare class InstanceNotFoundError extends InstanceError {
+    readonly missingKey?: string;
+    constructor(keyPath: string[], missingKey?: string, registryType?: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when no instances are registered for a key path that exists in the tree
+ */
+export declare class NoInstancesRegisteredError extends InstanceError {
+    constructor(keyPath: string[], registryType?: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when no instances are available (empty instances array)
+ */
+export declare class NoInstancesAvailableError extends InstanceError {
+    constructor(keyPath: string[], registryType?: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when no instance matches the requested scopes
+ */
+export declare class ScopeNotFoundError extends InstanceError {
+    readonly requestedScopes: string[];
+    readonly availableScopes: string[][];
+    constructor(keyPath: string[], requestedScopes: string[], availableScopes?: string[][], registryType?: string);
+}
+/**
+ * Thrown when a key path has no children but children are expected
+ */
+export declare class NoChildrenAvailableError extends InstanceError {
+    readonly parentKey: string;
+    constructor(keyPath: string[], parentKey: string, registryType?: string, context?: Record<string, any>);
+}

package/dist/errors/InstanceError.js

@@ -0,0 +1,92 @@
+import { RegistryError } from './RegistryError.js';
+
+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 instance-related errors
+ */ class InstanceError extends RegistryError {
+    constructor(message, keyPath, registryType, context){
+        super(message, registryType, {
+            ...context,
+            keyPath
+        }), _define_property(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(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(this, "requestedScopes", void 0), _define_property(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(this, "parentKey", void 0);
+        this.parentKey = parentKey;
+    }
+}
+
+export { InstanceError, InstanceNotFoundError, NoChildrenAvailableError, NoInstancesAvailableError, NoInstancesRegisteredError, ScopeNotFoundError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VFcnJvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/errors/RegistryError.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/**
+ * Base class for all registry-related errors
+ */ 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;
+}
+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(this, "registryType", void 0), _define_property(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(this, "keyPath", void 0), _define_property(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(this, "keyPath", void 0), _define_property(this, "attemptedRegistration", void 0);
+        this.keyPath = keyPath;
+        this.attemptedRegistration = attemptedRegistration;
+    }
+}
+
+exports.InvalidFactoryResultError = InvalidFactoryResultError;
+exports.InvalidInstanceRegistrationError = InvalidInstanceRegistrationError;
+exports.RegistryCreationError = RegistryCreationError;
+exports.RegistryError = RegistryError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlFcnJvci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/errors/RegistryError.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Base class for all registry-related errors
+ */
+export declare abstract class RegistryError extends Error {
+    readonly registryType?: string;
+    readonly context?: Record<string, any>;
+    constructor(message: string, registryType?: string, context?: Record<string, any>);
+    getDetails(): string;
+}
+/**
+ * Thrown when attempting to create a registry with invalid parameters
+ */
+export declare class RegistryCreationError extends RegistryError {
+    constructor(type: string, reason: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when a factory function returns an invalid instance
+ */
+export declare class InvalidFactoryResultError extends RegistryError {
+    readonly keyPath: string[];
+    readonly factoryResult: any;
+    constructor(keyPath: string[], factoryResult: any, registryType?: string);
+}
+/**
+ * Thrown when attempting to register a non-instance object
+ */
+export declare class InvalidInstanceRegistrationError extends RegistryError {
+    readonly keyPath: string[];
+    readonly attemptedRegistration: any;
+    constructor(keyPath: string[], attemptedRegistration: any, registryType?: string);
+}

package/dist/errors/RegistryError.js

@@ -0,0 +1,75 @@
+/**
+ * Base class for all registry-related errors
+ */ 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;
+}
+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(this, "registryType", void 0), _define_property(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(this, "keyPath", void 0), _define_property(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(this, "keyPath", void 0), _define_property(this, "attemptedRegistration", void 0);
+        this.keyPath = keyPath;
+        this.attemptedRegistration = attemptedRegistration;
+    }
+}
+
+export { InvalidFactoryResultError, InvalidInstanceRegistrationError, RegistryCreationError, RegistryError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlFcnJvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/errors/RegistryHubError.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const RegistryError = require('./RegistryError.cjs');
+
+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 registry hub-related errors
+ */ class RegistryHubError extends RegistryError.RegistryError {
+    constructor(message, hubType, context){
+        const enrichedContext = hubType ? {
+            ...context,
+            hubType
+        } : context;
+        super(message, '', enrichedContext), _define_property(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(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(this, "requestedType", void 0), _define_property(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(this, "factoryError", void 0), _define_property(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(this, "factoryResult", void 0), _define_property(this, "attemptedType", void 0);
+        this.factoryResult = factoryResult;
+        this.attemptedType = type;
+    }
+}
+
+exports.DuplicateRegistryTypeError = DuplicateRegistryTypeError;
+exports.InvalidRegistryFactoryResultError = InvalidRegistryFactoryResultError;
+exports.RegistryFactoryError = RegistryFactoryError;
+exports.RegistryHubError = RegistryHubError;
+exports.RegistryTypeNotFoundError = RegistryTypeNotFoundError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWJFcnJvci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==