alepha 0.15.0 → 0.15.1

package/dist/websocket/index.d.ts

@@ -1,7 +1,7 @@
-import * as alepha42 from "alepha";
+import * as alepha6 from "alepha";
 import { Alepha, KIND, Primitive, Static, TObject, TString, TUnion } from "alepha";
 import * as alepha_topic0 from "alepha/topic";
-import * as alepha_logger2 from "alepha/logger";
+import * as alepha_logger1 from "alepha/logger";
 import { WebSocket as WebSocket$1, WebSocketServer } from "ws";
 import { IncomingMessage } from "node:http";
 
@@ -33,32 +33,32 @@ type TWSObject = TObject | TUnion;
  */
 interface ChannelPrimitiveOptions<TClient extends TWSObject, TServer extends TWSObject> {
   /**
-       * WebSocket endpoint path (e.g., "/ws/chat")
-       */
+   * WebSocket endpoint path (e.g., "/ws/chat")
+   */
   path: string;
   /**
-       * Optional description for documentation
-       */
+   * Optional description for documentation
+   */
   description?: string;
   /**
-       * Message schemas for bidirectional communication
-       */
+   * Message schemas for bidirectional communication
+   */
   schema: {
     /**
-             * Optional room ID schema validation
-             * Default: t.text() (any string)
-             * Can be enforced at application level: t.uuid(), t.regex(/^[a-f0-9\-]{36}$/)
-             */
+     * Optional room ID schema validation
+     * Default: t.text() (any string)
+     * Can be enforced at application level: t.uuid(), t.regex(/^[a-f0-9\-]{36}$/)
+     */
     roomId?: TString;
     /**
-             * Messages from server to client
-             * This is what clients will receive
-             */
+     * Messages from server to client
+     * This is what clients will receive
+     */
     in: TClient;
     /**
-             * Messages from client to server
-             * This is what the server will receive
-             */
+     * Messages from client to server
+     * This is what the server will receive
+     */
     out: TServer;
   };
 }
