@olane/o-node 0.7.46 → 0.7.48

package/dist/src/connection/o-node-connection.manager.d.ts

@@ -5,58 +5,55 @@ import { oNodeConnection } from './o-node-connection.js';
 export declare class oNodeConnectionManager extends oConnectionManager {
     readonly config: oNodeConnectionManagerConfig;
     protected p2pNode: Libp2p;
-    private defaultReadTimeoutMs?;
-    private defaultDrainTimeoutMs?;
-    private connectionsByAddress;
-    private pendingDialsByAddress;
-    /** Cache of oNodeConnection instances keyed by p2p connection ID */
-    private nodeConnectionByConnectionId;
+    protected defaultReadTimeoutMs?: number;
+    protected defaultDrainTimeoutMs?: number;
+    /** Single cache of oNodeConnection instances keyed by address */
+    protected cachedConnections: Map<string, oNodeConnection[]>;
+    protected pendingDialsByAddress: Map<string, Promise<Connection>>;
     constructor(config: oNodeConnectionManagerConfig);
     /**
      * Set up listeners to maintain connection cache state
      */
-    private setupConnectionListeners;
+    protected setupConnectionListeners(): void;
     /**
      * Build a stable cache key from an address.
      *
      * We key the cache by address value (e.g., "o://my-tool") to maintain
      * a simple one-to-one mapping between addresses and connections.
      */
-    private getAddressKey;
+    protected getAddressKey(address: oAddress): string | null;
     /**
      * Extract peer ID string from an address
      * @param address - The address to extract peer ID from
      * @returns The peer ID string or null if not found
      */
-    private getPeerIdFromAddress;
+    protected getPeerIdFromAddress(address: oAddress): string | null;
     /**
-     * Select the best connection from an array of connections.
-     * Prioritizes connections with active streams, then by direction based on context.
+     * Get the first valid (open) connection for the given address key.
+     * Cleans up stale connections from the cache automatically.
      *
-     * @param connections - Array of connections to choose from
-     * @param reuseContext - If true, prefer inbound connections; otherwise prefer outbound
-     * @returns The best connection or null if none are suitable
-     */
-    private selectBestConnection;
-    /**
-     * Get a cached oNodeConnection for the given p2p connection if it exists and is valid.
-     * @param p2pConnection - The p2p connection to look up
+     * @param addressKey - The address key to look up
      * @returns A valid oNodeConnection or null if none found
      */
-    private getCachedNodeConnection;
+    protected getValidConnection(addressKey: string): oNodeConnection | null;
     /**
-     * Cache an oNodeConnection by its p2p connection ID for potential reuse.
+     * Cache an oNodeConnection by its address key.
      * @param conn - The oNodeConnection to cache
+     * @param addressKey - The address key to cache under
+     */
+    protected cacheConnection(conn: oNodeConnection, addressKey: string): void;
+    /**
+     * Get or create a raw p2p connection to the given address.
+     * Subclasses can override connect() and use this method to get the underlying p2p connection.
      */
-    private cacheNodeConnection;
-    getOrCreateConnection(nextHopAddress: oAddress, address: oAddress): Promise<Connection>;
-    private performDial;
+    protected getOrCreateP2pConnection(nextHopAddress: oAddress, addressKey: string): Promise<Connection>;
+    protected performDial(nextHopAddress: oAddress, addressKey: string): Promise<Connection>;
     answer(config: oConnectionConfig & {
         p2pConnection: Connection;
         reuse?: boolean;
     }): Promise<oNodeConnection>;
     /**
-     * Connect to a given address, reusing oNodeConnection and libp2p connections when possible
+     * Connect to a given address, reusing oNodeConnection when possible
      * @param config - Connection configuration
      * @returns The connection object
      */
@@ -68,11 +65,11 @@ export declare class oNodeConnectionManager extends oConnectionManager {
      */
     isCached(address: oAddress): boolean;
     /**
-     * Get an existing connection to the target peer (from cache or libp2p)
+     * Get an existing cached oNodeConnection for the target address
      * @param address - The address to get a connection for
-     * @returns The Connection object or null if not found
+     * @returns The oNodeConnection or null if not found
      */
-    getCachedLibp2pConnection(address: oAddress): Connection | null;
+    getCachedConnection(address: oAddress): oNodeConnection | null;
     /**
      * Get cache statistics for monitoring and debugging
      * @returns Object containing cache statistics
@@ -81,7 +78,6 @@ export declare class oNodeConnectionManager extends oConnectionManager {
         cachedAddresses: number;
         totalCachedConnections: number;
         pendingDials: number;
-        cachedNodeConnections: number;
         connectionsByPeer: Array<{
             peerId: string;
             status: string;
@@ -93,10 +89,5 @@ export declare class oNodeConnectionManager extends oConnectionManager {
      * @returns Number of connections removed
      */
     cleanupStaleConnections(): number;
-    /**
-     * Clean up all stale oNodeConnections from cache
-     * @returns Number of oNodeConnections removed
-     */
-    cleanupStaleNodeConnections(): number;
 }
 //# sourceMappingURL=o-node-connection.manager.d.ts.map

package/dist/src/connection/o-node-connection.manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAUhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IATzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,oBAAoB,CAAwC;IACpE,OAAO,CAAC,qBAAqB,CAA+C;IAC5E,oEAAoE;IACpE,OAAO,CAAC,4BAA4B,CACxB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAyChC;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IASrB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IA8D5B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAc/B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAIrB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YAgFR,WAAW;IAwBnB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IA2C3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA6ClE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAiDpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA6D/D;;;OAGG;IACH,aAAa,IAAI;QACf,eAAe,EAAE,MAAM,CAAC;QACxB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;QACrB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,iBAAiB,EAAE,KAAK,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;KACJ;IA6BD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;IA6BjC;;;OAGG;IACH,2BAA2B,IAAI,MAAM;CAgBtC"}
+{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACxC,SAAS,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IACzC,iEAAiE;IACjE,SAAS,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAa;IACxE,SAAS,CAAC,qBAAqB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAa;gBAEzD,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,SAAS,CAAC,wBAAwB,IAAI,IAAI;IA+B1C;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI;IASzD;;;;OAIG;IACH,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI;IAahE;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAkBxE;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAY1E;;;OAGG;cACa,wBAAwB,CACtC,cAAc,EAAE,QAAQ,EACxB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC;cAoCN,WAAW,CACzB,cAAc,EAAE,QAAQ,EACxB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC;IAqBhB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IAqD3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAyDlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAcpC;;;;OAIG;IACH,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI;IAc9D;;;OAGG;IACH,aAAa,IAAI;QACf,eAAe,EAAE,MAAM,CAAC;QACxB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,KAAK,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;KACJ;IAyBD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;CAuBlC"}

package/dist/src/connection/o-node-connection.manager.js

@@ -4,10 +4,9 @@ export class oNodeConnectionManager extends oConnectionManager {
     constructor(config) {
         super(config);
         this.config = config;
-        this.connectionsByAddress = new Map();
+        /** Single cache of oNodeConnection instances keyed by address */
+        this.cachedConnections = new Map();
         this.pendingDialsByAddress = new Map();
-        /** Cache of oNodeConnection instances keyed by p2p connection ID */
-        this.nodeConnectionByConnectionId = new Map();
         this.p2pNode = config.p2pNode;
         this.defaultReadTimeoutMs = config.defaultReadTimeoutMs;
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
@@ -24,31 +23,18 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (!connection) {
                 return;
             }
-            // Clean up libp2p connection cache
-            // for (const [
-            //   addressKey,
-            //   cachedConnections,
-            // ] of this.connectionsByAddress.entries()) {
-            //   const index = cachedConnections.indexOf(connection);
-            //   if (index !== -1) {
-            //     this.logger.debug(
-            //       'Connection closed, removing from cache for address:',
-            //       addressKey,
-            //     );
-            //     cachedConnections.splice(index, 1);
-            //     // Remove the address key entirely if no connections remain
-            //     if (cachedConnections.length === 0) {
-            //       this.connectionsByAddress.delete(addressKey);
-            //     } else {
-            //       this.connectionsByAddress.set(addressKey, cachedConnections);
-            //     }
-            //   }
-            // }
-            // Clean up oNodeConnection cache by connection ID
             const connectionId = connection.id;
-            if (this.nodeConnectionByConnectionId.has(connectionId)) {
-                this.logger.debug('Connection closed, removing oNodeConnection for connection ID:', connectionId);
-                this.nodeConnectionByConnectionId.delete(connectionId);
+            // Clean up cached connections by filtering out the closed connection
+            for (const [key, conns] of this.cachedConnections.entries()) {
+                const filtered = conns.filter((c) => c.p2pConnection.id !== connectionId);
+                if (filtered.length === 0) {
+                    this.logger.debug('Connection closed, removing all cached connections for address:', key);
+                    this.cachedConnections.delete(key);
+                }
+                else if (filtered.length !== conns.length) {
+                    this.logger.debug('Connection closed, updating cached connections for address:', key);
+                    this.cachedConnections.set(key, filtered);
+                }
             }
         });
     }
@@ -86,117 +72,53 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
     }
     /**
-     * Select the best connection from an array of connections.
-     * Prioritizes connections with active streams, then by direction based on context.
+     * Get the first valid (open) connection for the given address key.
+     * Cleans up stale connections from the cache automatically.
      *
-     * @param connections - Array of connections to choose from
-     * @param reuseContext - If true, prefer inbound connections; otherwise prefer outbound
-     * @returns The best connection or null if none are suitable
+     * @param addressKey - The address key to look up
+     * @returns A valid oNodeConnection or null if none found
      */
-    selectBestConnection(connections, reuseContext = false) {
-        // Filter to only open connections
-        const openConnections = connections.filter((c) => c.status === 'open');
-        if (openConnections.length === 0) {
-            return null;
-        }
-        // Priority 1: Connections with active o-protocol streams
-        const connectionsWithStreams = openConnections
-            .map((conn) => ({
-            conn,
-            activeStreamCount: conn.streams.filter((s) => s.protocol.includes('/o/') &&
-                s.status === 'open' &&
-                s.writeStatus === 'writable' &&
-                s.remoteReadStatus === 'readable').length,
-        }))
-            .filter((item) => item.activeStreamCount > 0)
-            .sort((a, b) => b.activeStreamCount - a.activeStreamCount);
-        if (connectionsWithStreams.length > 0) {
-            this.logger.debug('Selected connection with active streams', {
-                streamCount: connectionsWithStreams[0].activeStreamCount,
-            });
-            return connectionsWithStreams[0].conn;
-        }
-        // Priority 2: Based on reuse context
-        if (reuseContext) {
-            // Prefer inbound connections
-            const inbound = openConnections.find((c) => c.direction === 'inbound' || !c.direction);
-            if (inbound) {
-                this.logger.debug('Selected inbound connection (reuse context)');
-                return inbound;
+    getValidConnection(addressKey) {
+        const connections = this.cachedConnections.get(addressKey) || [];
+        // Filter to open connections
+        const valid = connections.filter((c) => c.p2pConnection?.status === 'open');
+        // Update cache if we cleaned any stale connections
+        if (valid.length !== connections.length) {
+            if (valid.length === 0) {
+                this.cachedConnections.delete(addressKey);
             }
-        }
-        else {
-            // Prefer outbound connections
-            const outbound = openConnections.find((c) => c.direction === 'outbound');
-            if (outbound) {
-                this.logger.debug('Selected outbound connection (non-reuse context)');
-                return outbound;
+            else {
+                this.cachedConnections.set(addressKey, valid);
             }
         }
-        // Priority 3: Return first open connection
-        this.logger.debug('Selected first available open connection', connectionsWithStreams);
-        return openConnections[0];
+        return valid[0] ?? null;
     }
     /**
-     * Get a cached oNodeConnection for the given p2p connection if it exists and is valid.
-     * @param p2pConnection - The p2p connection to look up
-     * @returns A valid oNodeConnection or null if none found
+     * Cache an oNodeConnection by its address key.
+     * @param conn - The oNodeConnection to cache
+     * @param addressKey - The address key to cache under
      */
-    getCachedNodeConnection(p2pConnection) {
-        const cached = this.nodeConnectionByConnectionId.get(p2pConnection.id);
-        if (cached && cached.p2pConnection?.status === 'open') {
-            return cached;
-        }
-        // Clean up stale entry if connection is no longer open
-        if (cached) {
-            this.nodeConnectionByConnectionId.delete(p2pConnection.id);
-        }
-        return null;
+    cacheConnection(conn, addressKey) {
+        this.logger.debug('Caching connection for address:', addressKey, conn.p2pConnection.id, conn.p2pConnection.direction);
+        const existing = this.cachedConnections.get(addressKey) || [];
+        existing.push(conn);
+        this.cachedConnections.set(addressKey, existing);
     }
     /**
-     * Cache an oNodeConnection by its p2p connection ID for potential reuse.
-     * @param conn - The oNodeConnection to cache
+     * Get or create a raw p2p connection to the given address.
+     * Subclasses can override connect() and use this method to get the underlying p2p connection.
      */
-    cacheNodeConnection(conn) {
-        this.nodeConnectionByConnectionId.set(conn.p2pConnection.id, conn);
-    }
-    async getOrCreateConnection(nextHopAddress, address) {
-        if (!nextHopAddress) {
-            throw new Error('Invalid address passed');
-        }
-        // Build an address-based cache key from the next hop address
-        const addressKey = this.getAddressKey(nextHopAddress);
-        if (!addressKey) {
-            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
-        }
-        // Check if we have cached connections by address key
-        const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
-        const bestConnection = this.selectBestConnection(cachedConnections, false);
-        if (bestConnection) {
-            this.logger.debug('Reusing cached connection for address:', nextHopAddress?.value, bestConnection.id);
-            return bestConnection;
-        }
-        // Clean up stale connections if they exist but are not open
-        if (cachedConnections.length > 0) {
-            const openConnections = cachedConnections.filter((c) => c.status === 'open');
-            if (openConnections.length === 0) {
-                this.logger.debug('Removing all stale connections for address:', addressKey);
-                this.connectionsByAddress.delete(addressKey);
-            }
-            else if (openConnections.length < cachedConnections.length) {
-                this.logger.debug('Cleaning up some stale connections for address:', addressKey);
-                this.connectionsByAddress.set(addressKey, openConnections);
+    async getOrCreateP2pConnection(nextHopAddress, addressKey) {
+        // Check if libp2p already has an active connection for this peer
+        const peerId = this.getPeerIdFromAddress(nextHopAddress);
+        if (peerId) {
+            const connections = this.p2pNode.getConnections();
+            const existingConnection = connections.find((conn) => conn.remotePeer?.toString() === peerId && conn.status === 'open');
+            if (existingConnection) {
+                this.logger.debug('Found existing libp2p connection for address:', addressKey);
+                return existingConnection;
             }
         }
-        // Check if libp2p has an active connection for this address
-        const libp2pConnection = this.getCachedLibp2pConnection(nextHopAddress);
-        if (libp2pConnection && libp2pConnection.status === 'open') {
-            this.logger.debug('Caching existing libp2p connection for address:', addressKey);
-            const connections = this.connectionsByAddress.get(addressKey) || [];
-            connections.push(libp2pConnection);
-            this.connectionsByAddress.set(addressKey, connections);
-            return libp2pConnection;
-        }
         // Check if dial is already in progress for this address key
         const pendingDial = this.pendingDialsByAddress.get(addressKey);
         if (pendingDial) {
@@ -207,12 +129,7 @@ export class oNodeConnectionManager extends oConnectionManager {
         const dialPromise = this.performDial(nextHopAddress, addressKey);
         this.pendingDialsByAddress.set(addressKey, dialPromise);
         try {
-            const connection = await dialPromise;
-            // Add the established connection to the cache array
-            const connections = this.connectionsByAddress.get(addressKey) || [];
-            connections.push(connection);
-            this.connectionsByAddress.set(addressKey, connections);
-            return connection;
+            return await dialPromise;
         }
         finally {
             this.pendingDialsByAddress.delete(addressKey);
@@ -233,6 +150,17 @@ export class oNodeConnectionManager extends oConnectionManager {
     }
     async answer(config) {
         const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, reuse, } = config;
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (!addressKey) {
+            this.logger.error('Failed to generate an address key for address:', nextHopAddress);
+            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
+        }
+        // Check if we already have a cached connection for this address
+        const existingConnection = this.getValidConnection(addressKey);
+        if (existingConnection) {
+            this.logger.debug('Reusing cached connection for answer:', addressKey, existingConnection.p2pConnection.id);
+            return existingConnection;
+        }
         const connection = new oNodeConnection({
             nextHopAddress: nextHopAddress,
             address: address,
@@ -246,38 +174,33 @@ export class oNodeConnectionManager extends oConnectionManager {
             requestHandler: config.requestHandler ?? undefined,
             reusePolicy: reuse ? 'reuse' : 'none',
         });
-        // Cache the new connection by its p2p connection ID
-        this.cacheNodeConnection(connection);
-        const addressKey = this.getAddressKey(nextHopAddress);
-        if (addressKey) {
-            const connections = this.connectionsByAddress.get(addressKey) || [];
-            // Only add if not already in the cache
-            if (!connections.includes(p2pConnection)) {
-                connections.push(p2pConnection);
-                this.connectionsByAddress.set(addressKey, connections);
-            }
-        }
-        else {
-            this.logger.error('Should not happen! Failed to generate an address key for address:', nextHopAddress);
-        }
+        // Cache the new connection
+        this.cacheConnection(connection, addressKey);
         return connection;
     }
     /**
-     * Connect to a given address, reusing oNodeConnection and libp2p connections when possible
+     * Connect to a given address, reusing oNodeConnection when possible
      * @param config - Connection configuration
      * @returns The connection object
      */
     async connect(config) {
         const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
-        // First get or create the underlying p2p connection
-        const p2pConnection = await this.getOrCreateConnection(nextHopAddress, address);
-        // Check for existing valid oNodeConnection for this p2p connection
-        const existingConnection = this.getCachedNodeConnection(p2pConnection);
+        if (!nextHopAddress) {
+            throw new Error('Invalid address passed');
+        }
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (!addressKey) {
+            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
+        }
+        // Check for existing valid cached connection
+        const existingConnection = this.getValidConnection(addressKey);
         if (existingConnection) {
-            this.logger.debug('Reusing cached oNodeConnection for connection ID:', p2pConnection.id);
+            this.logger.debug('Reusing cached connection for address:', addressKey, existingConnection.p2pConnection.id);
             return existingConnection;
         }
-        // No valid cached connection, create new one
+        // Get or create the underlying p2p connection
+        const p2pConnection = await this.getOrCreateP2pConnection(nextHopAddress, addressKey);
+        // Create new oNodeConnection
         const connection = new oNodeConnection({
             nextHopAddress: nextHopAddress,
             address: address,
@@ -290,8 +213,8 @@ export class oNodeConnectionManager extends oConnectionManager {
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
             requestHandler: config.requestHandler ?? undefined,
         });
-        // Cache the new connection by its p2p connection ID
-        this.cacheNodeConnection(connection);
+        // Cache the new connection
+        this.cacheConnection(connection, addressKey);
         return connection;
     }
     /**
@@ -305,30 +228,7 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (!addressKey) {
                 return false;
             }
-            // Check our address-based cache first
-            const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
-            const bestConnection = this.selectBestConnection(cachedConnections, false);
-            if (bestConnection) {
-                return true;
-            }
-            // Fall back to checking libp2p's connections
-            const peerId = this.getPeerIdFromAddress(address);
-            // the following works since the peer id param is not really required: https://github.com/libp2p/js-libp2p/blob/0bbf5021b53938b2bffcffca6c13c479a95c2a60/packages/libp2p/src/connection-manager/index.ts#L508
-            const connections = this.p2pNode.getConnections(peerId); // ignore since converting to a proper peer id breaks the browser implementation
-            // Check if we have at least one open connection
-            const hasOpenConnection = connections.some((conn) => conn.status === 'open');
-            // If libp2p has an open connection, update our cache
-            if (hasOpenConnection) {
-                const openConnection = connections.find((conn) => conn.status === 'open');
-                if (openConnection) {
-                    const existingConnections = this.connectionsByAddress.get(addressKey) || [];
-                    if (!existingConnections.includes(openConnection)) {
-                        existingConnections.push(openConnection);
-                        this.connectionsByAddress.set(addressKey, existingConnections);
-                    }
-                }
-            }
-            return hasOpenConnection;
+            return this.getValidConnection(addressKey) !== null;
         }
         catch (error) {
             this.logger.debug('Error checking cached connection:', error);
@@ -336,48 +236,17 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
     }
     /**
-     * Get an existing connection to the target peer (from cache or libp2p)
+     * Get an existing cached oNodeConnection for the target address
      * @param address - The address to get a connection for
-     * @returns The Connection object or null if not found
+     * @returns The oNodeConnection or null if not found
      */
-    getCachedLibp2pConnection(address) {
+    getCachedConnection(address) {
         try {
             const addressKey = this.getAddressKey(address);
             if (!addressKey) {
                 return null;
             }
-            // Check address-based cache first
-            const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
-            const bestConnection = this.selectBestConnection(cachedConnections, false);
-            if (bestConnection) {
-                return bestConnection;
-            }
-            const peerId = this.getPeerIdFromAddress(address);
-            if (!peerId) {
-                return null;
-            }
-            // Query libp2p for connections to this peer
-            const connections = this.p2pNode.getConnections();
-            const filteredConnections = connections.filter((conn) => conn.remotePeer?.toString() === peerId);
-            // Find open connections
-            const openConnections = filteredConnections.filter((conn) => conn.status === 'open');
-            // If we found open connections in libp2p, add them to cache and select best
-            if (openConnections.length > 0) {
-                const existingConnections = this.connectionsByAddress.get(addressKey) || [];
-                // Add any new connections that aren't already cached
-                for (const conn of openConnections) {
-                    if (!existingConnections.includes(conn)) {
-                        existingConnections.push(conn);
-                    }
-                }
-                this.connectionsByAddress.set(addressKey, existingConnections);
-                return this.selectBestConnection(existingConnections, false);
-            }
-            // Clean up stale cache entries if connections are no longer open
-            if (cachedConnections.length > 0) {
-                this.connectionsByAddress.delete(addressKey);
-            }
-            return null;
+            return this.getValidConnection(addressKey);
         }
         catch (error) {
             this.logger.debug('Error getting cached connection:', error);
@@ -390,20 +259,19 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     getCacheStats() {
         const allConnections = [];
-        for (const [addressKey, connections,] of this.connectionsByAddress.entries()) {
+        for (const [addressKey, connections] of this.cachedConnections.entries()) {
             for (const conn of connections) {
                 allConnections.push({
-                    peerId: conn.remotePeer?.toString() ?? 'unknown',
-                    status: conn.status,
+                    peerId: conn.p2pConnection?.remotePeer?.toString() ?? 'unknown',
+                    status: conn.p2pConnection?.status ?? 'unknown',
                     addressKey,
                 });
             }
         }
         return {
-            cachedAddresses: this.connectionsByAddress.size,
+            cachedAddresses: this.cachedConnections.size,
             totalCachedConnections: allConnections.length,
             pendingDials: this.pendingDialsByAddress.size,
-            cachedNodeConnections: this.nodeConnectionByConnectionId.size,
             connectionsByPeer: allConnections,
         };
     }
@@ -413,18 +281,16 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     cleanupStaleConnections() {
         let removed = 0;
-        for (const [addressKey, connections,] of this.connectionsByAddress.entries()) {
-            const openConnections = connections.filter((conn) => conn.status === 'open');
+        for (const [addressKey, connections] of this.cachedConnections.entries()) {
+            const openConnections = connections.filter((conn) => conn.p2pConnection?.status === 'open');
             const staleCount = connections.length - openConnections.length;
             if (staleCount > 0) {
                 removed += staleCount;
                 if (openConnections.length === 0) {
-                    // Remove the entire entry if no connections remain
-                    this.connectionsByAddress.delete(addressKey);
+                    this.cachedConnections.delete(addressKey);
                 }
                 else {
-                    // Keep only the open connections
-                    this.connectionsByAddress.set(addressKey, openConnections);
+                    this.cachedConnections.set(addressKey, openConnections);
                 }
             }
         }
@@ -433,21 +299,4 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
         return removed;
     }
-    /**
-     * Clean up all stale oNodeConnections from cache
-     * @returns Number of oNodeConnections removed
-     */
-    cleanupStaleNodeConnections() {
-        let removed = 0;
-        for (const [connectionId, conn,] of this.nodeConnectionByConnectionId.entries()) {
-            if (conn.p2pConnection?.status !== 'open') {
-                this.nodeConnectionByConnectionId.delete(connectionId);
-                removed++;
-            }
-        }
-        if (removed > 0) {
-            this.logger.debug(`Cleaned up ${removed} stale oNodeConnections`);
-        }
-        return removed;
-    }
 }

package/dist/src/index.d.ts

@@ -1,6 +1,5 @@
 export * from './o-node.js';
 export * from './utils/index.js';
-export * from './decorators/index.js';
 export * from './o-node.hierarchy-manager.js';
 export * from './interfaces/o-node.config.js';
 export * from './connection/index.js';

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AACnD,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AACnD,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC"}

package/dist/src/index.js

@@ -1,6 +1,5 @@
 export * from './o-node.js';
 export * from './utils/index.js';
-export * from './decorators/index.js';
 export * from './o-node.hierarchy-manager.js';
 export * from './interfaces/o-node.config.js';
 export * from './connection/index.js';

package/dist/src/o-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"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"}

package/dist/src/o-node.js

@@ -1,12 +1,3 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import { createNode, defaultLibp2pConfig, KEEP_ALIVE, } from '@olane/o-config';
 import { v4 as uuidv4 } from 'uuid';
 import { oNodeRouter } from './router/o-node.router.js';
@@ -21,7 +12,6 @@ import { oLeaderResolverFallback } from './router/index.js';
 import { oNodeNotificationManager } from './o-node.notification-manager.js';
 import { oReconnectionManager } from './managers/o-reconnection.manager.js';
 import { LockManager } from './utils/lock-manager.js';
-import { Synchronized } from './decorators/synchronized.js';
 export class oNode extends oToolBase {
     constructor(config) {
         super(config);
@@ -652,15 +642,3 @@ export class oNode extends oToolBase {
         }
     }
 }
-__decorate([
-    Synchronized('register:parent'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], oNode.prototype, "registerParent", null);
-__decorate([
-    Synchronized('register:leader'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], oNode.prototype, "registerLeader", null);

package/dist/src/o-node.tool.d.ts

@@ -11,6 +11,7 @@ export declare class oNodeTool extends oNodeTool_base {
     private streamHandler;
     handleProtocolReuse(address: oAddress): Promise<void>;
     handleProtocol(address: oAddress): Promise<void>;
+    initializeProtocols(): Promise<void>;
     initialize(): Promise<void>;
     handleStreamReuse(stream: Stream, connection: Connection): Promise<void>;
     handleStream(stream: Stream, connection: Connection, reuse?: boolean): Promise<void>;

package/dist/src/o-node.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAMrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAsBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAoBhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAyCV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAMrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAsBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAoBhC,mBAAmB;IAWnB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAyCV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}

package/dist/src/o-node.tool.js

@@ -47,15 +47,19 @@ export class oNodeTool extends oTool(oServerNode) {
         });
         await this.handleProtocolReuse(address);
     }
-    async initialize() {
-        await super.initialize();
-        this.streamHandler = new StreamHandler(this.logger);
+    async initializeProtocols() {
+        this.logger.info('Initializing custom protocols for node...');
         await this.handleProtocol(this.address);
         if (this.staticAddress &&
             this.staticAddress?.toString() !== this.address.toString()) {
             await this.handleProtocol(this.staticAddress);
         }
     }
+    async initialize() {
+        await super.initialize();
+        this.streamHandler = new StreamHandler(this.logger);
+        await this.initializeProtocols();
+    }
     async handleStreamReuse(stream, connection) {
         return this.handleStream(stream, connection, true);
     }

package/dist/src/utils/connection.utils.d.ts

@@ -1,6 +1,11 @@
 import { Connection } from '@olane/o-config';
 import { oObject } from '@olane/o-core';
 export declare class ConnectionUtils extends oObject {
+    /**
+     * Waits for a peer to appear in the peer store with sufficient protocol information.
+     * Implements retry logic to handle race conditions where peer store is not immediately populated.
+     */
+    private static waitForPeerInStore;
     static addressFromConnection(options: {
         currentNode: any;
         connection: Connection;

package/dist/src/utils/connection.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;WACtB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CA+DF"}
+{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;mBACkB,kBAAkB;WAmCnB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CA8DF"}

package/dist/src/utils/connection.utils.js

@@ -2,25 +2,48 @@ import { oError, oErrorCodes, oObject } from '@olane/o-core';
 import { oNodeAddress } from '../router/o-node.address.js';
 import { oNodeTransport } from '../router/o-node.transport.js';
 export class ConnectionUtils extends oObject {
-    static async addressFromConnection(options) {
-        try {
-            const { currentNode, connection } = options;
-            const p2pNode = currentNode.p2pNode;
-            // Extract the actual olane address from the peer store
+    /**
+     * Waits for a peer to appear in the peer store with sufficient protocol information.
+     * Implements retry logic to handle race conditions where peer store is not immediately populated.
+     */
+    static async waitForPeerInStore(p2pNode, remotePeerId) {
+        const MAX_RETRIES = 100; // 5 seconds total (100 * 50ms)
+        const RETRY_DELAY_MS = 50;
+        const MIN_PROTOCOLS = 2;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
             const peers = await p2pNode.peerStore.all();
             const remotePeer = peers.find((peer) => {
-                return peer.id.toString() === connection.remotePeer.toString();
+                return peer.id.toString() === remotePeerId.toString();
             });
-            if (!remotePeer) {
-                console.log('Failed to find peer:', remotePeer);
-                throw new Error(`Failed to extract remote address, peer ${connection.remotePeer.toString()} not found in peer store.`);
+            // Check if peer exists and has sufficient protocol information
+            if (remotePeer && remotePeer.protocols.length > MIN_PROTOCOLS) {
+                console.log(`Peer found in store after ${attempt} attempts (${attempt * RETRY_DELAY_MS}ms)`);
+                return remotePeer;
+            }
+            // Wait before next retry
+            if (attempt < MAX_RETRIES - 1) {
+                await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
             }
+        }
+        // Timeout exceeded
+        throw new Error(`Timeout waiting for peer ${remotePeerId.toString()} to appear in peer store with sufficient protocols (waited ${MAX_RETRIES * RETRY_DELAY_MS}ms)`);
+    }
+    // TODO: improve this logic (poor implementation for now)
+    static async addressFromConnection(options) {
+        try {
+            const { currentNode, connection } = options;
+            const p2pNode = currentNode.p2pNode;
+            // Wait for peer to appear in peer store with sufficient protocol information
+            // This handles race conditions where peer store is not immediately populated
+            const remotePeer = await this.waitForPeerInStore(p2pNode, connection.remotePeer);
             // Get origin address for comparison
             const originAddress = currentNode.address?.value;
             if (!originAddress) {
                 throw new Error('Origin address is not configured');
             }
-            const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/'));
+            console.log('Deriving address from connection protocols:', remotePeer.protocols);
+            const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/') &&
+                p.includes(currentNode?.address?.protocol) === false);
             if (!oProtocol) {
                 throw new Error('Failed to extract remote address, could not find o-protocol in peer protocols.');
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.46",
+  "version": "0.7.48",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-test": "0.7.46",
+    "@olane/o-test": "0.7.48",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/json5": "^2.2.0",
@@ -60,13 +60,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.46",
-    "@olane/o-core": "0.7.46",
-    "@olane/o-protocol": "0.7.46",
-    "@olane/o-tool": "0.7.46",
+    "@olane/o-config": "0.7.48",
+    "@olane/o-core": "0.7.48",
+    "@olane/o-protocol": "0.7.48",
+    "@olane/o-tool": "0.7.48",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "48c45f37c6e2e1ee626ce1fb0f0de175ca2db3b6"
+  "gitHead": "1810818bb9682b586e9db2febcc2a89da5057449"
 }

package/dist/src/decorators/index.d.ts

@@ -1,2 +0,0 @@
-export * from './synchronized.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/decorators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/src/decorators/index.js

@@ -1 +0,0 @@
-export * from './synchronized.js';

package/dist/src/decorators/synchronized.d.ts

@@ -1,21 +0,0 @@
-/**
- * Method decorator that automatically acquires and releases a lock
- * when the decorated method is called. Ensures only one invocation
- * of the method executes at a time.
- *
- * @param lockName - Optional custom lock name. If not provided,
- *                   defaults to "ClassName:methodName"
- * @param timeoutMs - Optional timeout for lock acquisition in milliseconds
- *
- * @example
- * class MyNode extends oNode {
- *   protected lockManager = new LockManager();
- *
- *   @Synchronized('register:leader')
- *   async registerLeader(): Promise<void> {
- *     // This method is automatically synchronized
- *   }
- * }
- */
-export declare function Synchronized(lockName?: string, timeoutMs?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-//# sourceMappingURL=synchronized.d.ts.map

package/dist/src/decorators/synchronized.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"synchronized.d.ts","sourceRoot":"","sources":["../../../src/decorators/synchronized.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,YAEtD,GAAG,eACE,MAAM,cACP,kBAAkB,wBA8BjC"}

package/dist/src/decorators/synchronized.js

@@ -1,39 +0,0 @@
-/**
- * Method decorator that automatically acquires and releases a lock
- * when the decorated method is called. Ensures only one invocation
- * of the method executes at a time.
- *
- * @param lockName - Optional custom lock name. If not provided,
- *                   defaults to "ClassName:methodName"
- * @param timeoutMs - Optional timeout for lock acquisition in milliseconds
- *
- * @example
- * class MyNode extends oNode {
- *   protected lockManager = new LockManager();
- *
- *   @Synchronized('register:leader')
- *   async registerLeader(): Promise<void> {
- *     // This method is automatically synchronized
- *   }
- * }
- */
-export function Synchronized(lockName, timeoutMs) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        // Generate lock name if not provided
-        const finalLockName = lockName || `${target.constructor.name}:${propertyKey}`;
-        descriptor.value = async function (...args) {
-            // Ensure lockManager exists on the instance
-            const lockManager = this.lockManager;
-            if (!lockManager) {
-                throw new Error(`LockManager not initialized on instance. ` +
-                    `Ensure 'protected lockManager = new LockManager()' is declared in ${target.constructor.name}`);
-            }
-            // Execute the method with automatic lock management
-            return lockManager.withLock(finalLockName, async () => {
-                return originalMethod.apply(this, args);
-            }, timeoutMs);
-        };
-        return descriptor;
-    };
-}

package/dist/test/astream-reuse.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=astream-reuse.spec.d.ts.map

package/dist/test/astream-reuse.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"astream-reuse.spec.d.ts","sourceRoot":"","sources":["../../test/astream-reuse.spec.ts"],"names":[],"mappings":""}

package/dist/test/astream-reuse.spec.js

@@ -1,107 +0,0 @@
-import { expect } from 'chai';
-import { TestEnvironment } from './helpers/index.js';
-import { NetworkTopologies, } from './helpers/network-builder.js';
-import { oNodeAddress } from '../src/router/o-node.address.js';
-describe('Stream Reuse', () => {
-    const env = new TestEnvironment();
-    let builder;
-    afterEach(async () => {
-        if (builder) {
-            await builder.cleanup();
-        }
-        await env.cleanup();
-    });
-    describe('Stream Reuse with reusePolicy="reuse"', () => {
-        it('should reuse the same stream across multiple requests', async () => {
-            builder = await NetworkTopologies.twoNode();
-            const leader = builder.getNode('o://leader');
-            const child = builder.getNode('o://child');
-            // Track stream IDs
-            const streamIds = [];
-            // Make first request
-            const response1 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
-                method: 'echo',
-                params: { message: 'first' },
-            });
-            expect(response1.result.success).to.be.true;
-            // Get active connection to inspect streams
-            const connectionManager = leader.connectionManager;
-            const connection = connectionManager.getCachedLibp2pConnection(child.address);
-            connection.reusePolicy;
-            if (connection) {
-                // Store initial stream count and first stream ID
-                const initialStreamCount = connection.streams.length;
-                if (connection.streams.length > 0) {
-                    streamIds.push(connection.streams[0].id);
-                }
-                // Make second request
-                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
-                    method: 'echo',
-                    params: { message: 'second' },
-                });
-                expect(response2.result.success).to.be.true;
-                // Get stream count after second request
-                const finalStreamCount = connection.streams.length;
-                if (connection.streams.length > 0) {
-                    streamIds.push(connection.streams[0].id);
-                }
-                // With default behavior (reusePolicy='none'), new streams are created
-                // This test verifies current behavior
-                expect(streamIds.length).to.be.greaterThan(0);
-                expect(finalStreamCount).to.be.greaterThan(0);
-            }
-        });
-    });
-    describe('Stream Creation with reusePolicy="none"', () => {
-        it('should create new streams for each request', async () => {
-            builder = await NetworkTopologies.twoNode();
-            const leader = builder.getNode('o://leader');
-            const child = builder.getNode('o://child');
-            // Make multiple requests
-            for (let i = 0; i < 3; i++) {
-                const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
-                    method: 'echo',
-                    params: { message: `request-${i}` },
-                });
-                expect(response.result.success).to.be.true;
-            }
-            // Get connection to verify stream behavior
-            const connectionManager = leader.connectionManager;
-            const connection = connectionManager.getCachedLibp2pConnection(child.address);
-            // With default reusePolicy='none', streams are closed after each request
-            // So we expect minimal open streams
-            expect(connection).to.exist;
-            if (connection) {
-                // The number of open streams should be limited since old ones are closed
-                expect(connection.streams.length).to.be.lessThan(10);
-            }
-        });
-    });
-    describe('Stream Persistence After Transmission', () => {
-        it('should close streams after transmission with reusePolicy="none"', async () => {
-            builder = await NetworkTopologies.twoNode();
-            const leader = builder.getNode('o://leader');
-            const child = builder.getNode('o://child');
-            // Make a request
-            const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
-                method: 'echo',
-                params: { message: 'test' },
-            });
-            expect(response.result.success).to.be.true;
-            // Get connection
-            const connectionManager = leader.connectionManager;
-            const connection = connectionManager.getCachedLibp2pConnection(child.address);
-            expect(connection).to.exist;
-            if (connection) {
-                // Make another request to verify new stream can be created
-                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
-                    method: 'echo',
-                    params: { message: 'test2' },
-                });
-                expect(response2.result.success).to.be.true;
-                // Verify connection is still functional
-                expect(connection.status).to.equal('open');
-            }
-        });
-    });
-});