alepha 0.12.1 → 0.13.1

package/dist/websocket/index.cjs

@@ -1,1117 +0,0 @@
-let alepha = require("alepha");
-let alepha_server = require("alepha/server");
-let alepha_topic = require("alepha/topic");
-let alepha_logger = require("alepha/logger");
-let ws = require("ws");
-
-//#region src/websocket/descriptors/$channel.ts
-/**
-* Defines a WebSocket channel with specified client and server message schemas.
-*
-* Channels must be defined as class properties to be registered in the Alepha context.
-* They define the "vocabulary" for communication - the schema for messages flowing
-* in both directions (server→client and client→server).
-*
-* @example Server-side with $websocket
-* ```typescript
-* class ChatController {
-*   // Channel must be defined inside a class
-*   chatChannel = $channel({
-*     path: "/ws/chat",
-*     description: "Real-time chat channel",
-*     schema: {
-*       // Server → Client messages
-*       in: t.union([
-*         t.object({
-*           type: t.const("append"),
-*           content: t.text(),
-*           username: t.text()
-*         }),
-*         t.object({
-*           type: t.const("system"),
-*           message: t.text()
-*         })
-*       ]),
-*       // Client → Server messages
-*       out: t.object({
-*         content: t.text()
-*       })
-*     }
-*   });
-*
-*   chat = $websocket({
-*     channel: this.chatChannel,
-*     handler: async ({ message, reply }) => {
-*       await reply({
-*         message: { type: "append", content: message.content, username: "user" }
-*       });
-*     }
-*   });
-* }
-* ```
-*
-* @example Browser-side with useRoom
-* ```typescript
-* // Define channel in a class for browser context
-* class ChatClient {
-*   chatChannel = $channel({
-*     path: "/ws/chat",
-*     schema: { in: inSchema, out: outSchema }
-*   });
-* }
-*
-* // Use in React component
-* function Chat() {
-*   const client = useInject(ChatClient);
-*   const chat = useRoom({ roomId: "lobby", channel: client.chatChannel, handler: ... }, []);
-* }
-* ```
-*/
-const $channel = (options) => {
-	return (0, alepha.createDescriptor)(ChannelDescriptor, options);
-};
-var ChannelDescriptor = class extends alepha.Descriptor {};
-$channel[alepha.KIND] = ChannelDescriptor;
-
-//#endregion
-//#region src/websocket/providers/WebSocketServerProvider.ts
-/**
-* Abstract WebSocket server provider
-*
-* This class provides the base interface that must be implemented by
-* platform-specific providers (Node.js, Browser, etc.)
-*/
-var WebSocketServerProvider = class {};
-
-//#endregion
-//#region src/websocket/descriptors/$websocket.ts
-/**
-* Defines a WebSocket server endpoint for a specific channel.
-*
-* Server-side only. Creates a WebSocket endpoint that:
-* - Accepts connections from clients
-* - Validates incoming messages against the channel schema
-* - Provides room-based messaging
-* - Integrates with alepha/security for authentication (optional)
-* - Supports horizontal scaling via alepha/topic
-*
-* @example
-* ```typescript
-* class ChatController {
-*   chat = $websocket({
-*     channel: chatChannel,
-*     handler: async ({ connectionId, userId, roomId, message, reply }) => {
-*       // Broadcast to all in room except sender
-*       await reply({
-*         message: {
-*           type: "append",
-*           username: userId,
-*           content: message.content
-*         },
-*         exceptSelf: true
-*       });
-*     }
-*   });
-*
-*   async broadcastAnnouncement(roomId: string, text: string) {
-*     await this.chat.emit({
-*       roomId,
-*       message: {
-*         type: "append",
-*         username: "System",
-*         content: text
-*       }
-*     });
-*   }
-* }
-* ```
-*/
-const $websocket = (options) => {
-	return (0, alepha.createDescriptor)(WebSocketDescriptor, options);
-};
-var WebSocketDescriptor = class extends alepha.Descriptor {
-	webSocketServerProvider = (0, alepha.$inject)(WebSocketServerProvider);
-	onInit() {
-		this.webSocketServerProvider.registerEndpoint(this.options);
-	}
-	/**
-	* 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" }
-	* });
-	* ```
-	*/
-	async emit(options) {
-		await this.webSocketServerProvider.emit(this.options.channel.options.path, options);
-	}
-};
-$websocket[alepha.KIND] = WebSocketDescriptor;
-
-//#endregion
-//#region src/websocket/errors/WebSocketError.ts
-/**
-* Base WebSocket error class
-*/
-var WebSocketError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "WebSocketError";
-	}
-};
-/**
-* Error thrown when WebSocket connection fails
-*/
-var WebSocketConnectionError = class extends WebSocketError {
-	constructor(message, code) {
-		super(message, code);
-		this.name = "WebSocketConnectionError";
-	}
-};
-/**
-* Error thrown when WebSocket message validation fails
-*/
-var WebSocketValidationError = class extends WebSocketError {
-	constructor(message) {
-		super(message);
-		this.name = "WebSocketValidationError";
-	}
-};
-
-//#endregion
-//#region src/websocket/services/RoomManager.ts
-/**
-* Manages WebSocket room memberships
-*
-* Rooms are logical groupings of connections. A connection can be in multiple rooms,
-* and messages can be targeted to specific rooms.
-*/
-var RoomManager = class {
-	log = (0, alepha_logger.$logger)();
-	/**
-	* Maps roomId → Set<connectionId>
-	*/
-	rooms = /* @__PURE__ */ new Map();
-	/**
-	* Maps connectionId → Set<roomId>
-	* Inverse index for fast lookup of connection's rooms
-	*/
-	connectionRooms = /* @__PURE__ */ new Map();
-	/**
-	* Join a connection to one or more rooms
-	*/
-	joinRooms(connectionId, roomIds) {
-		for (const roomId of roomIds) this.joinRoom(connectionId, roomId);
-	}
-	/**
-	* Join a connection to a room
-	*/
-	joinRoom(connectionId, roomId) {
-		let room = this.rooms.get(roomId);
-		if (!room) {
-			room = /* @__PURE__ */ new Set();
-			this.rooms.set(roomId, room);
-		}
-		room.add(connectionId);
-		let connRooms = this.connectionRooms.get(connectionId);
-		if (!connRooms) {
-			connRooms = /* @__PURE__ */ new Set();
-			this.connectionRooms.set(connectionId, connRooms);
-		}
-		connRooms.add(roomId);
-		this.log.debug(`Connection ${connectionId} joined room ${roomId}`);
-	}
-	/**
-	* Leave a connection from a room
-	*/
-	leaveRoom(connectionId, roomId) {
-		const room = this.rooms.get(roomId);
-		if (room) {
-			room.delete(connectionId);
-			if (room.size === 0) this.rooms.delete(roomId);
-		}
-		const connRooms = this.connectionRooms.get(connectionId);
-		if (connRooms) {
-			connRooms.delete(roomId);
-			if (connRooms.size === 0) this.connectionRooms.delete(connectionId);
-		}
-		this.log.debug(`Connection ${connectionId} left room ${roomId}`);
-	}
-	/**
-	* Remove a connection from all rooms
-	*/
-	leaveAllRooms(connectionId) {
-		const connRooms = this.connectionRooms.get(connectionId);
-		if (!connRooms) return;
-		for (const roomId of connRooms) {
-			const room = this.rooms.get(roomId);
-			if (room) {
-				room.delete(connectionId);
-				if (room.size === 0) this.rooms.delete(roomId);
-			}
-		}
-		this.connectionRooms.delete(connectionId);
-		this.log.debug(`Connection ${connectionId} left all rooms`);
-	}
-	/**
-	* Get all connection IDs in a room
-	*/
-	getRoomConnections(roomId) {
-		const room = this.rooms.get(roomId);
-		return room ? Array.from(room) : [];
-	}
-	/**
-	* Get all room IDs for a connection
-	*/
-	getConnectionRooms(connectionId) {
-		const connRooms = this.connectionRooms.get(connectionId);
-		return connRooms ? Array.from(connRooms) : [];
-	}
-	/**
-	* Check if a connection is in a room
-	*/
-	isInRoom(connectionId, roomId) {
-		const connRooms = this.connectionRooms.get(connectionId);
-		return connRooms ? connRooms.has(roomId) : false;
-	}
-	/**
-	* Get all active rooms
-	*/
-	getAllRooms() {
-		return Array.from(this.rooms.keys());
-	}
-	/**
-	* Get total number of connections across all rooms
-	*/
-	getTotalConnections() {
-		return this.connectionRooms.size;
-	}
-	/**
-	* Get room statistics
-	*/
-	getStats() {
-		const roomSizes = /* @__PURE__ */ new Map();
-		for (const [roomId, connections] of this.rooms) roomSizes.set(roomId, connections.size);
-		return {
-			totalRooms: this.rooms.size,
-			totalConnections: this.connectionRooms.size,
-			roomSizes
-		};
-	}
-};
-
-//#endregion
-//#region src/websocket/services/WebSocketTopicService.ts
-/**
-* WebSocket message distribution event
-*/
-const webSocketMessageSchema = { payload: alepha.t.object({
-	channelPath: alepha.t.text(),
-	roomIds: alepha.t.optional(alepha.t.array(alepha.t.text())),
-	userIds: alepha.t.optional(alepha.t.array(alepha.t.text())),
-	connectionIds: alepha.t.optional(alepha.t.array(alepha.t.text())),
-	exceptConnectionIds: alepha.t.optional(alepha.t.array(alepha.t.text())),
-	exceptUserIds: alepha.t.optional(alepha.t.array(alepha.t.text())),
-	message: alepha.t.any()
-}) };
-/**
-* WebSocket Topic Service
-*
-* Manages pub/sub messaging for WebSocket connections across multiple server instances.
-* Uses alepha/topic for cross-instance message distribution, enabling horizontal scaling.
-*
-* When a WebSocket message needs to be sent:
-* 1. Server instance A publishes to the topic
-* 2. All server instances (A, B, C, etc.) receive the message
-* 3. Each instance sends to its local connections that match the criteria
-*
-* This enables:
-* - Multiple server instances handling WebSocket connections
-* - Redis-backed message distribution (with alepha/topic/redis)
-* - Horizontal scaling without losing messages
-*/
-var WebSocketTopicService = class {
-	log = (0, alepha_logger.$logger)();
-	/**
-	* Handler function to be called when a message is received from the topic
-	* This is set by the WebSocket provider during initialization
-	*/
-	messageHandler;
-	/**
-	* Topic for distributing WebSocket messages across server instances
-	*/
-	topic = (0, alepha_topic.$topic)({
-		name: "websocket:broadcast",
-		description: "Distributes WebSocket messages across server instances for horizontal scaling",
-		schema: webSocketMessageSchema,
-		handler: async (message) => {
-			if (this.messageHandler) await this.messageHandler(message.payload);
-		}
-	});
-	/**
-	* Publish a message to be distributed across all server instances
-	*/
-	async publish(event) {
-		await this.topic.publish(event);
-	}
-	/**
-	* Set the handler for incoming messages
-	*/
-	setMessageHandler(handler) {
-		this.messageHandler = handler;
-	}
-};
-
-//#endregion
-//#region src/websocket/providers/NodeWebSocketServerProvider.ts
-const envSchema$1 = alepha.t.object({ WEBSOCKET_PATH: alepha.t.text({
-	default: "/ws",
-	description: "Base path for WebSocket endpoints"
-}) });
-var NodeWebSocketServerProvider = class extends WebSocketServerProvider {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	roomManager = (0, alepha.$inject)(RoomManager);
-	topicService = (0, alepha.$inject)(WebSocketTopicService);
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$1);
-	wss;
-	endpoints = /* @__PURE__ */ new Map();
-	connections = /* @__PURE__ */ new Map();
-	userConnections = /* @__PURE__ */ new Map();
-	nextConnectionId = 1;
-	registerEndpoint(config) {
-		const path = config.channel.options.path;
-		this.endpoints.set(path, config);
-	}
-	async emit(channelPath, options) {
-		await this.topicService.publish({
-			channelPath,
-			roomIds: options.roomIds ? options.roomIds : options.roomId ? [options.roomId] : void 0,
-			userIds: options.userIds ? options.userIds : options.userId ? [options.userId] : void 0,
-			connectionIds: options.connectionIds ? options.connectionIds : options.connectionId ? [options.connectionId] : void 0,
-			exceptConnectionIds: options.exceptConnectionIds,
-			exceptUserIds: options.exceptUserIds,
-			message: options.message
-		});
-	}
-	getConnections() {
-		return Array.from(this.connections.values());
-	}
-	getRoomConnections(roomId) {
-		return this.roomManager.getRoomConnections(roomId).map((id) => this.connections.get(id)).filter((conn) => conn !== void 0);
-	}
-	getUserConnections(userId) {
-		const connectionIds = this.userConnections.get(userId);
-		if (!connectionIds) return [];
-		return Array.from(connectionIds).map((id) => this.connections.get(id)).filter((conn) => conn !== void 0);
-	}
-	async closeConnection(connectionId, code, reason) {
-		const connection = this.connections.get(connectionId);
-		if (!connection) {
-			this.log.warn(`Connection not found: ${connectionId}`);
-			return;
-		}
-		await connection.close(code, reason);
-	}
-	handleUpgrade(request, socket, head) {
-		const path = new URL(request.url || "/", "http://localhost").pathname;
-		const endpoint = this.endpoints.get(path);
-		if (!endpoint) {
-			if (!this.alepha.isViteDev()) {
-				this.log.warn(`No WebSocket endpoint found for path: ${path}`);
-				socket.destroy();
-			}
-			return false;
-		}
-		this.log.debug(`WebSocket upgrade request: ${path}`);
-		this.wss?.handleUpgrade(request, socket, head, (ws$1) => {
-			this.handleConnection(ws$1, endpoint, request);
-		});
-		return true;
-	}
-	handleConnection(ws$1, endpoint, request) {
-		const connectionId = `ws-${this.nextConnectionId++}`;
-		const userId = void 0;
-		const url = new URL(request.url || "/", "http://localhost");
-		const roomIds = this.extractRoomIds(url);
-		const connection = this.alepha.inject(NodeWebSocketConnection, {
-			lifetime: "transient",
-			args: [
-				connectionId,
-				userId,
-				roomIds,
-				ws$1,
-				this,
-				endpoint
-			]
-		});
-		this.connections.set(connectionId, connection);
-		if (roomIds.length > 0) this.roomManager.joinRooms(connectionId, roomIds);
-		this.log.info(`WebSocket connection established: ${connectionId}`, {
-			path: endpoint.channel.options.path,
-			userId,
-			roomIds,
-			remoteAddress: request.socket.remoteAddress
-		});
-		if (endpoint.onConnect) Promise.resolve(endpoint.onConnect({
-			connectionId,
-			userId,
-			roomIds
-		})).catch((error) => {
-			this.log.error("Error in onConnect handler:", error);
-		});
-		ws$1.on("message", async (data) => {
-			await connection.handleMessage(data);
-		});
-		ws$1.on("close", (code, reason) => {
-			this.log.info(`WebSocket connection closed: ${connectionId}`, {
-				code,
-				reason: reason.toString()
-			});
-			this.connections.delete(connectionId);
-			this.roomManager.leaveAllRooms(connectionId);
-			if (endpoint.onDisconnect) Promise.resolve(endpoint.onDisconnect({
-				connectionId,
-				userId,
-				roomIds
-			})).catch((error) => {
-				this.log.error("Error in onDisconnect handler:", error);
-			});
-		});
-		ws$1.on("error", (error) => {
-			this.log.error(`WebSocket error on ${connectionId}:`, error);
-		});
-	}
-	extractRoomIds(url) {
-		const roomIds = [];
-		const roomIdParams = url.searchParams.getAll("roomId");
-		roomIds.push(...roomIdParams);
-		const roomIdsParam = url.searchParams.get("roomIds");
-		if (roomIdsParam) roomIds.push(...roomIdsParam.split(",").map((id) => id.trim()));
-		if (roomIds.length === 0) roomIds.push("default");
-		return roomIds;
-	}
-	/**
-	* Send message to local connections based on targeting criteria
-	* This is called by the topic service when a message is received
-	*/
-	async sendToLocalConnections(channelPath, message, criteria) {
-		const targetConnections = /* @__PURE__ */ new Set();
-		if (criteria.roomIds) for (const roomId of criteria.roomIds) {
-			const roomConns = this.roomManager.getRoomConnections(roomId);
-			for (const connId of roomConns) targetConnections.add(connId);
-		}
-		if (criteria.userIds) for (const userId of criteria.userIds) {
-			const userConns = this.userConnections.get(userId);
-			if (userConns) for (const connId of userConns) targetConnections.add(connId);
-		}
-		if (criteria.connectionIds) for (const connId of criteria.connectionIds) targetConnections.add(connId);
-		if (!criteria.roomIds && !criteria.userIds && !criteria.connectionIds) for (const conn of this.connections.values()) targetConnections.add(conn.id);
-		if (criteria.exceptConnectionIds) for (const connId of criteria.exceptConnectionIds) targetConnections.delete(connId);
-		if (criteria.exceptUserIds) for (const userId of criteria.exceptUserIds) {
-			const userConns = this.userConnections.get(userId);
-			if (userConns) for (const connId of userConns) targetConnections.delete(connId);
-		}
-		const serialized = JSON.stringify(message);
-		await Promise.all(Array.from(targetConnections).map(async (connId) => {
-			const conn = this.connections.get(connId);
-			if (conn) try {
-				await conn.send(serialized);
-			} catch (error) {
-				this.log.error(`Failed to send to connection ${connId}:`, error);
-			}
-		}));
-	}
-	start = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			if (this.alepha.isServerless()) {
-				this.log.debug("WebSocket server disabled in serverless mode");
-				return;
-			}
-			this.wss = new ws.WebSocketServer({ noServer: true });
-			for (const [path, endpoint] of this.endpoints.entries()) this.log.debug(`WebSocket endpoint registered: ${path}`);
-			this.topicService.setMessageHandler(async (event) => {
-				await this.sendToLocalConnections(event.channelPath, event.message, {
-					roomIds: event.roomIds,
-					userIds: event.userIds,
-					connectionIds: event.connectionIds,
-					exceptConnectionIds: event.exceptConnectionIds,
-					exceptUserIds: event.exceptUserIds
-				});
-			});
-			this.log.info("WebSocket server OK", { basePath: this.env.WEBSOCKET_PATH });
-		}
-	});
-	ready = (0, alepha.$hook)({
-		on: "ready",
-		handler: async () => {
-			if (this.alepha.isServerless() || !this.wss) return;
-			const httpServer = this.alepha.state.get("alepha.node.server");
-			if (httpServer) {
-				httpServer.on("upgrade", (request, socket, head) => {
-					this.handleUpgrade(request, socket, head);
-				});
-				this.log.debug("WebSocket upgrade handler attached to HTTP server");
-			} else this.log.warn("No HTTP server found - WebSocket upgrade handler not attached");
-		}
-	});
-	stop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (!this.wss) return;
-			for (const connection of this.connections.values()) await connection.close(1001, "Server shutting down");
-			await new Promise((resolve, reject) => {
-				this.wss?.close((err) => {
-					if (err) reject(err);
-					else resolve();
-				});
-			});
-			this.log.info("WebSocket server closed");
-		}
-	});
-};
-var NodeWebSocketConnection = class {
-	log = (0, alepha_logger.$logger)();
-	metadata;
-	constructor(id, userId, roomIds, ws$1, provider, endpoint) {
-		this.id = id;
-		this.userId = userId;
-		this.roomIds = roomIds;
-		this.ws = ws$1;
-		this.provider = provider;
-		this.endpoint = endpoint;
-	}
-	get readyState() {
-		return this.ws.readyState;
-	}
-	async send(message) {
-		if (this.ws.readyState !== ws.WebSocket.OPEN) throw new Error("WebSocket is not open");
-		const data = typeof message === "string" ? message : JSON.stringify(message);
-		await new Promise((resolve, reject) => {
-			this.ws.send(data, (err) => {
-				if (err) reject(err);
-				else resolve();
-			});
-		});
-	}
-	async close(code, reason) {
-		this.ws.close(code, reason);
-	}
-	async handleMessage(data) {
-		try {
-			const rawMessage = data.toString();
-			let parsed;
-			try {
-				parsed = JSON.parse(rawMessage);
-			} catch {
-				this.log.warn("Received non-JSON message");
-				return;
-			}
-			const roomId = parsed.roomId || this.roomIds[0] || "default";
-			const message = parsed.message || parsed;
-			const outSchema = this.endpoint.channel.options.schema.out;
-			if (!alepha.TypeBoxValue.Check(outSchema, message)) throw new WebSocketValidationError(`Message validation failed: ${Array.from(alepha.TypeBoxValue.Errors(outSchema, message)).map((e) => e.message).join(", ")}`);
-			const reply = async (options) => {
-				const targetRoomId = options.roomId || roomId;
-				const exceptConnectionIds = options.exceptConnectionIds || [];
-				if (options.exceptSelf) exceptConnectionIds.push(this.id);
-				await this.provider.emit(this.endpoint.channel.options.path, {
-					message: options.message,
-					roomId: targetRoomId,
-					exceptConnectionIds,
-					exceptUserIds: options.exceptUserIds
-				});
-			};
-			const context = {
-				connectionId: this.id,
-				userId: this.userId,
-				roomId,
-				message,
-				reply
-			};
-			await this.endpoint.handler(context);
-		} catch (error) {
-			this.log.error(`Error handling WebSocket message on ${this.id}:`, error);
-			await this.send({ error: error instanceof Error ? error.message : "Unknown error" });
-		}
-	}
-};
-
-//#endregion
-//#region src/websocket/interfaces/WebSocketInterfaces.ts
-/**
-* WebSocket state enum
-*/
-let WebSocketState = /* @__PURE__ */ function(WebSocketState$1) {
-	WebSocketState$1[WebSocketState$1["CONNECTING"] = 0] = "CONNECTING";
-	WebSocketState$1[WebSocketState$1["OPEN"] = 1] = "OPEN";
-	WebSocketState$1[WebSocketState$1["CLOSING"] = 2] = "CLOSING";
-	WebSocketState$1[WebSocketState$1["CLOSED"] = 3] = "CLOSED";
-	return WebSocketState$1;
-}({});
-
-//#endregion
-//#region src/websocket/services/WebSocketClient.ts
-const envSchema = alepha.t.object({
-	WEBSOCKET_URL: alepha.t.text({
-		default: "",
-		description: "WebSocket server URL (e.g., ws://localhost:3001). Leave empty to auto-detect."
-	}),
-	WEBSOCKET_RECONNECT_INTERVAL: alepha.t.integer({
-		default: 3e3,
-		description: "Reconnection interval in milliseconds"
-	}),
-	WEBSOCKET_MAX_RECONNECT_ATTEMPTS: alepha.t.integer({
-		default: 10,
-		description: "Maximum number of reconnection attempts. Set to -1 for infinite."
-	})
-});
-/**
-* WebSocket channel connection
-*
-* Manages a single WebSocket connection to a channel with multiple room subscriptions.
-* One connection can handle multiple rooms on the same channel.
-*/
-var WebSocketChannelConnection = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	log = (0, alepha_logger.$logger)();
-	ws;
-	reconnectAttempts = 0;
-	reconnectTimer;
-	messageQueue = [];
-	subscriptions = /* @__PURE__ */ new Map();
-	isConnected = false;
-	isConnecting = false;
-	isError = false;
-	error;
-	onConnectCallbacks = /* @__PURE__ */ new Set();
-	onDisconnectCallbacks = /* @__PURE__ */ new Set();
-	onErrorCallbacks = /* @__PURE__ */ new Set();
-	constructor(channel, options, env) {
-		this.channel = channel;
-		this.options = options;
-		this.env = env;
-	}
-	/**
-	* Build WebSocket URL
-	*/
-	buildUrl() {
-		this.log.trace("Building WebSocket URL", {
-			hasCustomUrl: !!this.options.url,
-			channelPath: this.channel.options.path
-		});
-		if (this.options.url) {
-			this.log.debug("Using custom WebSocket URL", { url: this.options.url });
-			return this.options.url;
-		}
-		if (typeof window !== "undefined") {
-			const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-			const host = window.location.host;
-			const path = this.channel.options.path;
-			const roomIds = Array.from(this.subscriptions.keys());
-			const url$1 = `${protocol}//${host}${path}${roomIds.length > 0 ? `?roomIds=${roomIds.join(",")}` : ""}`;
-			this.log.debug("Auto-detected WebSocket URL", {
-				url: url$1,
-				roomIds
-			});
-			return url$1;
-		}
-		const url = `${this.env.WEBSOCKET_URL}${this.channel.options.path}`;
-		this.log.debug("Using env WebSocket URL", { url });
-		return url;
-	}
-	/**
-	* Subscribe to a room on this channel
-	*/
-	subscribe(roomId, handler, callbacks) {
-		this.log.debug("Subscribing to room", {
-			roomId,
-			channelPath: this.channel.options.path,
-			existingSubscriptions: this.subscriptions.size
-		});
-		this.subscriptions.set(roomId, handler);
-		if (callbacks?.onConnect) this.onConnectCallbacks.add(callbacks.onConnect);
-		if (callbacks?.onDisconnect) this.onDisconnectCallbacks.add(callbacks.onDisconnect);
-		if (callbacks?.onError) this.onErrorCallbacks.add(callbacks.onError);
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-			this.log.trace("No active connection, initiating connect");
-			this.connect().catch((error) => {
-				this.log.error("Failed to connect:", error);
-			});
-		} else this.log.trace("Already connected, reusing existing connection");
-		return () => {
-			this.log.debug("Unsubscribing from room", { roomId });
-			this.subscriptions.delete(roomId);
-			if (callbacks?.onConnect) this.onConnectCallbacks.delete(callbacks.onConnect);
-			if (callbacks?.onDisconnect) this.onDisconnectCallbacks.delete(callbacks.onDisconnect);
-			if (callbacks?.onError) this.onErrorCallbacks.delete(callbacks.onError);
-			if (this.subscriptions.size === 0) {
-				this.log.debug("No more subscriptions, disconnecting");
-				this.disconnect();
-			}
-		};
-	}
-	/**
-	* Connect to WebSocket server
-	*/
-	async connect() {
-		if (this.ws?.readyState === WebSocket.OPEN) {
-			this.log.trace("Already connected, skipping connect");
-			return;
-		}
-		this.isConnecting = true;
-		this.isError = false;
-		this.error = void 0;
-		const url = this.buildUrl();
-		this.log.info("Connecting to WebSocket server", { url });
-		return new Promise((resolve, reject) => {
-			try {
-				const ws$1 = new WebSocket(url);
-				this.ws = ws$1;
-				ws$1.onopen = () => {
-					this.isConnected = true;
-					this.isConnecting = false;
-					this.isError = false;
-					this.error = void 0;
-					this.reconnectAttempts = 0;
-					this.log.info("WebSocket connected", {
-						channelPath: this.channel.options.path,
-						rooms: Array.from(this.subscriptions.keys())
-					});
-					if (this.messageQueue.length > 0) this.log.debug("Flushing queued messages", { count: this.messageQueue.length });
-					while (this.messageQueue.length > 0) {
-						const msg = this.messageQueue.shift();
-						if (msg) {
-							this.log.trace("Sending queued message", { roomId: msg.roomId });
-							ws$1.send(JSON.stringify({
-								roomId: msg.roomId,
-								message: msg.message
-							}));
-						}
-					}
-					for (const callback of this.onConnectCallbacks) callback();
-					resolve();
-				};
-				ws$1.onmessage = (event) => {
-					this.log.trace("Message received", { dataLength: event.data?.length });
-					this.handleMessage(event.data);
-				};
-				ws$1.onclose = (event) => {
-					this.isConnected = false;
-					this.isConnecting = false;
-					this.ws = void 0;
-					this.log.info("WebSocket disconnected", {
-						code: event.code,
-						reason: event.reason,
-						wasClean: event.wasClean
-					});
-					for (const callback of this.onDisconnectCallbacks) callback();
-					if (this.options.autoReconnect !== false) this.scheduleReconnect();
-				};
-				ws$1.onerror = () => {
-					const err = /* @__PURE__ */ new Error("WebSocket connection error");
-					this.isError = true;
-					this.error = err;
-					this.isConnecting = false;
-					this.log.error("WebSocket error", { url });
-					for (const callback of this.onErrorCallbacks) callback(err);
-					reject(err);
-				};
-			} catch (err) {
-				const error = err instanceof Error ? err : /* @__PURE__ */ new Error("Connection failed");
-				this.isError = true;
-				this.error = error;
-				this.isConnecting = false;
-				this.log.error("Failed to create WebSocket", { error: error.message });
-				for (const callback of this.onErrorCallbacks) callback(error);
-				reject(error);
-			}
-		});
-	}
-	/**
-	* Handle incoming message
-	*/
-	handleMessage(data) {
-		try {
-			const parsed = JSON.parse(data);
-			this.log.trace("Parsed incoming message", { parsed });
-			const inSchema = this.channel.options.schema.in;
-			this.alepha.codec.validate(inSchema, parsed);
-			this.log.debug("Dispatching message to handlers", { handlerCount: this.subscriptions.size });
-			for (const handler of this.subscriptions.values()) handler(parsed);
-		} catch (err) {
-			this.log.error("Error handling message:", err);
-		}
-	}
-	/**
-	* Send message to a specific room
-	*/
-	async send(roomId, message) {
-		this.log.trace("Sending message", {
-			roomId,
-			message
-		});
-		const outSchema = this.channel.options.schema.out;
-		if (!alepha.TypeBoxValue.Check(outSchema, message)) {
-			const errors = Array.from(alepha.TypeBoxValue.Errors(outSchema, message));
-			this.log.warn("Message validation failed", { errors });
-			throw new Error(`Message validation failed: ${errors.map((e) => e.message).join(", ")}`);
-		}
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-			this.log.debug("Connection not ready, queuing message", {
-				roomId,
-				queueSize: this.messageQueue.length + 1
-			});
-			this.messageQueue.push({
-				roomId,
-				message
-			});
-			return;
-		}
-		this.log.debug("Sending message to server", { roomId });
-		this.ws.send(JSON.stringify({
-			roomId,
-			message
-		}));
-	}
-	/**
-	* Schedule reconnection
-	*/
-	scheduleReconnect() {
-		const maxAttempts = this.options.maxReconnectAttempts ?? this.env.WEBSOCKET_MAX_RECONNECT_ATTEMPTS ?? 10;
-		const reconnectInterval = this.options.reconnectInterval ?? this.env.WEBSOCKET_RECONNECT_INTERVAL ?? 3e3;
-		if (maxAttempts !== -1 && this.reconnectAttempts >= maxAttempts) {
-			this.log.warn("Max reconnection attempts reached", {
-				attempts: this.reconnectAttempts,
-				maxAttempts
-			});
-			return;
-		}
-		this.reconnectAttempts++;
-		this.log.debug("Scheduling reconnection", {
-			attempt: this.reconnectAttempts,
-			maxAttempts,
-			intervalMs: reconnectInterval
-		});
-		this.reconnectTimer = window.setTimeout(() => {
-			this.log.info("Reconnecting...", {
-				attempt: this.reconnectAttempts,
-				maxAttempts
-			});
-			this.connect().catch((error) => {
-				this.log.error("Reconnection failed:", error);
-			});
-		}, reconnectInterval);
-	}
-	/**
-	* Disconnect from server
-	*/
-	disconnect() {
-		this.log.debug("Disconnecting", {
-			hasTimer: !!this.reconnectTimer,
-			hasConnection: !!this.ws
-		});
-		if (this.reconnectTimer) {
-			clearTimeout(this.reconnectTimer);
-			this.reconnectTimer = void 0;
-		}
-		if (this.ws) {
-			this.ws.close();
-			this.ws = void 0;
-		}
-		this.isConnected = false;
-		this.isConnecting = false;
-		this.log.info("Disconnected");
-	}
-	/**
-	* Reconnect manually
-	*/
-	reconnect() {
-		this.log.info("Manual reconnect requested");
-		this.disconnect();
-		this.connect().catch((error) => {
-			this.log.error("Manual reconnection failed:", error);
-		});
-	}
-	/**
-	* Check if subscribed to a room
-	*/
-	hasRoom(roomId) {
-		return this.subscriptions.has(roomId);
-	}
-	/**
-	* Get all subscribed rooms
-	*/
-	getRooms() {
-		return Array.from(this.subscriptions.keys());
-	}
-};
-/**
-* WebSocket Client Service
-*
-* Manages WebSocket connections from the client side (browser).
-* One connection per channel, multiple rooms per connection.
-*/
-var WebSocketClient = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	env = (0, alepha.$env)(envSchema);
-	connections = /* @__PURE__ */ new Map();
-	/**
-	* Subscribe to a room on a channel
-	*/
-	subscribe(roomId, channel, handler, options = {}) {
-		const channelPath = channel.options.path;
-		this.log.debug("WebSocketClient.subscribe", {
-			roomId,
-			channelPath,
-			existingConnections: this.connections.size
-		});
-		let connection = this.connections.get(channelPath);
-		if (!connection) {
-			this.log.debug("Creating new connection for channel", { channelPath });
-			connection = this.alepha.inject(WebSocketChannelConnection, {
-				lifetime: "transient",
-				args: [
-					channel,
-					{
-						url: options.url,
-						autoReconnect: options.autoReconnect,
-						reconnectInterval: options.reconnectInterval,
-						maxReconnectAttempts: options.maxReconnectAttempts
-					},
-					this.env
-				]
-			});
-			this.connections.set(channelPath, connection);
-		} else this.log.trace("Reusing existing connection for channel", { channelPath });
-		const unsubscribe = connection.subscribe(roomId, handler, {
-			onConnect: options.onConnect,
-			onDisconnect: options.onDisconnect,
-			onError: options.onError
-		});
-		return () => {
-			this.log.debug("WebSocketClient.unsubscribe", {
-				roomId,
-				channelPath
-			});
-			unsubscribe();
-			if (connection.getRooms().length === 0) {
-				this.log.debug("Removing connection for channel (no more rooms)", { channelPath });
-				this.connections.delete(channelPath);
-			}
-		};
-	}
-	/**
-	* Send message to a room on a channel
-	*/
-	async send(roomId, channel, message) {
-		const channelPath = channel.options.path;
-		this.log.trace("WebSocketClient.send", {
-			roomId,
-			channelPath
-		});
-		const connection = this.connections.get(channelPath);
-		if (!connection) {
-			this.log.warn("Attempted to send on unsubscribed channel", { channelPath });
-			throw new alepha.AlephaError(`Not subscribed to channel ${channelPath}. Subscribe first before sending messages.`);
-		}
-		await connection.send(roomId, message);
-	}
-	/**
-	* Get connection for a channel
-	*/
-	getConnection(channel) {
-		const channelPath = channel.options.path;
-		const connection = this.connections.get(channelPath);
-		this.log.trace("WebSocketClient.getConnection", {
-			channelPath,
-			found: !!connection
-		});
-		return connection;
-	}
-	/**
-	* Disconnect all connections
-	*/
-	disconnectAll() {
-		this.log.info("Disconnecting all connections", { count: this.connections.size });
-		for (const connection of this.connections.values()) connection.disconnect();
-		this.connections.clear();
-		this.log.debug("All connections disconnected");
-	}
-};
-
-//#endregion
-//#region src/websocket/index.ts
-/**
-* Provides real-time bidirectional communication using WebSockets.
-*
-* The WebSockets module enables building real-time applications using the `$websocket` descriptor
-* on class properties. It provides automatic connection management, message routing, type-safe
-* message handling, and seamless integration with other Alepha modules.
-*
-* On the server side (Node.js), it uses the 'ws' library to create a WebSocket server.
-* On the client side (browser), it uses the native WebSocket API.
-*
-* @see {@link $websocket}
-* @module alepha.websockets
-*/
-const AlephaWebSocket = (0, alepha.$module)({
-	name: "alepha.websocket",
-	descriptors: [$channel, $websocket],
-	services: [
-		WebSocketServerProvider,
-		NodeWebSocketServerProvider,
-		RoomManager,
-		WebSocketTopicService
-	],
-	register: (alepha$1) => {
-		alepha$1.with(alepha_server.AlephaServer);
-		alepha$1.with(alepha_topic.AlephaTopic);
-		alepha$1.with({
-			provide: WebSocketServerProvider,
-			use: NodeWebSocketServerProvider
-		});
-	}
-});
-
-//#endregion
-exports.$channel = $channel;
-exports.$websocket = $websocket;
-exports.AlephaWebSocket = AlephaWebSocket;
-exports.ChannelDescriptor = ChannelDescriptor;
-exports.NodeWebSocketConnection = NodeWebSocketConnection;
-exports.NodeWebSocketServerProvider = NodeWebSocketServerProvider;
-exports.RoomManager = RoomManager;
-exports.WebSocketChannelConnection = WebSocketChannelConnection;
-exports.WebSocketClient = WebSocketClient;
-exports.WebSocketConnectionError = WebSocketConnectionError;
-exports.WebSocketDescriptor = WebSocketDescriptor;
-exports.WebSocketError = WebSocketError;
-exports.WebSocketServerProvider = WebSocketServerProvider;
-exports.WebSocketState = WebSocketState;
-exports.WebSocketTopicService = WebSocketTopicService;
-exports.WebSocketValidationError = WebSocketValidationError;
-//# sourceMappingURL=index.cjs.map