@vercube/ws 0.0.19

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present - Vercube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+<div align="center">
+  <a href="https://vercube.dev/"><img src="https://github.com/OskarLebuda/vue-lazy-hydration/raw/main/.github/assets/logo.png?raw=true" alt="Vite logo" width="200"></a>
+  <br>
+  <br>
+
+  # Vercube
+  
+  Next generation HTTP framework
+  
+  <a href="https://www.npmjs.com/package/@vercube/auth">
+    <img src="https://img.shields.io/npm/v/%40vercube%2Fauth?style=for-the-badge&logo=npm&color=%23767eff" alt="npm"/>
+  </a>
+  <a href="https://www.npmjs.com/package/@vercube/auth">
+    <img src="https://img.shields.io/npm/dm/%40vercube%2Fauth?style=for-the-badge&logo=npm&color=%23767eff" alt="npm"/>
+  </a>
+  <a href="https://github.com/vercube/vercube/blob/main/LICENSE" target="_blank">
+    <img src="https://img.shields.io/npm/l/%40vercube%2Fauth?style=for-the-badge&color=%23767eff" alt="License"/>
+  </a>
+  <br/>
+  <br/>
+</div>
+
+An ultra-efficient JavaScript server framework that runs anywhere - Node.js, Bun, or Deno - with unmatched flexibility and complete configurability for developers who refuse to sacrifice speed or control.
+
+## <a name="module">Websocket module</a>
+The Websocket module enables you to set up websocket connections on your application. It offers a collection of decorators that enable you to listen to incoming messages, emit/broadcast messages and more. It works based on namespaces.
+
+## <a name="documentation">📖 Documentation</a>
+Comprehensive documentation is available at [vercube.dev](https://vercube.dev). There you'll find detailed module descriptions, project information, guides, and everything else you need to know about Vercube.

package/dist/index.d.mts

@@ -0,0 +1,219 @@
+import { App, BasePlugin, ValidationTypes } from "@vercube/core";
+import { Peer } from "crossws";
+
+//#region src/Decorators/Namespace.d.ts
+
+/**
+ * A decorator function for defining a websocket namespace and accepting websocket connections.
+ *
+ * This function attaches namespace metadata to the decorated class, which is used to group websocket events under a
+ * specific namespace.
+ *
+ * @param {string} path - The namespace path for websocket connections.
+ * @returns {Function} - The decorator function.
+ */
+declare function Namespace(path: string): Function;
+//#endregion
+//#region src/Decorators/Message.d.ts
+interface MessageDecoratorOptions {
+  event: string;
+  validationSchema?: ValidationTypes.Schema;
+}
+/**
+ * A decorator function for listening to websocket messages under a specific event.
+ *
+ * This function creates an instance of the MessageDecorator class and registers a handler for websocket messages under
+ * the specified event and optional validation schema.
+ *
+ * @param {MessageDecoratorOptions} params - The options for the message handler, including event and optional validation schema.
+ * @returns {Function} - The decorator function.
+ */
+declare function Message(params: MessageDecoratorOptions): Function;
+//#endregion
+//#region src/Decorators/Emit.d.ts
+/**
+ * A decorator function for emitting websocket messages to the peer.
+ *
+ * This function creates an instance of the EmitDecorator class and emits the result of the decorated method as a
+ * websocket message to the peer under the specified event.
+ *
+ * @param {string} event - The event name for the emitted websocket message.
+ * @returns {Function} - The decorator function.
+ */
+declare function Emit(event: string): Function;
+//#endregion
+//#region src/Decorators/Broadcast.d.ts
+/**
+ * A decorator function for broadcasting websocket messages to everyone on the namespace (including the peer).
+ *
+ * This function creates an instance of the BroadcastDecorator class and emits the result of the decorated method as a
+ * websocket message to everyone on the namespace under the specified event.
+ *
+ * @param {string} event - The event name for the broadcasted websocket message.
+ * @returns {Function} - The decorator function.
+ */
+declare function Broadcast(event: string): Function;
+//#endregion
+//#region src/Decorators/BroadcastOthers.d.ts
+/**
+ * A decorator function for broadcasting websocket messages to everyone on the namespace (except the peer).
+ *
+ * This function creates an instance of the BroadcastOthersDecorator class and emits the result of the decorated method
+ * as a websocket message to everyone on the namespace (except the peer) under the specified event.
+ *
+ * @param {string} event - The event name for the broadcasted websocket message.
+ * @returns {Function} - The decorator function.
+ */
+declare function BroadcastOthers(event: string): Function;
+//#endregion
+//#region src/Decorators/OnConnectionAttempt.d.ts
+/**
+ * A decorator function for handling websocket connection attempts to a namespace.
+ *
+ * This function creates an instance of the OnConnectionAttemptDecorator class and registers a handler for websocket
+ * connection attempts under the namespace. If the decorated function throws or returns false, the connection will not
+ * be accepted.
+ *
+ * The decorated function will receive the following parameters:
+ *   - params: {Record<string, unknown>} The connection query parameters.
+ *   - request: {Request} The original HTTP request.
+ *
+ * @returns {Function} - The decorator function.
+ */
+declare function OnConnectionAttempt(): Function;
+//#endregion
+//#region src/Plugins/WebsocketPlugin.d.ts
+/**
+ * Websocket Plugin for Vercube framework
+ *
+ * Enables websocket connections and use of decorators related
+ * to the Websocket package.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from '@vercube/core';
+ * import { WebsocketPlugin } from '@vercube/ws';
+ *
+ * const app = createApp({
+ *   setup: async (app) => {
+ *     app.addPlugin(WebsocketPlugin);
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link https://vercube.dev} for full documentation
+ */
+declare class WebsocketPlugin<T = unknown> extends BasePlugin<T> {
+  /**
+   * The name of the plugin.
+   * @override
+   */
+  name: string;
+  /**
+   * Method to use the plugin with the given app.
+   * @param {App} app - The application instance.
+   * @returns {void | Promise<void>}
+   * @override
+   */
+  use(app: App, options: T): void | Promise<void>;
+}
+//#endregion
+//#region src/Types/WebsocketTypes.d.ts
+declare namespace WebsocketTypes {
+  enum HandlerAction {
+    CONNECTION = "connection",
+    MESSAGE = "message",
+  }
+  type HandlerAttributes = {
+    callback: Function;
+    event?: string;
+    schema?: ValidationTypes.Schema;
+  };
+}
+//#endregion
+//#region src/Services/WebsocketService.d.ts
+/**
+ * WebsocketService class responsible for dealing with Websocket connections.
+ *
+ * This class is responsible for:
+ * - Registering namespaces and accepting websocket connections for them
+ * - Registering event handlers and handling them
+ */
+declare class WebsocketService {
+  /**
+   * Http Server for injecting the server plugin
+   */
+  private readonly gHttpServer;
+  /**
+   * Validation provider for running the schema validation
+   */
+  private readonly gValidationProvider;
+  private readonly gLogger;
+  /**
+   * Internal namespace registry
+   */
+  private fNamespaces;
+  /**
+   * Internal handlers registry
+   */
+  private fHandlers;
+  /**
+   * Register a new namespace.
+   *
+   * @param {string} path - The namespace path to register.
+   * @returns {void}
+   */
+  registerNamespace(path: string): void;
+  /**
+   * Register a new handler for a namespace or event.
+   *
+   * @param {WebsocketTypes.HandlerAction} action - The handler action type.
+   * @param {string} namespace - The namespace to register the handler for.
+   * @param {WebsocketTypes.HandlerAttributes} handler - The handler attributes.
+   * @returns {void}
+   */
+  registerHandler(action: WebsocketTypes.HandlerAction, namespace: string, handler: WebsocketTypes.HandlerAttributes): void;
+  /**
+   * Broadcast a message to all peers in the same namespace (including the sender).
+   *
+   * @param {Peer} peer - The sender peer (used to determine the namespace).
+   * @param {unknown} message - The message to broadcast.
+   * @returns {void}
+   */
+  broadcast(peer: Peer, message: unknown): void;
+  /**
+   * Emit a message to a single peer.
+   *
+   * @param {Peer} peer - The peer to send the message to.
+   * @param {unknown} message - The message to send.
+   * @returns {void}
+   */
+  emit(peer: Peer, message: unknown): void;
+  /**
+   * Broadcast a message to all peers in the same namespace except the sender.
+   *
+   * @param {Peer} peer - The sender peer (used to determine the namespace).
+   * @param {unknown} message - The message to broadcast.
+   * @returns {void}
+   */
+  broadcastOthers(peer: Peer, message: unknown): void;
+  /**
+   * Initialize the websocket service and attach the server plugin.
+   *
+   * @returns {void}
+   */
+  initialize(): void;
+  /**
+   * Handle an incoming websocket message for a peer.
+   *
+   * @param {Peer} peer - The peer receiving the message.
+   * @param {Message} rawMessage - The raw websocket message.
+   * @returns {Promise<void>}
+   */
+  private handleMessage;
+}
+//#endregion
+//#region src/Symbols/WebsocketSymbols.d.ts
+declare const $WebsocketService: symbol;
+//#endregion
+export { $WebsocketService, Broadcast, BroadcastOthers, Emit, Message, Namespace, OnConnectionAttempt, WebsocketPlugin, WebsocketService, WebsocketTypes };

package/dist/index.mjs

@@ -0,0 +1,554 @@
+import "node:module";
+import { BadRequestError, BasePlugin, HttpServer, ValidationProvider, initializeMetadata, initializeMetadataMethod } from "@vercube/core";
+import { BaseDecorator, Identity, Inject, InjectOptional, createDecorator } from "@vercube/di";
+import { plugin } from "crossws/server";
+import { defineHooks } from "crossws";
+import { Logger } from "@vercube/logger";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/Decorators/Namespace.ts
+/**
+* A decorator function for defining a websocket namespace and accepting websocket connections.
+*
+* This function attaches namespace metadata to the decorated class, which is used to group websocket events under a
+* specific namespace.
+*
+* @param {string} path - The namespace path for websocket connections.
+* @returns {Function} - The decorator function.
+*/
+function Namespace(path) {
+	return function internalDecorator(target) {
+		const meta = initializeMetadata(target.prototype);
+		meta.__meta = {
+			...meta?.__meta,
+			namespace: path
+		};
+	};
+}
+
+//#endregion
+//#region src/Types/WebsocketTypes.ts
+let WebsocketTypes;
+(function(_WebsocketTypes) {
+	let HandlerAction = /* @__PURE__ */ function(HandlerAction$1) {
+		HandlerAction$1["CONNECTION"] = "connection";
+		HandlerAction$1["MESSAGE"] = "message";
+		return HandlerAction$1;
+	}({});
+	_WebsocketTypes.HandlerAction = HandlerAction;
+})(WebsocketTypes || (WebsocketTypes = {}));
+
+//#endregion
+//#region src/Symbols/WebsocketSymbols.ts
+const $WebsocketService = Identity("WebsocketService");
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.77.3/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+	function __decorate(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	}
+	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+//#endregion
+//#region src/Decorators/Message.ts
+var import_decorate$5 = __toESM(require_decorate(), 1);
+/**
+* A decorator class for listening to websocket messages under
+* a specific event.
+* 
+* This class extends the BaseDecorator and is used to listen
+* to websocket messages under a specific event.
+*
+* @extends {BaseDecorator<MessageDecoratorOptions>}
+*/
+var MessageDecorator = class extends BaseDecorator {
+	gWebsocketService;
+	created() {
+		if (!this.gWebsocketService) {
+			console.warn("MessageDecorator::WebsocketService is not registered");
+			return;
+		}
+		const meta = initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		const namespace = meta?.__meta?.namespace;
+		if (!namespace) {
+			console.warn("MessageDecorator::Unable to find namespace. Did you use @Namespace()?");
+			return;
+		}
+		method.meta = {
+			...method.meta,
+			event: this.options.event
+		};
+		const originalMethod = this.instance[this.propertyName].bind(this.instance);
+		this.gWebsocketService.registerHandler(WebsocketTypes.HandlerAction.MESSAGE, namespace, {
+			callback: originalMethod,
+			event: this.options.event,
+			schema: this.options.validationSchema
+		});
+	}
+};
+(0, import_decorate$5.default)([InjectOptional($WebsocketService)], MessageDecorator.prototype, "gWebsocketService", void 0);
+/**
+* A decorator function for listening to websocket messages under a specific event.
+*
+* This function creates an instance of the MessageDecorator class and registers a handler for websocket messages under
+* the specified event and optional validation schema.
+*
+* @param {MessageDecoratorOptions} params - The options for the message handler, including event and optional validation schema.
+* @returns {Function} - The decorator function.
+*/
+function Message(params) {
+	return createDecorator(MessageDecorator, params);
+}
+
+//#endregion
+//#region src/Decorators/Emit.ts
+var import_decorate$4 = __toESM(require_decorate(), 1);
+/**
+* A decorator class for emitting websocket messages to the peer.
+*
+* This class extends the BaseDecorator and is used to emit the result of
+* your function as a websocket message to the peer.
+*
+* @extends {BaseDecorator<EmitDecoratorOptions>}
+*/
+var EmitDecorator = class extends BaseDecorator {
+	gWebsocketService;
+	created() {
+		if (!this.gWebsocketService) {
+			console.warn("EmitDecorator::WebsocketService is not registered");
+			return;
+		}
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		const originalMethod = this.instance[this.propertyName];
+		this.instance[this.propertyName] = async (incomingMessage, peer) => {
+			const result = await originalMethod.call(this.instance, incomingMessage, peer);
+			this.gWebsocketService.emit(peer, {
+				event: this.options.event,
+				data: result
+			});
+			return result;
+		};
+	}
+};
+(0, import_decorate$4.default)([InjectOptional($WebsocketService)], EmitDecorator.prototype, "gWebsocketService", void 0);
+/**
+* A decorator function for emitting websocket messages to the peer.
+*
+* This function creates an instance of the EmitDecorator class and emits the result of the decorated method as a
+* websocket message to the peer under the specified event.
+*
+* @param {string} event - The event name for the emitted websocket message.
+* @returns {Function} - The decorator function.
+*/
+function Emit(event) {
+	return createDecorator(EmitDecorator, { event });
+}
+
+//#endregion
+//#region src/Decorators/Broadcast.ts
+var import_decorate$3 = __toESM(require_decorate(), 1);
+/**
+* A decorator class for broadcasting websocket messages to everyone 
+* on the namespace (including the peer).
+* 
+* This class extends the BaseDecorator and is used to emit the result of
+* your function as a websocket message to everyone on the namespace.
+*
+* @extends {BaseDecorator<BroadcastDecoratorOptions>}
+*/
+var BroadcastDecorator = class extends BaseDecorator {
+	gWebsocketService;
+	created() {
+		if (!this.gWebsocketService) {
+			console.warn("BroadcastDecorator::WebsocketService is not registered");
+			return;
+		}
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		const originalMethod = this.instance[this.propertyName];
+		this.instance[this.propertyName] = async (incomingMessage, peer) => {
+			const result = await originalMethod.call(this.instance, incomingMessage, peer);
+			this.gWebsocketService.broadcast(peer, {
+				event: this.options.event,
+				data: result
+			});
+			return result;
+		};
+	}
+};
+(0, import_decorate$3.default)([InjectOptional($WebsocketService)], BroadcastDecorator.prototype, "gWebsocketService", void 0);
+/**
+* A decorator function for broadcasting websocket messages to everyone on the namespace (including the peer).
+*
+* This function creates an instance of the BroadcastDecorator class and emits the result of the decorated method as a
+* websocket message to everyone on the namespace under the specified event.
+*
+* @param {string} event - The event name for the broadcasted websocket message.
+* @returns {Function} - The decorator function.
+*/
+function Broadcast(event) {
+	return createDecorator(BroadcastDecorator, { event });
+}
+
+//#endregion
+//#region src/Decorators/BroadcastOthers.ts
+var import_decorate$2 = __toESM(require_decorate(), 1);
+/**
+* A decorator class for broadcasting websocket messages to everyone 
+* on the namespace (except the peer).
+* 
+* This class extends the BaseDecorator and is used to emit the result of
+* your function as a websocket message to everyone on the namespace
+* (except the peer).
+*
+* @extends {BaseDecorator<BroadcastOthersDecoratorOptions>}
+*/
+var BroadcastOthersDecorator = class extends BaseDecorator {
+	gWebsocketService;
+	created() {
+		if (!this.gWebsocketService) {
+			console.warn("BroadcastOthersDecorator::WebsocketService is not registered");
+			return;
+		}
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		const originalMethod = this.instance[this.propertyName];
+		this.instance[this.propertyName] = async (incomingMessage, peer) => {
+			const result = await originalMethod.call(this.instance, incomingMessage, peer);
+			this.gWebsocketService.broadcastOthers(peer, {
+				event: this.options.event,
+				data: result
+			});
+			return result;
+		};
+	}
+};
+(0, import_decorate$2.default)([InjectOptional($WebsocketService)], BroadcastOthersDecorator.prototype, "gWebsocketService", void 0);
+/**
+* A decorator function for broadcasting websocket messages to everyone on the namespace (except the peer).
+*
+* This function creates an instance of the BroadcastOthersDecorator class and emits the result of the decorated method
+* as a websocket message to everyone on the namespace (except the peer) under the specified event.
+*
+* @param {string} event - The event name for the broadcasted websocket message.
+* @returns {Function} - The decorator function.
+*/
+function BroadcastOthers(event) {
+	return createDecorator(BroadcastOthersDecorator, { event });
+}
+
+//#endregion
+//#region src/Decorators/OnConnectionAttempt.ts
+var import_decorate$1 = __toESM(require_decorate(), 1);
+/**
+* A decorator class for handling websocket connection attempts.
+*
+* This class extends the BaseDecorator and is used to handle a
+* websocket connection attempt to a namespace.
+* 
+* If your function throws, or returns false, the connection
+* will not be accepted.
+* 
+* The decorated function will receive the following parameters:
+* 
+* @param {Record<string, unknown>} params - The connection query parameters.
+* @param {Request} request - The original HTTP request.
+*
+* @extends {BaseDecorator}
+*/
+var OnConnectionAttemptDecorator = class extends BaseDecorator {
+	gWebsocketService;
+	created() {
+		if (!this.gWebsocketService) {
+			console.warn("OnConnectionAttemptDecorator::WebsocketService is not registered");
+			return;
+		}
+		const meta = initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		const namespace = meta?.__meta?.namespace;
+		if (!namespace) {
+			console.warn("OnConnectionAttemptDecorator::Unable to find namespace. Did you use @Namespace()?");
+			return;
+		}
+		const originalMethod = this.instance[this.propertyName].bind(this.instance);
+		this.gWebsocketService.registerHandler(WebsocketTypes.HandlerAction.CONNECTION, namespace, { callback: originalMethod });
+	}
+};
+(0, import_decorate$1.default)([InjectOptional($WebsocketService)], OnConnectionAttemptDecorator.prototype, "gWebsocketService", void 0);
+/**
+* A decorator function for handling websocket connection attempts to a namespace.
+*
+* This function creates an instance of the OnConnectionAttemptDecorator class and registers a handler for websocket
+* connection attempts under the namespace. If the decorated function throws or returns false, the connection will not
+* be accepted.
+*
+* The decorated function will receive the following parameters:
+*   - params: {Record<string, unknown>} The connection query parameters.
+*   - request: {Request} The original HTTP request.
+*
+* @returns {Function} - The decorator function.
+*/
+function OnConnectionAttempt() {
+	return createDecorator(OnConnectionAttemptDecorator, void 0);
+}
+
+//#endregion
+//#region src/Services/WebsocketService.ts
+var import_decorate = __toESM(require_decorate(), 1);
+/**
+* WebsocketService class responsible for dealing with Websocket connections.
+*
+* This class is responsible for:
+* - Registering namespaces and accepting websocket connections for them
+* - Registering event handlers and handling them
+*/
+var WebsocketService = class {
+	/**
+	* Http Server for injecting the server plugin
+	*/
+	gHttpServer;
+	/**
+	* Validation provider for running the schema validation
+	*/
+	gValidationProvider;
+	gLogger;
+	/**
+	* Internal namespace registry
+	*/
+	fNamespaces = {};
+	/**
+	* Internal handlers registry
+	*/
+	fHandlers = {
+		[WebsocketTypes.HandlerAction.CONNECTION]: {},
+		[WebsocketTypes.HandlerAction.MESSAGE]: {}
+	};
+	/**
+	* Register a new namespace.
+	*
+	* @param {string} path - The namespace path to register.
+	* @returns {void}
+	*/
+	registerNamespace(path) {
+		if (!this?.fNamespaces?.[path.toLowerCase()]) this.fNamespaces[path.toLowerCase()] = [];
+	}
+	/**
+	* Register a new handler for a namespace or event.
+	*
+	* @param {WebsocketTypes.HandlerAction} action - The handler action type.
+	* @param {string} namespace - The namespace to register the handler for.
+	* @param {WebsocketTypes.HandlerAttributes} handler - The handler attributes.
+	* @returns {void}
+	*/
+	registerHandler(action, namespace, handler) {
+		const normalizedNamespace = namespace.toLowerCase();
+		if (action === WebsocketTypes.HandlerAction.CONNECTION) this.fHandlers[action][normalizedNamespace] = handler;
+		if (action === WebsocketTypes.HandlerAction.MESSAGE) {
+			const event = handler.event;
+			if (!event) {
+				this.gLogger?.warn("WebsocketService::registerHandler", `Cannot register message handler without an event name for namespace "${normalizedNamespace}".`);
+				return;
+			}
+			if (!this.fHandlers[action][normalizedNamespace]) this.fHandlers[action][normalizedNamespace] = {};
+			this.fHandlers[action][normalizedNamespace][event] = handler;
+		}
+		this.registerNamespace(normalizedNamespace);
+	}
+	/**
+	* Broadcast a message to all peers in the same namespace (including the sender).
+	*
+	* @param {Peer} peer - The sender peer (used to determine the namespace).
+	* @param {unknown} message - The message to broadcast.
+	* @returns {void}
+	*/
+	broadcast(peer, message) {
+		const namespace = peer.namespace?.toLowerCase();
+		if (!namespace) return;
+		const peers = this.fNamespaces[namespace];
+		if (!peers || peers.length === 0) return;
+		for (const p of peers) p.send(message);
+	}
+	/**
+	* Emit a message to a single peer.
+	*
+	* @param {Peer} peer - The peer to send the message to.
+	* @param {unknown} message - The message to send.
+	* @returns {void}
+	*/
+	emit(peer, message) {
+		peer.send(message);
+	}
+	/**
+	* Broadcast a message to all peers in the same namespace except the sender.
+	*
+	* @param {Peer} peer - The sender peer (used to determine the namespace).
+	* @param {unknown} message - The message to broadcast.
+	* @returns {void}
+	*/
+	broadcastOthers(peer, message) {
+		const namespace = peer.namespace?.toLowerCase();
+		if (!namespace) return;
+		const peers = this.fNamespaces[namespace];
+		if (!peers || peers.length === 0) return;
+		for (const p of peers) if (p.id !== peer.id) p.send(message);
+	}
+	/**
+	* Initialize the websocket service and attach the server plugin.
+	*
+	* @returns {void}
+	*/
+	initialize() {
+		const hooks = defineHooks({
+			upgrade: async (request) => {
+				const url = new URL(request.url);
+				const namespace = url.pathname;
+				const parameters = Object.fromEntries(url.searchParams.entries());
+				const isNamespaceRegistered = !!this.fNamespaces?.[namespace?.toLowerCase()];
+				if (!isNamespaceRegistered) {
+					this.gLogger?.warn("WebsocketService::initialize", `Namespace "${namespace}" is not registered. Connection rejected.`);
+					return new Response("Namespace not registered", { status: 403 });
+				}
+				const handler = this.fHandlers[WebsocketTypes.HandlerAction.CONNECTION]?.[namespace];
+				if (handler) try {
+					const result = await handler.callback(parameters, request);
+					if (result === false) return new Response("Unauthorized", { status: 403 });
+				} catch (error) {
+					if (error instanceof Error) return new Response(error.message, { status: 403 });
+					return new Response("Unknown error", { status: 403 });
+				}
+				return {
+					namespace,
+					headers: {}
+				};
+			},
+			open: async (peer) => {
+				const namespace = peer.namespace?.toLowerCase();
+				if (namespace && this.fNamespaces[namespace]) this.fNamespaces[namespace].push(peer);
+			},
+			message: async (peer, message) => {
+				await this.handleMessage(peer, message);
+			},
+			close: async (peer) => {
+				const namespace = peer.namespace?.toLowerCase();
+				if (namespace && this.fNamespaces[namespace]) {
+					const peers = this.fNamespaces[namespace];
+					this.fNamespaces[namespace] = peers.filter((p) => p.id !== peer.id);
+				}
+			},
+			error: async (peer, error) => {
+				this.gLogger?.error("WebsocketService::initialize", `Error: ${error.message}`, { peer });
+			}
+		});
+		const serverPlugin = plugin(hooks);
+		this.gHttpServer.addPlugin(serverPlugin);
+	}
+	/**
+	* Handle an incoming websocket message for a peer.
+	*
+	* @param {Peer} peer - The peer receiving the message.
+	* @param {Message} rawMessage - The raw websocket message.
+	* @returns {Promise<void>}
+	*/
+	async handleMessage(peer, rawMessage) {
+		try {
+			const msg = JSON.parse(rawMessage.text());
+			const namespace = peer.namespace?.toLowerCase();
+			const event = msg.event;
+			const data = msg.data;
+			const handler = this.fHandlers[WebsocketTypes.HandlerAction.MESSAGE]?.[namespace]?.[event];
+			if (!handler) {
+				this.gLogger?.warn("WebsocketService::handleMessage", `No message handler for event "${event}" in namespace "${namespace}"`);
+				return;
+			}
+			if (handler.schema) {
+				if (!this.gValidationProvider) {
+					this.gLogger?.warn("WebsocketService::handleMessage", "ValidationProvider is not registered");
+					return;
+				}
+				const result = await this.gValidationProvider.validate(handler.schema, data);
+				if (result?.issues?.length) throw new BadRequestError("Websocket message validation error", result.issues);
+			}
+			await handler.callback(data, peer);
+		} catch (error) {
+			this.gLogger?.error("WebsocketService::handleMessage", `Failed to process message: ${error}`);
+		}
+	}
+};
+(0, import_decorate.default)([Inject(HttpServer)], WebsocketService.prototype, "gHttpServer", void 0);
+(0, import_decorate.default)([InjectOptional(ValidationProvider)], WebsocketService.prototype, "gValidationProvider", void 0);
+(0, import_decorate.default)([InjectOptional(Logger)], WebsocketService.prototype, "gLogger", void 0);
+
+//#endregion
+//#region src/Plugins/WebsocketPlugin.ts
+/**
+* Websocket Plugin for Vercube framework
+* 
+* Enables websocket connections and use of decorators related
+* to the Websocket package.
+* 
+* @example
+* ```ts
+* import { createApp } from '@vercube/core';
+* import { WebsocketPlugin } from '@vercube/ws';
+* 
+* const app = createApp({
+*   setup: async (app) => {
+*     app.addPlugin(WebsocketPlugin);
+*   }
+* });
+* ```
+* 
+* @see {@link https://vercube.dev} for full documentation
+*/
+var WebsocketPlugin = class extends BasePlugin {
+	/**
+	* The name of the plugin.
+	* @override
+	*/
+	name = "WebsocketPlugin";
+	/**
+	* Method to use the plugin with the given app.
+	* @param {App} app - The application instance.
+	* @returns {void | Promise<void>}
+	* @override
+	*/
+	use(app, options) {
+		app.container.bind($WebsocketService, WebsocketService);
+		app.container.get($WebsocketService).initialize();
+	}
+};
+
+//#endregion
+export { $WebsocketService, Broadcast, BroadcastOthers, Emit, Message, Namespace, OnConnectionAttempt, WebsocketPlugin, WebsocketService, WebsocketTypes };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@vercube/ws",
+  "version": "0.0.19",
+  "description": "Websocket module for Vercube framework",
+  "repository": "@vercube/ws",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "zod": "4.0.10"
+  },
+  "dependencies": {
+    "crossws": "0.4.1",
+    "srvx": "0.8.2",
+    "@vercube/core": "0.0.19",
+    "@vercube/logger": "0.0.19",
+    "@vercube/di": "0.0.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}