@persistica/flux-mesh 0.0.11 → 0.0.16

package/package.json

@@ -1,23 +1,29 @@
 {
     "name": "@persistica/flux-mesh",
-    "version": "0.0.11",
+    "version": "0.0.16",
     "description": "Persistica Flux Mesh",
     "type": "module",
     "keywords": [],
     "publishConfig": {
         "access": "public"
     },
-    "exports": "./index.js",
+    "exports": {
+        ".": {
+            "types": "./src/index.d.ts",
+            "import": "./index.js",
+            "default": "./index.js"
+        }
+    },
     "main": "./index.js",
     "types": "./src/index.d.ts",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/rujorgensen/persistica.git"
+        "url": "git+https://github.com/rujorgensen/flux.git"
     },
     "author": "pixl.prophet",
     "license": "ISC",
     "bugs": {
-        "url": "https://github.com/rujorgensen/persistica/issues"
+        "url": "https://github.com/rujorgensen/flux/issues"
     },
-    "homepage": "https://github.com/rujorgensen/persistica#readme"
+    "homepage": "https://github.com/rujorgensen/flux#readme"
 }

package/src/_classes/web-rtc-client-interface.class.d.ts

@@ -7,14 +7,66 @@ export declare class WebRTCClient extends RPCClient<'createOffer' | 'acceptOffer
     private readonly _handleResponseMessage;
     constructor(_originProcessAddress: TProcessAddress, _sendToRPCServer: (data: any, // ! Use 'unknown' or Bun.BufferSource (does not work)
     compress?: boolean | undefined) => number, _handleResponseMessage: (fn: TRPCResponseCallbackFunction) => void);
+    /**
+     * Creates a WebRTC offer.
+     *
+     * @returns { Promise<unknown> } The WebRTC offer
+     */
     createOffer(): Promise<unknown>;
+    /**
+     * Accepts a WebRTC offer and creates an answer.
+     *
+     * @param { unknown } offer - The WebRTC offer from remote
+     *
+     * @returns { Promise<unknown> } The answer
+     */
     acceptOfferAndCreateAnswer(offer: unknown): Promise<unknown>;
+    /**
+     * Accepts a WebRTC answer from the remote client.
+     *
+     * @param { unknown } answer - The WebRTC answer
+     *
+     * @returns { Promise<boolean> } True if accepted
+     */
     acceptAnswer(answer: unknown): Promise<boolean>;
+    /**
+     * Notifies the remote client that the answer was accepted.
+     *
+     * @param { boolean } answerAccepted - Whether the answer was accepted
+     *
+     * @returns { Promise<boolean> }
+     */
     answerWasAccepted(answerAccepted: boolean): Promise<boolean>;
 }
 export declare class GlobalWebRTCClient extends GlobalRPCClient2<'createOffer' | 'acceptOffer' | 'acceptAnswer' | 'answerAcceptedByInitiator'> {
+    /**
+     * Creates a WebRTC offer.
+     *
+     * @returns { Promise<unknown> } The WebRTC offer
+     */
     createOffer(): Promise<unknown>;
+    /**
+     * Accepts a WebRTC offer and creates an answer.
+     *
+     * @param { unknown } offer - The WebRTC offer from remote
+     *
+     * @returns { Promise<unknown> } The answer
+     */
     acceptOfferAndCreateAnswer(offer: unknown): Promise<unknown>;
+    /**
+     * Accepts a WebRTC answer from the remote client.
+     *
+     * @param { unknown } answer - The WebRTC answer
+     *
+     * @returns { Promise<boolean> } True if accepted
+     */
     acceptAnswer(answer: unknown): Promise<boolean>;
+    /**
+     * Notifies the remote client that the answer was accepted.
+     *
+     * @param { boolean } answerAccepted - Whether the answer was accepted
+     *
+     * @returns { Promise<boolean> }
+     */
     answerWasAccepted(answerAccepted: boolean): Promise<boolean>;
 }

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

@@ -0,0 +1,15 @@
+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 { NetworkAgentRedisCache } from '../register/network-agent-redis-cache.class';
+export declare class AgentManager {
+    private readonly _redisConnection;
+    private readonly _clientMap;
+    private readonly _networkAgentRedisCache;
+    private readonly machineAddress;
+    private readonly processAddress;
+    private readonly _globalClientManager;
+    private readonly _localAgentManager;
+    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    kick(agentAddress: TAddress): void;
+}

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

