@fjell/registry 4.4.9 → 4.4.11

package/dist/Registry.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const logger$1 = require('./logger.cjs');
 const Instance = require('./Instance.cjs');
 const Coordinate = require('./Coordinate.cjs');
+const RegistryStats = require('./RegistryStats.cjs');
 
 const logger = logger$1.default.get("Registry");
 const findScopedInstance = (scopedInstances, requestedScopes)=>{
@@ -29,13 +30,39 @@ const findScopedInstance = (scopedInstances, requestedScopes)=>{
 };
 const createRegistry = (type, registryHub)=>{
     const instanceTree = {};
+    // Statistics tracking
+    const registryStats = new RegistryStats.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.debug(`Creating and registering instance for key path and scopes`, kta, scopes, `in registry type: ${type}`);
         // Create coordinate for the instance
         const coordinate = Coordinate.createCoordinate(kta, scopes);
-        // Use factory to create the instance with the new context parameter
+        // 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,
+            registry: proxiedRegistry,
             registryHub
         });
         // Validate the created instance
@@ -87,6 +114,8 @@ const createRegistry = (type, registryHub)=>{
         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();
@@ -133,6 +162,9 @@ const createRegistry = (type, registryHub)=>{
         traverseTree(instanceTree);
         return coordinates;
     };
+    const getStatistics = ()=>{
+        return registryStats.getStatistics();
+    };
     const registry = {
         type,
         registryHub,
@@ -140,10 +172,11 @@ const createRegistry = (type, registryHub)=>{
         register,
         get,
         getCoordinates,
+        getStatistics,
         instanceTree
     };
     return registry;
 };
 
 exports.createRegistry = createRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Registry.js

@@ -1,6 +1,7 @@
 import LibLogger from './logger.js';
 import { isInstance } from './Instance.js';
 import { createCoordinate } from './Coordinate.js';
+import { RegistryStats } from './RegistryStats.js';
 
 const logger = LibLogger.get("Registry");
 const findScopedInstance = (scopedInstances, requestedScopes)=>{
@@ -25,13 +26,39 @@ const findScopedInstance = (scopedInstances, requestedScopes)=>{
 };
 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.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
+        // 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,
+            registry: proxiedRegistry,
             registryHub
         });
         // Validate the created instance
@@ -83,6 +110,8 @@ const createRegistry = (type, registryHub)=>{
         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();
@@ -129,6 +158,9 @@ const createRegistry = (type, registryHub)=>{
         traverseTree(instanceTree);
         return coordinates;
     };
+    const getStatistics = ()=>{
+        return registryStats.getStatistics();
+    };
     const registry = {
         type,
         registryHub,
@@ -136,10 +168,11 @@ const createRegistry = (type, registryHub)=>{
         register,
         get,
         getCoordinates,
+        getStatistics,
         instanceTree
     };
     return registry;
 };
 
 export { createRegistry };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/RegistryStats.cjs

@@ -0,0 +1,200 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/**
+ * Represents a service client (another service making the request)
+ */ 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;
+}
+/**
+ * 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(this, "totalCalls", 0);
+        // Map structure: ktaKey -> scopeKey -> clientKey -> count
+        _define_property(this, "coordinateCalls", new Map());
+    }
+}
+
+exports.RegistryStats = RegistryStats;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlTdGF0cy5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/RegistryStats.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Represents a service client (another service making the request)
+ */
+export interface ServiceClient {
+    /** The type of registry where the calling service is registered */
+    registryType: string;
+    /** The coordinate of the calling service */
+    coordinate: {
+        kta: string[];
+        scopes: string[];
+    };
+}
+/**
+ * Represents either a service or application client
+ */
+export type ClientIdentifier = ServiceClient | string;
+/**
+ * Represents a specific coordinate call with both kta and scopes
+ */
+export interface CoordinateCallRecord {
+    /** The key type array that was requested */
+    kta: string[];
+    /** The scopes that were requested (empty array if no scopes) */
+    scopes: string[];
+    /** Number of times this exact combination was called */
+    count: number;
+    /** Breakdown of calls by client */
+    clientCalls: ClientCallRecord[];
+}
+/**
+ * Represents calls from a specific client
+ */
+export interface ClientCallRecord {
+    /** The client that made the calls */
+    client: ClientIdentifier;
+    /** Number of calls from this client */
+    count: number;
+}
+/**
+ * Statistics about Registry get() method calls with detailed coordinate tracking
+ */
+export interface RegistryStatistics {
+    /** Total number of get() calls made on this registry */
+    totalGetCalls: number;
+    /** Detailed records of each unique coordinate combination and their call counts */
+    coordinateCallRecords: CoordinateCallRecord[];
+    /** Summary of calls by client type */
+    clientSummary: {
+        /** Total calls from services (service-to-service) */
+        serviceCalls: number;
+        /** Total calls from applications (direct application calls) */
+        applicationCalls: number;
+        /** Total calls with no client specified */
+        unidentifiedCalls: number;
+    };
+}
+/**
+ * Internal class for tracking Registry statistics with complex coordinate combinations and client tracking
+ */
+export declare class RegistryStats {
+    private totalCalls;
+    private coordinateCalls;
+    /**
+     * Records a get() call for the specified coordinate and client
+     */
+    recordGetCall(kta: string[], scopes?: string[], client?: ClientIdentifier): void;
+    /**
+     * Gets the current statistics snapshot
+     */
+    getStatistics(): RegistryStatistics;
+    /**
+     * Gets call count for a specific coordinate combination
+     */
+    getCallCount(kta: string[], scopes?: string[]): number;
+    /**
+     * Gets call count for a specific coordinate combination from a specific client
+     */
+    getCallCountByClient(kta: string[], scopes?: string[], client?: ClientIdentifier): number;
+    /**
+     * Gets total calls for a specific kta (across all scopes)
+     */
+    getTotalCallsForKta(kta: string[]): number;
+    /**
+     * Gets all unique kta paths that have been called
+     */
+    getCalledKtaPaths(): string[][];
+    /**
+     * Creates a normalized scope key from scopes array
+     */
+    private createScopeKey;
+    /**
+     * Parses a scope key back to scopes array
+     */
+    private parseScopeKey;
+    /**
+     * Creates a normalized client key from client identifier
+     */
+    private createClientKey;
+    /**
+     * Parses a client key back to client identifier
+     */
+    private parseClientKey;
+}

package/dist/RegistryStats.js

@@ -0,0 +1,196 @@
+/**
+ * Represents a service client (another service making the request)
+ */ 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;
+}
+/**
+ * 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(this, "totalCalls", 0);
+        // Map structure: ktaKey -> scopeKey -> clientKey -> count
+        _define_property(this, "coordinateCalls", new Map());
+    }
+}
+
+export { RegistryStats };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlTdGF0cy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=