alepha 0.20.6 → 0.20.7

package/dist/websocket/index.browser.js

@@ -1,848 +0,0 @@
-import { $env, $inject, $module, Alepha, AlephaError, KIND, Primitive, SchemaValidator, createPrimitive, t } from "alepha";
-import { $topic, AlephaTopic } from "alepha/topic";
-import { $logger } from "alepha/logger";
-//#region ../../src/websocket/primitives/$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 createPrimitive(ChannelPrimitive, options);
-};
-var ChannelPrimitive = class extends Primitive {};
-$channel[KIND] = ChannelPrimitive;
-//#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/primitives/$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 createPrimitive(WebSocketPrimitive, options);
-};
-var WebSocketPrimitive = class extends Primitive {
-	webSocketServerProvider = $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[KIND] = WebSocketPrimitive;
-//#endregion
-//#region ../../src/websocket/services/WebSocketClient.ts
-const envSchema = t.object({
-	WEBSOCKET_URL: t.text({
-		default: "",
-		description: "WebSocket server URL (e.g., ws://localhost:3001). Leave empty to auto-detect."
-	}),
-	WEBSOCKET_RECONNECT_INTERVAL: t.integer({
-		default: 3e3,
-		description: "Reconnection interval in milliseconds"
-	}),
-	WEBSOCKET_MAX_RECONNECT_ATTEMPTS: 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 WebSocketChannelConnection {
-	channel;
-	options;
-	env;
-	alepha = $inject(Alepha);
-	schemaValidator = $inject(SchemaValidator);
-	log = $logger();
-	ws;
-	reconnectAttempts = 0;
-	reconnectTimer;
-	static MAX_QUEUE_SIZE = 1e3;
-	messageQueue = [];
-	subscriptions = /* @__PURE__ */ new Map();
-	isConnected = false;
-	isConnecting = false;
-	isError = false;
-	error;
-	connectPromise;
-	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 = `${protocol}//${host}${path}${roomIds.length > 0 ? `?roomIds=${roomIds.join(",")}` : ""}`;
-			this.log.debug("Auto-detected WebSocket URL", {
-				url,
-				roomIds
-			});
-			return url;
-		}
-		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("Reconnecting to include new room subscription", { roomId });
-			this.reconnect();
-		}
-		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;
-		}
-		if (this.connectPromise) {
-			this.log.trace("Connection already in progress, reusing promise");
-			return this.connectPromise;
-		}
-		this.isConnecting = true;
-		this.isError = false;
-		this.error = void 0;
-		const url = this.buildUrl();
-		this.log.info("Connecting to WebSocket server", { url });
-		this.connectPromise = new Promise((resolve, reject) => {
-			try {
-				const ws = new WebSocket(url);
-				this.ws = ws;
-				ws.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.send(JSON.stringify({
-								roomId: msg.roomId,
-								message: msg.message
-							}));
-						}
-					}
-					for (const callback of this.onConnectCallbacks) callback();
-					resolve();
-				};
-				ws.onmessage = (event) => {
-					this.log.trace("Message received", { dataLength: event.data?.length });
-					this.handleMessage(event.data);
-				};
-				ws.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.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);
-			}
-		}).finally(() => {
-			this.connectPromise = void 0;
-		});
-		return this.connectPromise;
-	}
-	/**
-	* 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;
-		try {
-			this.schemaValidator.validate(outSchema, message, {
-				trim: false,
-				nullToUndefined: false,
-				deleteUndefined: false
-			});
-		} catch (err) {
-			this.log.warn("Message validation failed", { error: err });
-			throw new AlephaError(`Message validation failed: ${err.message}`);
-		}
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-			if (this.messageQueue.length >= WebSocketChannelConnection.MAX_QUEUE_SIZE) {
-				this.log.warn("Message queue full, dropping oldest message", {
-					roomId,
-					queueSize: this.messageQueue.length
-				});
-				this.messageQueue.shift();
-			}
-			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() {
-		if (this.reconnectTimer) {
-			clearTimeout(this.reconnectTimer);
-			this.reconnectTimer = void 0;
-		}
-		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.connectPromise = void 0;
-		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 = $logger();
-	alepha = $inject(Alepha);
-	env = $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 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/errors/WebSocketError.ts
-/**
-* Base WebSocket error class
-*/
-var WebSocketError = class extends AlephaError {
-	code;
-	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/interfaces/WebSocketInterfaces.ts
-/**
-* WebSocket state enum
-*/
-let WebSocketState = /* @__PURE__ */ function(WebSocketState) {
-	WebSocketState[WebSocketState["CONNECTING"] = 0] = "CONNECTING";
-	WebSocketState[WebSocketState["OPEN"] = 1] = "OPEN";
-	WebSocketState[WebSocketState["CLOSING"] = 2] = "CLOSING";
-	WebSocketState[WebSocketState["CLOSED"] = 3] = "CLOSED";
-	return WebSocketState;
-}({});
-//#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 = $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: t.object({
-	/**
-	* Channel path (e.g., "/ws/chat")
-	*/
-	channelPath: t.text(),
-	/**
-	* Target room ID(s)
-	*/
-	roomIds: t.optional(t.array(t.text())),
-	/**
-	* Target user ID(s)
-	*/
-	userIds: t.optional(t.array(t.text())),
-	/**
-	* Target connection ID(s)
-	*/
-	connectionIds: t.optional(t.array(t.text())),
-	/**
-	* Exclude connection ID(s) from receiving the message
-	*/
-	exceptConnectionIds: t.optional(t.array(t.text())),
-	/**
-	* Exclude user ID(s) from receiving the message
-	*/
-	exceptUserIds: t.optional(t.array(t.text())),
-	/**
-	* The message payload to send
-	*/
-	message: 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 = $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 = $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/index.browser.ts
-const AlephaWebSocket = $module({
-	name: "alepha.websocket",
-	primitives: [$channel, $websocket],
-	services: [WebSocketClient],
-	register: (alepha) => {
-		alepha.with(AlephaTopic);
-		alepha.with(WebSocketClient);
-	}
-});
-//#endregion
-export { $channel, $websocket, AlephaWebSocket, ChannelPrimitive, RoomManager, WebSocketChannelConnection, WebSocketClient, WebSocketConnectionError, WebSocketError, WebSocketPrimitive, WebSocketServerProvider, WebSocketState, WebSocketTopicService, WebSocketValidationError };
-
-//# sourceMappingURL=index.browser.js.map