@persistica/flux-mesh 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-mesh",
-    "version": "0.0.17",
+    "version": "0.0.19",
     "description": "Persistica Flux Mesh",
     "type": "module",
     "keywords": [],

package/src/_managers/authority.manager.d.ts

@@ -1,4 +1,4 @@
-import { type TAddress, TClientId } from '@flux/shared/types';
+import { type TAddress, type TClientId } from '@flux/shared/types';
 import { RedisConnection } from '../routing/redis/redis-connection.class';
 import { TConnectedClientSocket } from '../connected-client-socket.types';
 import { NetworkAuthorityRedisCache } from '../register/network-authority-redis-cache.class';
@@ -11,5 +11,5 @@ export declare class AuthorityManager {
     private readonly _globalClientManager;
     private readonly _localAuthorityManager;
     constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
-    kick(agentAddress: TAddress): void;
+    kick(authorityAddress: TAddress): void;
 }

package/src/_managers/global/global-client.manager.d.ts

@@ -1,5 +1,7 @@
 /**
  * Global client manager.
+ *
+ * Routes kick event to the process on which the client is connected.
  */
 import { type TAddress, type TClientId } from '@flux/shared/types';
 import { RedisConnection } from '../../routing/redis/redis-connection.class';
@@ -10,13 +12,13 @@ export declare class GlobalClientManager {
     /**
      * Sends a global message to kick a client.
      *
-     * @param { TAddress } fullClientAddress - The full client address
+     * @param { TAddress } agentAddress
      *
      * @returns { Promise<void> }
      */
-    kickClient(agentAddress: TAddress): Promise<void>;
+    kickClient(type: 'agent' | 'authority', agentAddress: TAddress): Promise<void>;
     /**
-     * On event on this process
+     * On event on this process.
      */
-    onKickClient(onKickCallback: (clientAddress: TClientId) => void): void;
+    onKickClient(type: 'agent' | 'authority', onKickCallback: (clientAddress: TClientId) => void): void;
 }

package/src/_managers/local/local-agent.manager.d.ts

@@ -8,5 +8,5 @@ export declare class LocalAgentManager {
     private readonly _clientMap;
     private readonly _networkAgentRedisCache;
     constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
-    kickAgent(clientAddress: TClientId): void;
+    kickAgent(clientId: TClientId): Promise<void>;
 }

package/src/_managers/local/local-authority.manager.d.ts

@@ -8,5 +8,5 @@ export declare class LocalAuthorityManager {
     private readonly _clientMap;
     private readonly _networkAuthorityRedisCache;
     constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
-    kickAuthority(clientAddress: TClientId): void;
+    kickAuthority(clientId: TClientId): Promise<void>;
 }

package/src/business-logic/channels/channel-manager.class.d.ts