@@ -0,0 +1,15 @@
+import { type TAddress, 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';
+export declare class AuthorityManager {
+    private readonly _redisConnection;
+    private readonly _clientMap;
+    private readonly _networkAuthorityRedisCache;
+    private readonly machineAddress;
+    private readonly processAddress;
+    private readonly _globalClientManager;
+    private readonly _localAuthorityManager;
+    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
+    kick(agentAddress: TAddress): void;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Global client manager.
+ */
+import { type TAddress, type TClientId } from '@flux/shared/types';
+import { RedisConnection } from '../../routing/redis/redis-connection.class';
+export declare class GlobalClientManager {
+    private readonly _redisConnection;
+    private readonly processAddress;
+    constructor(_redisConnection: RedisConnection);
+    /**
+     * Sends a global message to kick a client.
+     *
+     * @param { TAddress } fullClientAddress - The full client address
+     *
+     * @returns { Promise<void> }
+     */
+    kickClient(agentAddress: TAddress): Promise<void>;
+    /**
+     * On event on this process
+     */
+    onKickClient(onKickCallback: (clientAddress: TClientId) => void): void;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Disconnects a local agent client, and cleans up all related state in redis and locally.
+ */
+import type { TClientId } from '@flux/shared/types';
+import { TConnectedClientSocket } from '../../connected-client-socket.types';
+import { NetworkAgentRedisCache } from '../../register/network-agent-redis-cache.class';
+export declare class LocalAgentManager {
+    private readonly _clientMap;
+    private readonly _networkAgentRedisCache;
+    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    kickAgent(clientAddress: TClientId): void;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Disconnects a local authority client, and cleans up all related state in redis and locally.
+ */
+import type { TClientId } from '@flux/shared/types';
+import type { TConnectedClientSocket } from '../../connected-client-socket.types';
+import { NetworkAuthorityRedisCache } from '../../register/network-authority-redis-cache.class';
+export declare class LocalAuthorityManager {
+    private readonly _clientMap;
+    private readonly _networkAuthorityRedisCache;
+    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
+    kickAuthority(clientAddress: TClientId): void;
+}

package/src/_routes/auth/network-authority.post.route.d.ts

@@ -1,7 +1,15 @@
 import type * as Bun from 'bun';
+import { type TNetworkId_S } from '@flux/shared/types';
 /**
  * This route is used to authorize a network authority.
  *
- * @returns { Promise<Response> }
+ * The plain-text token value sent in the request body is validated against
+ * the local {@link NetworkTokenCache}. The cache is kept in sync via Redis
+ * pub/sub events emitted by the portal on token creation, rotation, or
+ * deletion — so no database round-trip is unless it doesn't exist locally.
+ *
+ * @param { Bun.BunRequest } request - The incoming HTTP request
+ *
+ * @returns { Promise<Response> } The HTTP response with auth token or error
  */
-export declare const authorizeNetworkAuthority: (request: Bun.BunRequest) => Promise<Response>;
+export declare const authorizeNetworkAuthority: (request: Bun.BunRequest, hardcodedNetworkCredentials?: Map<TNetworkId_S, string>) => Promise<Response>;

package/src/_routes/auth/network-client.post.route.d.ts

@@ -1,12 +1,13 @@
 import type { BunRequest } from 'bun';
 import type { GlobalRPCClient } from '../../routing/rpc/core/global-rpc-client.class';
-import type { NetworkAuthorityManager } from '../../register/register-network-authority.class';
+import type { NetworkAuthorityRedisCache } from '../../register/network-authority-redis-cache.class';
 /**
+ * This route is used to authorize a network agent.
  *
- * @param { BunRequest }                    request
- * @param { NetworkAuthorityManager }       networkAuthorityManager
- * @param { GlobalRPCClient<'authorize'> }  globalRPCClient
+ * @param { BunRequest } request - The incoming HTTP request
+ * @param { NetworkAuthorityRedisCache } networkAuthorityManager - The network authority manager
+ * @param { GlobalRPCClient<'authorize'> } globalRPCClient - The global RPC client
  *
- * @returns { void }
+ * @returns { Promise<Response> } The HTTP response with auth token or error
  */
-export declare const authorizeNetworkAgent: (request: BunRequest, networkAuthorityManager: NetworkAuthorityManager, globalRPCClient: GlobalRPCClient<"authorize">) => Promise<Response>;
+export declare const authorizeNetworkAgent: (request: BunRequest, networkAuthorityManager: NetworkAuthorityRedisCache, globalRPCClient: GlobalRPCClient<"authorize">) => Promise<Response>;

package/src/_routes/npc-interact.get.route.d.ts

@@ -0,0 +1,6 @@
+import type * as Bun from 'bun';
+/**
+ * Returns mesh NPC dialogue with random flavor text for the first few
+ * interactions from the same player, then a fixed final line afterwards.
+ */
+export declare const interactWithNpc: (request: Bun.BunRequest) => Response;

package/src/_routes/options.route.d.ts

@@ -1,6 +1,6 @@
 /**
  * Standard CORS response.
  *
- * @returns { Response }
+ * @returns { Response } A 204 No Content response with CORS headers
  */
 export declare const OPTIONS_RESPONSE: () => Response;

package/src/auth/auth.d.ts

@@ -13,10 +13,17 @@ export type TTokenPayloadJWT = string & {
 /**
  * Generates JWT string from a token payload.
  *
- * @param { TTokenPayload }     payload
- * @param { number }            expiresIn
+ * @param { TTokenPayload } payload - The token payload to sign
+ * @param { number } [expiresIn] - Token expiry time in seconds
  *
- * @returns { TTokenPayloadJWT }
+ * @returns { string } The signed JWT string
  */
 export declare const generateToken: (payload: TTokenPayload, expiresIn?: number) => string;
+/**
+ * Verifies a JWT token and returns the payload or throws if invalid.
+ *
+ * @param { unknown } token - The JWT token string to verify
+ *
+ * @returns { TTokenPayload } The decoded token payload
+ */
 export declare const verifyTokenOrThrow: (token: unknown) => TTokenPayload;

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

@@ -1,5 +1,14 @@
-import { type TAddress, type TChannelName, type TNetworkId_S } from '@flux/shared/types';
+import { type TAddress, type TChannelName, type TNetworkId_S, type TSubscription_S } from '@flux/shared/types';
 import type { GlobalChannelPubsub } from '../../routing/global-channel/global-channel-pubsub.class';
+export declare const MAX_CHANNEL_MEMBERS_BY_SUBSCRIPTION_TYPE: {
+    [key in TSubscription_S]: number;
+};
+export declare const MAX_CHANNEL_MEMBERS: number;
+export declare const normalizeSubscriptionType: (subscriptionType?: string) => TSubscription_S | undefined;
+export declare const resolveSubscriptionTypeOrDefault: (subscriptionType?: string) => TSubscription_S;
+export declare const readMaxChannelMembers: (subscriptionType?: string) => number;
+export declare const readSubscriptionTypeFromClaim: (claim?: string) => TSubscription_S | undefined;
+export declare const canChannelHaveMoreMembers: (memberCount: number, subscriptionType?: TSubscription_S) => boolean;
 export declare class NetworkChannelManager {
     private readonly _globalChannelPubsub;
     private readonly channelUsageCount;
@@ -10,60 +19,26 @@ export declare class NetworkChannelManager {
      * Checks if a channel can have more members.
      *
      * ! TODO Don't query the database repeatedly, implement local synced cache.
-     *
-     * @param { TNetworkId_S } networkId
-     * @param { TChannelName } channelName
-     *
-     * @returns { Promise<boolean> }
      */
-    canHaveMembers(networkId: TNetworkId_S, channelName: TChannelName): Promise<boolean>;
+    canHaveMembers(networkId: TNetworkId_S, channelName: TChannelName, subscriptionType?: TSubscription_S): Promise<boolean>;
     /**
      * Joins a network channel.
-     *
-     * @param { TNetworkId_S }  networkId
-     * @param { TChannelName }  channelName
-     * @param { TAddress }      clientAddress
-     *
-     * @returns { void }
      */
     joinNetworkChannel(networkId: TNetworkId_S, channelName: TChannelName, clientAddress: TAddress): void;
     /**
      * Leaves a network channel.
-     *
-     * @param { TNetworkId_S }  networkId
-     * @param { TChannelName }  channelName
-     * @param { TAddress }      clientAddress
-     *
-     * @returns { Promise<void> }
      */
     leaveNetworkChannel(networkId: TNetworkId_S, channelName: TChannelName, clientAddress: TAddress): Promise<void>;
     /**
      * Leaves all network channels.
-     *
-     * @param { TNetworkId_S }          networkId
-     * @param { TAddress }              clientAddress
-     * @param { Set<TChannelName> }     channelNames
-     *
-     * @returns { void }
      */
     leaveAllNetworkChannels(networkId: TNetworkId_S, clientAddress: TAddress, channelNames: Set<TChannelName>): void;
     /**
      * Creates a network channel if it does not exist.
-     *
-     * @param { TNetworkId_S }  networkId
-     * @param { TChannelName }  channelName
-     *
-     * @returns { void }
      */
     private createNetworkChannelIfNotExist;
     /**
      * Increases the usage count of a channel.
-     *
-     * @param { TNetworkId_S } networkId
-     * @param { TChannelName } channelName
-     * @param { number } usage
-     *
-     * @returns { void }
      */
     increaseUsageCount(networkId: TNetworkId_S, channelName: TChannelName, usage: number): void;
 }

package/src/business-logic/npc/npc-dialogue-manager.class.d.ts

@@ -0,0 +1,7 @@
+import type { INpcInteractionResult } from './npc-dialogue.types';
+export declare class NPCDialogueManager {
+    private readonly interactionTracker;
+    private readonly dialogueScript;
+    constructor(randomNumberGenerator?: () => number);
+    interact(userId: string, npcId: string): INpcInteractionResult;
+}

package/src/business-logic/npc/npc-dialogue-script.class.d.ts

@@ -0,0 +1,7 @@
+import type { INpcInteractionResult } from './npc-dialogue.types';
+export declare class NPCDialogueScript {
+    private readonly randomNumberGenerator;
+    constructor(randomNumberGenerator?: () => number);
+    resolveInteraction(interactionCount: number): INpcInteractionResult;
+    private resolveMessage;
+}

package/src/business-logic/npc/npc-dialogue-script.class.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/business-logic/npc/npc-dialogue.types.d.ts

@@ -0,0 +1,6 @@
+export interface INpcInteractionResult {
+    interactionCount: number;
+    isFinalResponse: boolean;
+    message: string;
+    remainingRandomResponses: number;
+}

package/src/business-logic/npc/npc-interaction-tracker.class.d.ts

@@ -0,0 +1,5 @@
+export declare class NPCInteractionTracker {
+    private readonly interactionCountByUserAndNpc;
+    incrementInteractionCount(userId: string, npcId: string): number;
+    private buildInteractionKey;
+}

package/src/business-logic/npc/npc-interaction-tracker.class.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.d.ts

@@ -1 +1,3 @@
 export { FluxMeshServer, } from './main';
+export { type RedisConnection, getMeshRedisConnection, } from './routing/redis/redis-connection.class';
+export { GlobalClientManager, } from './_managers/global/global-client.manager';

package/src/main.d.ts

@@ -1,9 +1,11 @@
 declare global {
     var meshLoadCount: number | null;
 }
+import { TNetworkId_S } from '@flux/shared/types';
 type TOptions = {
     port?: number;
     redisConnectionString?: string;
+    hardcodedNetworkCredentials?: Map<TNetworkId_S, string>;
 };
 export declare class FluxMeshServer {
     private readonly optionsOrPort?;
@@ -12,13 +14,11 @@ export declare class FluxMeshServer {
     private readonly bunServer;
     private readonly globalChannelPubsub;
     private readonly channelManager;
-    private readonly options;
+    private readonly agentManager;
     constructor(optionsOrPort?: (TOptions | number) | undefined);
     onReady(fn: () => void): void;
     /**
      * Gracefully shuts down the server.
-     *
-     * @returns { Promise<void> }
      */
     stop(): Promise<void>;
 }

package/src/orchestrators/facilitate-webrtc-connection.class.d.ts

@@ -1,2 +1,5 @@
 import { GlobalWebRTCClient, WebRTCClient } from '../_classes/web-rtc-client-interface.class';
+/**
+ * Orchestrates the WebRTC connection handshake between two clients.
+ */
 export declare const facilitateWebRTCConnection: (initiator: WebRTCClient | GlobalWebRTCClient, remoteClient: GlobalWebRTCClient) => Promise<void>;

package/src/register/{network-client-manager.class.d.ts → network-agent-redis-cache.class.d.ts}

@@ -2,7 +2,7 @@ import type { NetworkAgentRedisService } from '@flux/mesh/store/redis/network-ag
 import { NetworkUsageRedisCacheService } from '@flux/mesh/store/redis/network-usage';
 import type { TAddress, TClientId, TAgentOwnUId, TNetworkId_S } from '@flux/shared/types';
 import type { TFluxClientUID } from '@flux/shared/utils';
-export declare class NetworkAgentManager {
+export declare class NetworkAgentRedisCache {
     readonly networkAgentRedisService: NetworkAgentRedisService;
     readonly networkUsageRedisCacheService: NetworkUsageRedisCacheService;
     private readonly redisConnection;
@@ -12,13 +12,15 @@ export declare class NetworkAgentManager {
     /**
      * Register an agent.
      *
-     * @param { TNetworkId_S }              networkId
-     * @param { TClientId }                 id
-     * @param { Bun.SocketAddress | null }  ip
-     * @param { TAddress }                  address
-     * @param { TAgentOwnUId }              [uid]
+     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TClientId } id - The client socket ID
+     * @param { Bun.SocketAddress | null } ip - The client IP address
+     * @param { TAddress } address - The client address
+     * @param { object } throughput - The throughput tracking object
+     * @param { TAgentOwnUId } [uid] - Optional agent UID
+     * @param { TFluxClientUID } [machineUID] - Optional machine UID
      *
-     * @returns { void }
+     * @returns { Promise<void> }
      */
     registerAgent(networkId: TNetworkId_S, id: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
         bytes: number;
@@ -27,12 +29,20 @@ export declare class NetworkAgentManager {
     /**
      * Unregisters a network agent UID and associated data from the Redis hash.
      *
-     * @param { TNetworkId_S }      networkId
-     * @param { TClientId }         clientId
-     * @param { TAgentOwnUId }     clientOwnUId
+     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TClientId } clientId - The client socket ID
+     * @param { TAgentOwnUId } [clientOwnUId] - Optional agent UID
      *
      * @returns { void }
      */
     unregisterNetworkAgent(networkId: TNetworkId_S, clientId: TClientId, clientOwnUId?: TAgentOwnUId): void;
+    /**
+     * Resolves the network client address by an agent's UID, using a local cache to avoid unnecessary Redis calls.
+     *
+     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TAgentOwnUId } clientOwnUId - The agent UID to look up
+     *
+     * @returns { Promise<TAddress> } The resolved address
+     */
     resolveNetworkClientAddressByUid(networkId: TNetworkId_S, clientOwnUId: TAgentOwnUId): Promise<TAddress>;
 }

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

@@ -0,0 +1,49 @@
+import { type TAddress, type TClientId, type TNetworkId_S } from '@flux/shared/types';
+import type { TFluxClientUID } from '@flux/shared/utils';
+export declare class NetworkAuthorityRedisCache {
+    private readonly redisConnection;
+    private readonly cache;
+    /**
+     * Registers a network authority.
+     *
+     * @param { TNetworkId_S } networkId - The network ID to register on
+     * @param { TClientId } socketId - 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>;
+    /**
+     * 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
+     *
+     * @returns { void }
+     */
+    unregister(networkId: TNetworkId_S, networkAuthorityAddress: TAddress): void;
+    /**
+     * Used for cleanup, in case of discovering an idle authority.
+     *
+     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TAddress } networkAuthorityAddress - The address of the authority to unregister globally
+     *
+     * @returns { void }
+     */
+    unregisterGlobal(networkId: TNetworkId_S, networkAuthorityAddress: TAddress): void;
+    /**
+     * Resolves a random network authority address for a given network ID.
+     *
+     * @param { TNetworkId_S } networkId - The network ID to resolve an authority for
+     *
+     * @returns { Promise<TAddress> } The resolved authority address
+     */
+    resolveNetworkAuthorityAddressOrThrow(networkId: TNetworkId_S): Promise<TAddress>;
+    /**
+     * Removes a client from the cache and unregisters it globally.
+     *
+     * @param { TNetworkId_S } networkId - The network ID
+     * @param { TAddress } networkAuthorityAddress - The address of the unresponsive client
+     */
+    removeUnresponsiveClient(networkId: TNetworkId_S, networkAuthorityAddress: TAddress): void;
+}

package/src/routing/addressing.utils.d.ts

@@ -1,9 +1,19 @@
 import type { TMachineAddress, TProcessId, TProcessAddress } from '@flux/shared/types';
+/**
+ * Returns the current process ID.
+ *
+ * @returns { TProcessId } The current process ID
+ */
 export declare const readProcessId: () => TProcessId;
+/**
+ * Returns the current machine's network address.
+ *
+ * @returns { TMachineAddress } The current machine's network address
+ */
 export declare const readMachineAddress: () => TMachineAddress;
 /**
  * Returns the process address.
  *
- * @returns { TProcessAddress }
+ * @returns { TProcessAddress } The current process address
  */
 export declare const readProcessAddress: () => TProcessAddress;

package/src/routing/global-channel/global-channel-pubsub.class.d.ts

@@ -10,25 +10,25 @@ import type { RedisConnection } from '../redis/redis-connection.class';
 export type TGlobalChannel = string & {
     __brand: 'global-channel';
 };
+type TWebsocketData = {};
 export declare class GlobalChannelPubsub {
     private readonly redisConnection;
     private readonly bunServer;
     private readonly processAddress;
-    constructor(redisConnection: RedisConnection, bunServer: Bun.Server, processAddress: TProcessAddress);
+    constructor(redisConnection: RedisConnection, bunServer: Bun.Server<TWebsocketData>, processAddress: TProcessAddress);
     /**
      * Subscribes to the websocket channel event and publishes it on the local process.
-     *
-     * @returns { void }
      */
     private subscribeWebsocketChannelEvent;
     /**
      * Publishes a message to the given channel.
      *
-     * @param { string }  channel
-     * @param { string }  message
-     * @param { TConnectedClientSocket }  [ws]
+     * @param { string } channel - The channel name to publish to
+     * @param { string } message - The message to publish
+     * @param { TConnectedClientSocket } [ws] - Optional websocket to skip when publishing locally
      *
      * @returns { Promise<void> }
      */
     publish(channel: string, message: string, ws?: TConnectedClientSocket): Promise<void>;
 }
+export {};

package/src/routing/outgoing-message-router.class.d.ts

@@ -9,11 +9,10 @@ export declare class OutgoingMessageRouter {
     private readonly redisConnection;
     constructor(passToLocalClientOrThrowUnknownClient: (clientId: TClientId, message: string) => void);
     /**
+     * Routes a message to the correct destination.
      *
-     * @param address
-     * @param message
-     *
-     * @returns
+     * @param { TAddress } address - The destination address
+     * @param { string } message - The message to route
      */
     message(address: TAddress, message: string): void;
 }

package/src/routing/process-message-router.class.d.ts

@@ -11,18 +11,14 @@ export declare class ProcessMessageRouter {
     /**
      * Sends a message to a process.
      *
-     * @param { TProcessAddress }   address
-     * @param { string }            message
-     *
-     * @returns
+     * @param { TProcessAddress } address - The destination process address
+     * @param { string } message - The message to route
      */
     message(address: TProcessAddress, message: string): void;
     /**
-     * Subscribe to mesaages for local process.
-     *
-     * @param message
+     * Subscribes to messages for the local process.
      *
-     * @returns { void }
+     * @param { TCallbackFunction } onMessage - Callback to invoke when a message is received
      */
     subscribe(onMessage: TCallbackFunction): void;
 }

package/src/routing/redis/_utils/split-message.utils.d.ts

@@ -0,0 +1,11 @@
+import type { TClientId, TChannelName, TProcessAddress } from '@flux/shared/types';
+export type TMessageConstruct = `${TProcessAddress}:nc-on-pub:${TClientId}:${TChannelName}:${string}`;
+export interface ISplitMessageResult {
+    clientId: TClientId;
+    channelName: TChannelName;
+    data: string;
+}
+/**
+ * Splits a raw message string into its components: clientId, channelName, and data.
+ */
+export declare const splitOrThrowMessage: (rawMessage: TMessageConstruct) => ISplitMessageResult;

package/src/routing/redis/_utils/split-message.utils.spec.d.ts

@@ -0,0 +1 @@
+export {};