@@ -136,32 +136,32 @@ declare class ChannelPrimitive<TClient extends TWSObject, TServer extends TWSObj
  */
 interface WebSocketConnection {
   /**
-       * Unique connection ID
-       */
+   * Unique connection ID
+   */
   id: string;
   /**
-       * User ID (if authenticated and security module is used)
-       */
+   * User ID (if authenticated and security module is used)
+   */
   userId?: string;
   /**
-       * Room IDs that this connection is currently in
-       */
+   * Room IDs that this connection is currently in
+   */
   roomIds: string[];
   /**
-       * Send a message to this connection
-       */
+   * Send a message to this connection
+   */
   send(message: any): Promise<void>;
   /**
-       * Close this connection
-       */
+   * Close this connection
+   */
   close(code?: number, reason?: string): Promise<void>;
   /**
-       * Connection metadata (custom data)
-       */
+   * Connection metadata (custom data)
+   */
   metadata?: Record<string, any>;
   /**
-       * Connection state
-       */
+   * Connection state
+   */
   readyState: WebSocketState;
 }
 /**
@@ -171,66 +171,66 @@ declare enum WebSocketState {
   CONNECTING = 0,
   OPEN = 1,
   CLOSING = 2,
-  CLOSED = 3,
+  CLOSED = 3
 }
 /**
  * WebSocket endpoint configuration (server-side)
  */
 interface WebSocketPrimitiveOptions<TClient extends TWSObject, TServer extends TWSObject> {
   /**
-       * Channel definition with schema and path
-       */
+   * Channel definition with schema and path
+   */
   channel: ChannelPrimitive<TClient, TServer>;
   /**
-       * Handler for incoming messages from clients
-       */
+   * Handler for incoming messages from clients
+   */
   handler: WebSocketHandler<TClient, TServer>;
   /**
-       * Optional connection handler (called when a client connects)
-       */
+   * Optional connection handler (called when a client connects)
+   */
   onConnect?: (params: {
     /**
-             * Unique connection ID of the client
-             */
+     * Unique connection ID of the client
+     */
     connectionId: string;
     /**
-             * User ID of the connected client (if authenticated and security module is used)
-             */
+     * User ID of the connected client (if authenticated and security module is used)
+     */
     userId?: string;
     /**
-             * Room IDs that the client is connecting to
-             */
+     * Room IDs that the client is connecting to
+     */
     roomIds: string[];
   }) => Promise<void> | void;
   /**
-       * Optional disconnection handler (called when a client disconnects)
-       */
+   * Optional disconnection handler (called when a client disconnects)
+   */
   onDisconnect?: (params: {
     /**
-             * Unique connection ID of the client
-             */
+     * Unique connection ID of the client
+     */
     connectionId: string;
     /**
-             * User ID of the connected client (if authenticated and security module is used)
-             */
+     * User ID of the connected client (if authenticated and security module is used)
+     */
     userId?: string;
     /**
-             * Room IDs that the client was connected to
-             */
+     * Room IDs that the client was connected to
+     */
     roomIds: string[];
   }) => Promise<void> | void;
   /**
-       * Change WebSocket server provider (for custom implementations)
-       */
+   * Change WebSocket server provider (for custom implementations)
+   */
   provider?: any;
   /**
-       * Whether to enforce security (authentication, authorization) on this WebSocket endpoint
-       * Requires alepha/security integration
-       */
+   * Whether to enforce security (authentication, authorization) on this WebSocket endpoint
+   * Requires alepha/security integration
+   */
   secure?: boolean;
   /**
-       * Limit number of connections per user (if authenticated)
-       */
+   * Limit number of connections per user (if authenticated)
+   */
   maxConnectionsPerUser?: number;
 }
 /**
@@ -242,46 +242,46 @@ type WebSocketHandler<TClient extends TWSObject, TServer extends TWSObject> = (c
  */
 interface WebSocketHandlerContext<TClient extends TWSObject, TServer extends TWSObject> {
   /**
-       * Unique connection ID of the client
-       */
+   * Unique connection ID of the client
+   */
   connectionId: string;
   /**
-       * User ID of the connected client (if authenticated and security module is used)
-       */
+   * User ID of the connected client (if authenticated and security module is used)
+   */
   userId?: string;
   /**
-       * Room ID that the client sent the message from
-       */
+   * Room ID that the client sent the message from
+   */
   roomId: string;
   /**
-       * The parsed and validated message from the client
-       */
+   * The parsed and validated message from the client
+   */
   message: Static<TServer>;
   /**
-       * Reply function tailored to current context (connectionId, roomId)
-       */
+   * Reply function tailored to current context (connectionId, roomId)
+   */
   reply: (options: {
     /**
-             * Message to send
-             */
+     * Message to send
+     */
     message: Static<TClient>;
     /**
-             * Optional: specify room ID to send to (defaults to sender's room ID)
-             */
+     * Optional: specify room ID to send to (defaults to sender's room ID)
+     */
     roomId?: string;
     /**
-             * Optional: exclude the sender connection from receiving the message
-             * Will populate exceptConnectionIds with sender connection ID behind the scenes
-             */
+     * Optional: exclude the sender connection from receiving the message
+     * Will populate exceptConnectionIds with sender connection ID behind the scenes
+     */
     exceptSelf?: boolean;
     /**
-             * Optional: exclude specific connection IDs from receiving the message
-             */
+     * Optional: exclude specific connection IDs from receiving the message
+     */
     exceptConnectionIds?: string[];
     /**
-             * Optional: exclude specific user IDs from receiving the message
-             * Requires alepha/security integration
-             */
+     * Optional: exclude specific user IDs from receiving the message
+     * Requires alepha/security integration
+     */
     exceptUserIds?: string[];
   }) => Promise<void>;
 }
@@ -290,41 +290,41 @@ interface WebSocketHandlerContext<TClient extends TWSObject, TServer extends TWS
  */
 interface EmitOptions<TClient extends TWSObject> {
   /**
-       * Message to send to clients
-       */
+   * Message to send to clients
+   */
   message: Static<TClient>;
   /**
-       * Room ID to send the message to
-       */
+   * Room ID to send the message to
+   */
   roomId?: string;
   /**
-       * Room IDs to send the message to
-       */
+   * Room IDs to send the message to
+   */
   roomIds?: string[];
   /**
-       * User ID to send the message to (if authenticated)
-       */
+   * User ID to send the message to (if authenticated)
+   */
   userId?: string;
   /**
-       * User IDs to send the message to (if authenticated)
-       */
+   * User IDs to send the message to (if authenticated)
+   */
   userIds?: string[];
   /**
-       * Connection ID to send the message to
-       */
+   * Connection ID to send the message to
+   */
   connectionId?: string;
   /**
-       * Connection IDs to send the message to
-       */
+   * Connection IDs to send the message to
+   */
   connectionIds?: string[];
   /**
-       * Optional: exclude specific connection IDs from receiving the message
-       */
+   * Optional: exclude specific connection IDs from receiving the message
+   */
   exceptConnectionIds?: string[];
   /**
-       * Optional: exclude specific user IDs from receiving the message
-       * Requires alepha/security integration
-       */
+   * Optional: exclude specific user IDs from receiving the message
+   * Requires alepha/security integration
+   */
   exceptUserIds?: string[];
 }
 //#endregion
@@ -337,30 +337,30 @@ interface EmitOptions<TClient extends TWSObject> {
  */
 declare abstract class WebSocketServerProvider {
   /**
-       * Register a WebSocket endpoint with its channel configuration
-       */
+   * Register a WebSocket endpoint with its channel configuration
+   */
   abstract registerEndpoint<TClient extends TWSObject, TServer extends TWSObject>(config: WebSocketPrimitiveOptions<TClient, TServer>): void;
   /**
-       * Emit a message to clients based on targeting criteria
-       *
-       * This method distributes messages across all server instances via pub/sub.
-       */
+   * Emit a message to clients based on targeting criteria
+   *
+   * This method distributes messages across all server instances via pub/sub.
+   */
   abstract emit<TClient extends TWSObject>(channelPath: string, options: EmitOptions<TClient>): Promise<void>;
   /**
-       * Get all active connections (local to this server instance)
-       */
+   * Get all active connections (local to this server instance)
+   */
   abstract getConnections(): WebSocketConnection[];
   /**
-       * Get connections in a specific room (local to this server instance)
-       */
+   * Get connections in a specific room (local to this server instance)
+   */
   abstract getRoomConnections(roomId: string): WebSocketConnection[];
   /**
-       * Get connections for a specific user (local to this server instance)
-       */
+   * Get connections for a specific user (local to this server instance)
+   */
   abstract getUserConnections(userId: string): WebSocketConnection[];
   /**
-       * Close a specific connection
-       */
+   * Close a specific connection
+   */
   abstract closeConnection(connectionId: string, code?: number, reason?: string): Promise<void>;
 }
 //#endregion
@@ -414,33 +414,33 @@ declare class WebSocketPrimitive<TClient extends TWSObject, TServer extends TWSO
   protected readonly webSocketServerProvider: WebSocketServerProvider;
   protected onInit(): void;
   /**
-       * Emit message to clients
-       *
-       * Send messages from the server to connected clients based on targeting criteria.
-       * Messages are distributed across all server instances via pub/sub.
-       *
-       * @example
-       * ```typescript
-       * // Send to specific room
-       * await websocket.emit({
-       *   roomId: "room-123",
-       *   message: { type: "update", data: {...} }
-       * });
-       *
-       * // Send to specific user (all their connections)
-       * await websocket.emit({
-       *   userId: "user-456",
-       *   message: { type: "notification", text: "Hello!" }
-       * });
-       *
-       * // Send to multiple rooms, except certain users
-       * await websocket.emit({
-       *   roomIds: ["room-1", "room-2"],
-       *   exceptUserIds: ["user-123"],
-       *   message: { type: "broadcast", content: "System announcement" }
-       * });
-       * ```
-       */
+   * Emit message to clients
+   *
+   * Send messages from the server to connected clients based on targeting criteria.
+   * Messages are distributed across all server instances via pub/sub.
+   *
+   * @example
+   * ```typescript
+   * // Send to specific room
+   * await websocket.emit({
+   *   roomId: "room-123",
+   *   message: { type: "update", data: {...} }
+   * });
+   *
+   * // Send to specific user (all their connections)
+   * await websocket.emit({
+   *   userId: "user-456",
+   *   message: { type: "notification", text: "Hello!" }
+   * });
+   *
+   * // Send to multiple rooms, except certain users
+   * await websocket.emit({
+   *   roomIds: ["room-1", "room-2"],
+   *   exceptUserIds: ["user-123"],
+   *   message: { type: "broadcast", content: "System announcement" }
+   * });
+   * ```
+   */
   emit(options: EmitOptions<TClient>): Promise<void>;
 }
 //#endregion
@@ -452,55 +452,55 @@ declare class WebSocketPrimitive<TClient extends TWSObject, TServer extends TWSO
  * and messages can be targeted to specific rooms.
  */
 declare class RoomManager {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   /**
-       * Maps roomId → Set<connectionId>
-       */
+   * Maps roomId → Set<connectionId>
+   */
   protected readonly rooms: Map<string, Set<string>>;
   /**
-       * Maps connectionId → Set<roomId>
-       * Inverse index for fast lookup of connection's rooms
-       */
+   * Maps connectionId → Set<roomId>
+   * Inverse index for fast lookup of connection's rooms
+   */
   protected readonly connectionRooms: Map<string, Set<string>>;
   /**
-       * Join a connection to one or more rooms
-       */
+   * Join a connection to one or more rooms
+   */
   joinRooms(connectionId: string, roomIds: string[]): void;
   /**
-       * Join a connection to a room
-       */
+   * Join a connection to a room
+   */
   joinRoom(connectionId: string, roomId: string): void;
   /**
-       * Leave a connection from a room
-       */
+   * Leave a connection from a room
+   */
   leaveRoom(connectionId: string, roomId: string): void;
   /**
-       * Remove a connection from all rooms
-       */
+   * Remove a connection from all rooms
+   */
   leaveAllRooms(connectionId: string): void;
   /**
-       * Get all connection IDs in a room
-       */
+   * Get all connection IDs in a room
+   */
   getRoomConnections(roomId: string): string[];
   /**
-       * Get all room IDs for a connection
-       */
+   * Get all room IDs for a connection
+   */
   getConnectionRooms(connectionId: string): string[];
   /**
-       * Check if a connection is in a room
-       */
+   * Check if a connection is in a room
+   */
   isInRoom(connectionId: string, roomId: string): boolean;
   /**
-       * Get all active rooms
-       */
+   * Get all active rooms
+   */
   getAllRooms(): string[];
   /**
-       * Get total number of connections across all rooms
-       */
+   * Get total number of connections across all rooms
+   */
   getTotalConnections(): number;
   /**
-       * Get room statistics
-       */
+   * Get room statistics
+   */
   getStats(): {
     totalRooms: number;
     totalConnections: number;
@@ -509,10 +509,10 @@ declare class RoomManager {
 }
 //#endregion
 //#region ../../src/websocket/services/WebSocketClient.d.ts
-declare const envSchema$1: alepha42.TObject<{
-  WEBSOCKET_URL: alepha42.TString;
-  WEBSOCKET_RECONNECT_INTERVAL: alepha42.TInteger;
-  WEBSOCKET_MAX_RECONNECT_ATTEMPTS: alepha42.TInteger;
+declare const envSchema$1: alepha6.TObject<{
+  WEBSOCKET_URL: alepha6.TString;
+  WEBSOCKET_RECONNECT_INTERVAL: alepha6.TInteger;
+  WEBSOCKET_MAX_RECONNECT_ATTEMPTS: alepha6.TInteger;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -533,7 +533,7 @@ declare class WebSocketChannelConnection<TClient extends TWSObject, TServer exte
   };
   protected readonly env: Static<typeof envSchema$1>;
   protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected ws?: WebSocket;
   protected reconnectAttempts: number;
   protected reconnectTimer?: number;
@@ -556,48 +556,48 @@ declare class WebSocketChannelConnection<TClient extends TWSObject, TServer exte
     maxReconnectAttempts?: number;
   }, env: Static<typeof envSchema$1>);
   /**
-       * Build WebSocket URL
-       */
+   * Build WebSocket URL
+   */
   protected buildUrl(): string;
   /**
-       * Subscribe to a room on this channel
-       */
+   * Subscribe to a room on this channel
+   */
   subscribe(roomId: string, handler: (message: Static<TClient>) => void, callbacks?: {
     onConnect?: () => void;
     onDisconnect?: () => void;
     onError?: (error: Error) => void;
   }): () => void;
   /**
-       * Connect to WebSocket server
-       */
+   * Connect to WebSocket server
+   */
   protected connect(): Promise<void>;
   /**
-       * Handle incoming message
-       */
+   * Handle incoming message
+   */
   protected handleMessage(data: string): void;
   /**
-       * Send message to a specific room
-       */
+   * Send message to a specific room
+   */
   send(roomId: string, message: Static<TServer>): Promise<void>;
   /**
-       * Schedule reconnection
-       */
+   * Schedule reconnection
+   */
   protected scheduleReconnect(): void;
   /**
-       * Disconnect from server
-       */
+   * Disconnect from server
+   */
   disconnect(): void;
   /**
-       * Reconnect manually
-       */
+   * Reconnect manually
+   */
   reconnect(): void;
   /**
-       * Check if subscribed to a room
-       */
+   * Check if subscribed to a room
+   */
   hasRoom(roomId: string): boolean;
   /**
-       * Get all subscribed rooms
-       */
+   * Get all subscribed rooms
+   */
   getRooms(): string[];
 }
 /**
@@ -607,7 +607,7 @@ declare class WebSocketChannelConnection<TClient extends TWSObject, TServer exte
  * One connection per channel, multiple rooms per connection.
  */
 declare class WebSocketClient {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected readonly alepha: Alepha;
   protected readonly env: {
     WEBSOCKET_URL: string;
@@ -616,8 +616,8 @@ declare class WebSocketClient {
   };
   protected connections: Map<string, WebSocketChannelConnection<any, any>>;
   /**
-       * Subscribe to a room on a channel
-       */
+   * Subscribe to a room on a channel
+   */
   subscribe<TClient extends TWSObject, TServer extends TWSObject>(roomId: string, channel: ChannelPrimitive<TClient, TServer>, handler: (message: Static<TClient>) => void, options?: {
     url?: string;
     autoReconnect?: boolean;
@@ -628,16 +628,16 @@ declare class WebSocketClient {
     onError?: (error: Error) => void;
   }): () => void;
   /**
-       * Send message to a room on a channel
-       */
+   * Send message to a room on a channel
+   */
   send<TClient extends TWSObject, TServer extends TWSObject>(roomId: string, channel: ChannelPrimitive<TClient, TServer>, message: Static<TServer>): Promise<void>;
   /**
-       * Get connection for a channel
-       */
+   * Get connection for a channel
+   */
   getConnection<TClient extends TWSObject, TServer extends TWSObject>(channel: ChannelPrimitive<TClient, TServer>): WebSocketChannelConnection<TClient, TServer> | undefined;
   /**
-       * Disconnect all connections
-       */
+   * Disconnect all connections
+   */
   disconnectAll(): void;
 }
 //#endregion
@@ -646,35 +646,35 @@ declare class WebSocketClient {
  * WebSocket message distribution event
  */
 declare const webSocketMessageSchema: {
-  payload: alepha42.TObject<{
+  payload: alepha6.TObject<{
     /**
-             * Channel path (e.g., "/ws/chat")
-             */
-    channelPath: alepha42.TString;
+     * Channel path (e.g., "/ws/chat")
+     */
+    channelPath: alepha6.TString;
     /**
-             * Target room ID(s)
-             */
-    roomIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+     * Target room ID(s)
+     */
+    roomIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
     /**
-             * Target user ID(s)
-             */
-    userIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+     * Target user ID(s)
+     */
+    userIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
     /**
-             * Target connection ID(s)
-             */
-    connectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+     * Target connection ID(s)
+     */
+    connectionIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
     /**
-             * Exclude connection ID(s) from receiving the message
-             */
-    exceptConnectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+     * Exclude connection ID(s) from receiving the message
+     */
+    exceptConnectionIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
     /**
-             * Exclude user ID(s) from receiving the message
-             */
-    exceptUserIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+     * Exclude user ID(s) from receiving the message
+     */
+    exceptUserIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
     /**
-             * The message payload to send
-             */
-    message: alepha42.TAny;
+     * The message payload to send
+     */
+    message: alepha6.TAny;
   }>;
 };
 /**
@@ -694,60 +694,60 @@ declare const webSocketMessageSchema: {
  * - Horizontal scaling without losing messages
  */
 declare class WebSocketTopicService {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   /**
-       * Handler function to be called when a message is received from the topic
-       * This is set by the WebSocket provider during initialization
-       */
+   * Handler function to be called when a message is received from the topic
+   * This is set by the WebSocket provider during initialization
+   */
   messageHandler?: (event: Static<(typeof webSocketMessageSchema)["payload"]>) => Promise<void>;
   /**
-       * Topic for distributing WebSocket messages across server instances
-       */
+   * Topic for distributing WebSocket messages across server instances
+   */
   readonly topic: alepha_topic0.TopicPrimitive<{
-    payload: alepha42.TObject<{
+    payload: alepha6.TObject<{
       /**
-                   * Channel path (e.g., "/ws/chat")
-                   */
-      channelPath: alepha42.TString;
+       * Channel path (e.g., "/ws/chat")
+       */
+      channelPath: alepha6.TString;
       /**
-                   * Target room ID(s)
-                   */
-      roomIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+       * Target room ID(s)
+       */
+      roomIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
       /**
-                   * Target user ID(s)
-                   */
-      userIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+       * Target user ID(s)
+       */
+      userIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
       /**
-                   * Target connection ID(s)
-                   */
-      connectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+       * Target connection ID(s)
+       */
+      connectionIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
       /**
-                   * Exclude connection ID(s) from receiving the message
-                   */
-      exceptConnectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+       * Exclude connection ID(s) from receiving the message
+       */
+      exceptConnectionIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
       /**
-                   * Exclude user ID(s) from receiving the message
-                   */
-      exceptUserIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
+       * Exclude user ID(s) from receiving the message
+       */
+      exceptUserIds: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
       /**
-                   * The message payload to send
-                   */
-      message: alepha42.TAny;
+       * The message payload to send
+       */
+      message: alepha6.TAny;
     }>;
   }>;
   /**
-       * Publish a message to be distributed across all server instances
-       */
+   * Publish a message to be distributed across all server instances
+   */
   publish(event: Static<(typeof webSocketMessageSchema)["payload"]>): Promise<void>;
   /**
-       * Set the handler for incoming messages
-       */
+   * Set the handler for incoming messages
+   */
   setMessageHandler(handler: (event: Static<(typeof webSocketMessageSchema)["payload"]>) => Promise<void>): void;
 }
 //#endregion
 //#region ../../src/websocket/providers/NodeWebSocketServerProvider.d.ts
-declare const envSchema: alepha42.TObject<{
-  WEBSOCKET_PATH: alepha42.TString;
+declare const envSchema: alepha6.TObject<{
+  WEBSOCKET_PATH: alepha6.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -756,7 +756,7 @@ declare class NodeWebSocketServerProvider extends WebSocketServerProvider {
   protected readonly alepha: Alepha;
   protected readonly roomManager: RoomManager;
   protected readonly topicService: WebSocketTopicService;
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   protected readonly env: {
     WEBSOCKET_PATH: string;
   };
@@ -775,9 +775,9 @@ declare class NodeWebSocketServerProvider extends WebSocketServerProvider {
   protected handleConnection<TClient extends TWSObject, TServer extends TWSObject>(ws: WebSocket$1, endpoint: WebSocketPrimitiveOptions<TClient, TServer>, request: IncomingMessage): void;
   protected extractRoomIds(url: URL): string[];
   /**
-       * Send message to local connections based on targeting criteria
-       * This is called by the topic service when a message is received
-       */
+   * Send message to local connections based on targeting criteria
+   * This is called by the topic service when a message is received
+   */
   protected sendToLocalConnections(channelPath: string, message: any, criteria: {
     roomIds?: string[];
     userIds?: string[];
@@ -785,9 +785,9 @@ declare class NodeWebSocketServerProvider extends WebSocketServerProvider {
     exceptConnectionIds?: string[];
     exceptUserIds?: string[];
   }): Promise<void>;
-  protected readonly start: alepha42.HookPrimitive<"start">;
-  protected readonly ready: alepha42.HookPrimitive<"ready">;
-  protected readonly stop: alepha42.HookPrimitive<"stop">;
+  protected readonly start: alepha6.HookPrimitive<"start">;
+  protected readonly ready: alepha6.HookPrimitive<"ready">;
+  protected readonly stop: alepha6.HookPrimitive<"stop">;
 }
 declare class NodeWebSocketConnection implements WebSocketConnection {
   readonly id: string;
@@ -796,7 +796,7 @@ declare class NodeWebSocketConnection implements WebSocketConnection {
   protected readonly ws: WebSocket$1;
   protected readonly provider: NodeWebSocketServerProvider;
   protected readonly endpoint: WebSocketPrimitiveOptions<any, any>;
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger1.Logger;
   metadata?: Record<string, any>;
   constructor(id: string, userId: string | undefined, roomIds: string[], ws: WebSocket$1, provider: NodeWebSocketServerProvider, endpoint: WebSocketPrimitiveOptions<any, any>);
   get readyState(): WebSocketState;
@@ -809,15 +809,15 @@ declare class NodeWebSocketConnection implements WebSocketConnection {
 declare module "alepha" {
   interface Hooks {
     /**
-             * Fires when a WebSocket connection is established
-             */
+     * Fires when a WebSocket connection is established
+     */
     "websocket:connect": {
       connectionId: string;
       path: string;
     };
     /**
-             * Fires when a WebSocket connection is closed
-             */
+     * Fires when a WebSocket connection is closed
+     */
     "websocket:disconnect": {
       connectionId: string;
       path: string;
@@ -825,16 +825,16 @@ declare module "alepha" {
       reason?: string;
     };
     /**
-             * Fires when a WebSocket message is received
-             */
+     * Fires when a WebSocket message is received
+     */
     "websocket:message": {
       connectionId: string;
       path: string;
       message: any;
     };
     /**
-             * Fires when a WebSocket error occurs
-             */
+     * Fires when a WebSocket error occurs
+     */
     "websocket:error": {
       connectionId: string;
       path: string;
@@ -855,7 +855,7 @@ declare module "alepha" {
  * @see {@link $websocket}
  * @module alepha.websockets
  */
-declare const AlephaWebSocket: alepha42.Service<alepha42.Module>;
+declare const AlephaWebSocket: alepha6.Service<alepha6.Module>;
 //#endregion
 export { $channel, $websocket, AlephaWebSocket, ChannelPrimitive, ChannelPrimitiveOptions, EmitOptions, NodeWebSocketConnection, NodeWebSocketServerProvider, RoomManager, TWSObject, WebSocketChannelConnection, WebSocketClient, WebSocketConnection, WebSocketConnectionError, WebSocketError, WebSocketHandler, WebSocketHandlerContext, WebSocketPrimitive, WebSocketPrimitiveOptions, WebSocketServerProvider, WebSocketState, WebSocketTopicService, WebSocketValidationError };
 //# sourceMappingURL=index.d.ts.map