@@ -32,7 +32,7 @@ export declare class NetworkChannelManager {
     /**
      * Leaves all network channels.
      */
-    leaveAllNetworkChannels(networkId: TNetworkId_S, clientAddress: TAddress, channelNames: Set<TChannelName>): void;
+    leaveAllNetworkChannels(networkId: TNetworkId_S, clientAddress: TAddress, channelNames: Set<TChannelName>): Promise<void>;
     /**
      * Creates a network channel if it does not exist.
      */

package/src/register/network-agent-redis-cache.class.d.ts

@@ -29,13 +29,16 @@ export declare class NetworkAgentRedisCache {
     /**
      * Unregisters a network agent UID and associated data from the Redis hash.
      *
-     * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } clientId - The client socket ID
+     * @param { TClientId } clientId
+     * @param { TNetworkId_S } [networkId]
      * @param { TAgentOwnUId } [clientOwnUId] - Optional agent UID
      *
      * @returns { void }
      */
-    unregisterNetworkAgent(networkId: TNetworkId_S, clientId: TClientId, clientOwnUId?: TAgentOwnUId): void;
+    unregister(clientId: TClientId, networkId?: TNetworkId_S, clientOwnUId?: {
+        clientOwnUId: TAgentOwnUId;
+        networkId: TNetworkId_S;
+    }): Promise<void>;
     /**
      * Resolves the network client address by an agent's UID, using a local cache to avoid unnecessary Redis calls.
      *
@@ -44,5 +47,5 @@ export declare class NetworkAgentRedisCache {
      *
      * @returns { Promise<TAddress> } The resolved address
      */
-    resolveNetworkClientAddressByUid(networkId: TNetworkId_S, clientOwnUId: TAgentOwnUId): Promise<TAddress>;
+    resolveClientAddressByUid(networkId: TNetworkId_S, clientOwnUId: TAgentOwnUId): Promise<TAddress>;
 }

package/src/register/network-authority-redis-cache.class.d.ts

@@ -3,25 +3,26 @@ import type { TFluxClientUID } from '@flux/shared/utils';
 export declare class NetworkAuthorityRedisCache {
     private readonly redisConnection;
     private readonly cache;
+    private readonly clientCache;
     /**
      * Registers a network authority.
      *
      * @param { TNetworkId_S } networkId - The network ID to register on
-     * @param { TClientId } socketId - The socket ID of the authority
+     * @param { TClientId } clientId - The socket ID of the authority
      * @param { TFluxClientUID } [machineUID] - Optional machine UID
      *
      * @returns { Promise<void> }
      */
-    register(networkId: TNetworkId_S, socketId: TClientId, machineUID?: TFluxClientUID): Promise<void>;
+    register(networkId: TNetworkId_S, clientId: TClientId, machineUID?: TFluxClientUID): Promise<void>;
     /**
      * Unregisters a network authority from the local network.
      *
-     * @param { TNetworkId_S } networkId - The network ID
-     * @param { TAddress } networkAuthorityAddress - The address of the authority to unregister
+     * @param { TClientId } clientId
+     * @param { TNetworkId_S } [networkId]
      *
-     * @returns { void }
+     * @returns { Promise<void> }
      */
-    unregister(networkId: TNetworkId_S, networkAuthorityAddress: TAddress): void;
+    unregister(clientId: TClientId, networkId?: TNetworkId_S): Promise<void>;
     /**
      * Used for cleanup, in case of discovering an idle authority.
      *
@@ -38,11 +39,11 @@ export declare class NetworkAuthorityRedisCache {
      *
      * @returns { Promise<TAddress> } The resolved authority address
      */
-    resolveNetworkAuthorityAddressOrThrow(networkId: TNetworkId_S): Promise<TAddress>;
+    resolveAuthorityAddressOrThrow(networkId: TNetworkId_S): Promise<TAddress>;
     /**
      * Removes a client from the cache and unregisters it globally.
      *
-     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TNetworkId_S } networkId
      * @param { TAddress } networkAuthorityAddress - The address of the unresponsive client
      */
     removeUnresponsiveClient(networkId: TNetworkId_S, networkAuthorityAddress: TAddress): void;

package/src/routing/redis/network-agent.redis.d.ts

@@ -5,7 +5,6 @@ import type { RedisClient } from 'bun';
 import type { TClientId, TNetworkId_S } from '@flux/shared/types';
 export declare class NetworkAgentRedis {
     private readonly client;
-    private readonly networkAgentRedisSortedSet;
     private readonly cashedDataUsage;
     constructor(client: RedisClient);
     /**
@@ -41,15 +40,6 @@ export declare class NetworkAgentRedis {
             );
     }
      */
-    /**
-     * Unregisters a network agent from the sorted set.
-     *
-     * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } clientId - The socket ID
-     *
-     * @returns { Promise<number> } The number of elements removed
-     */
-    unregisterNetworkAgent(networkId: TNetworkId_S, clientId: TClientId): Promise<number>;
     /**
      * Caches the data usage for a network agent to be pushed periodically.
      *

package/src/routing/redis/redis-connection.class.d.ts

@@ -74,8 +74,8 @@ export declare class RedisConnection {
      * Used by {@link NetworkTokenCache} for cold-start bootstrapping.
      */
     getNetworkTokenValues(networkId: TNetworkId_S): Promise<TNetworkToken_S[]>;
-    publishCustom(subChannel: 'kick-client', destinationProcessAddress: TProcessAddress, message: string): Promise<void>;
-    subscribeToCustom(subChannel: 'kick-client', destinationProcessAddress: TProcessAddress, callback: (data: string) => void): void;
+    publishCustom(subChannel: 'kick-client-agent' | 'kick-client-authority', destinationProcessAddress: TProcessAddress, message: string): Promise<number>;
+    subscribeToCustom(subChannel: 'kick-client-agent' | 'kick-client-authority', destinationProcessAddress: TProcessAddress, callback: (data: string) => void): void;
     /**
      * Publishes a message directly to an address.
      */

package/src/routing/redis/hash/network-agent.redis.sorted-set.d.ts

@@ -1,26 +0,0 @@
-import type { RedisClient } from 'bun';
-import type { TClientId, TNetworkId_S } from '@flux/shared/types';
-export declare class NetworkAgentRedisSortedSet {
-    private readonly client;
-    private readonly processId;
-    private readonly machineAddress;
-    constructor(client: RedisClient);
-    /**
-     * Registers a network agent in the sorted set.
-     *
-     * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } socketId - The socket/client ID
-     *
-     * @returns { Promise<void> }
-     */
-    registerAgent(networkId: TNetworkId_S, socketId: TClientId): Promise<void>;
-    /**
-     * Unregisters a network agent from the sorted set.
-     *
-     * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } socketId - The socket/client ID
-     *
-     * @returns { Promise<number> } The number of elements removed
-     */
-    unregisterAgent(networkId: TNetworkId_S, socketId: TClientId): Promise<number>;
-}