vortez-io 1.0.0 → 1.0.1

package/package.json

@@ -1,12 +1,28 @@
 {
   "name": "vortez-io",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "Binary WebSocket protocol for multiplexed events, requests, responses, and errors in Vortez or other applications.",
   "main": "build/index.js",
   "scripts": {
     "build": "bash scripts/build.sh"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NetFeez/vortez-io.git"
+  },
+  "author": {
+    "name": "NetFeez",
+    "email": "netfeez.dev@gmail.com",
+    "url": "https://netfeez.github.io"
+  },
+  "files": [
+    "build",
+    "docs",
+    "LICENSE",
+    "README.md",
+    "PROTOCOL.md"
+  ],
   "keywords": [
     "vortez",
     "vortez-io",
@@ -19,15 +35,6 @@
     "typescript",
     "realtime"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/NetFeez/vortez-io.git"
-  },
-  "author": {
-    "name": "NetFeez",
-    "email": "netfeez.dev@gmail.com",
-    "url": "https://netfeez.github.io"
-  },
   "license": "Apache-2.0",
   "dependencies": {
     "@netfeez/common": "^3.1.1"

package/.gitignore

@@ -1,15 +0,0 @@
-# Build setting
-**/node_modules/
-**/build/
-**/build-*/
-**/.**
-**/*.log
-**/*.env
-**/*.tsbuildinfo
-!.gitignore
-
-# Work space setting
-!.vscode/
-
-# Test setting
-test.ts

package/scripts/build.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-output_file='build.log'
-
-if (npx tsc 2>&1 | tee "$output_file"); then
-    echo -e "\x1b[32mBuild succeeded.\x1b[0m"
-    rm -f "$output_file"
-else
-    echo -e "\x1b[31mBuild failed. See \x1b[36m$output_file\x1b[0m for details.\x1b[0m"
-    tail -n 20 "$output_file"
-    echo -e "use 'cat $output_file' to see the full log."
-    exit 1
-fi

package/src/Frame.ts

@@ -1,312 +0,0 @@
-/**
- * @module vortez-io
- * @author NetFeez <netfeez.dev@gemail.com>
- * @license Apache-2.0
- * @description Implements the core Frame structure of the Vortez IO protocol, including encoding and decoding logic for binary frames.
- *              The Frame class provides static methods to encode and decode frames according to the protocol specification, handling various frame types, modes, and identifier formats.
- *              It also includes validation to ensure that frames adhere to the protocol rules regarding type and identifier combinations.
- *              This module is essential for constructing and interpreting the binary messages exchanged in the Vortez IO protocol.
- *              The Frame structure consists of a header byte that encodes the frame type and mode, followed by an optional identifier (which can be a UUID or a string), and the payload data.
- *              The encoding and decoding processes involve careful parsing of the header and identifier fields, as well as proper handling of the payload data to ensure compliance with the protocol.
- *              The Frame class also defines the various types, modes, and identifier formats supported by the protocol, along with utility methods for converting between different representations (e.g., UUID to binary).
- *              The implementation emphasizes robustness and error handling, throwing VIOError exceptions when encountering invalid input or protocol violations during encoding and decoding operations.
- *              This module is a critical component of the Vortez IO protocol implementation, enabling the construction and interpretation of the binary frames that form the basis of communication within the protocol.
- *              The Frame class is designed to be flexible and extensible, allowing for future additions of frame types, modes, and identifier formats as the protocol evolves.
- *              The encoding and decoding logic is optimized for performance while maintaining strict adherence to the protocol specification, ensuring efficient processing of frames in real-world applications.
- *              Overall, this module serves as the foundation for handling the binary communication aspects of the Vortez IO protocol, providing a clear and robust implementation of the Frame structure and its associated encoding and decoding mechanisms.
- * 
- *             ⚠️ IMPORTANT: This module assumes that the input data for decoding is well-formed according to the protocol specification.
- *              It performs basic validations but does not attempt to recover from malformed frames.
- *              Users of this module should ensure that they are providing valid input to avoid unexpected errors during decoding.
- * 
- * @see https://github.com/NetFeez/Vortez-IO-Protocol/blob/main/PROTOCOL.md for the full protocol specification and documentation.
- */
-import UTF8Codec from "./support/UTF8Codec.js";
-import UUID from "./support/UUID.js";
-import Varint from "./support/Varint.js";
-import VIOError from "./VIOError.js";
-
-const MAX_ID_LENGTH = 1024;
-
-export class Frame<T extends Frame.Type = Frame.Type> implements Frame.Frame<T> {
-    protected static readonly TYPE_TO_BITS: Record<Frame.Type, number> = {
-        RAW: 0x0, EVENT: 0x1, REQUEST: 0x2, RESPONSE: 0x3, ERROR: 0x4
-    };
-    protected static readonly TYPE_MAP: Record<number, Frame.Type> = {
-        0x0: 'RAW', 0x1: 'EVENT', 0x2: 'REQUEST', 0x3: 'RESPONSE', 0x4: 'ERROR'
-    };
-
-    protected static readonly MODE_TO_BITS: Record<Frame.Mode, number> = {
-        BINARY: 0x0, JSON: 0x1, LINE: 0x2, CUSTOM: 0x3
-    };
-    protected static readonly MODE_MAP: Record<number, Frame.Mode> = {
-        0x0: 'BINARY', 0x1: 'JSON', 0x2: 'LINE', 0x3: 'CUSTOM'
-    };
-
-    protected static readonly ID_TYPE_TO_BITS: Record<Frame.IDType, number> = {
-        NONE: 0x0, UUID: 0x1, STRING: 0x2
-    };
-    protected static readonly ID_TYPE_MAP: Record<number, Frame.IDType> = {
-        0x0: 'NONE', 0x1: 'UUID', 0x2: 'STRING',
-    };
-
-    public constructor(
-        public readonly type: T,
-        public readonly mode: Frame.Mode,
-        public readonly identifier: Frame.IdentifierMap[T],
-        public readonly data: ArrayBuffer,
-        public readonly reservedRaw: number
-    ) {}
-    /**
-     * Decodes a binary frame from the given ArrayBuffer or Uint8Array according to the protocol specification.
-     * The method parses the frame header to determine the type, mode, and identifier, and then extracts the payload data.
-     * It performs various validations to ensure the frame adheres to the protocol rules, such as checking reserved bits and validating identifier types based on frame type.
-     * @param buffer The input buffer containing the binary frame data to decode.
-     * @returns A Frame object representing the decoded frame with its components (type, mode, identifier, data).
-     * @throws VIOError if the buffer is too short, contains invalid header values, or violates protocol rules regarding type and identifier combinations.
-     */
-    public static decode(buffer: ArrayBuffer | Uint8Array): Frame.FrameUnion {
-        const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-
-        if (view.length < 3) throw new VIOError(VIOError.Code.BUFFER_TOO_SHORT, 'Frame too short');
-
-        const head = view[0];
-
-        const typeBits = head & 0x0F;
-        const modeBits = (head >> 4) & 0x0F;
-
-        const type = this.assertDefined(this.TYPE_MAP[typeBits], VIOError.Code.INVALID_HEADER, `Invalid type: ${typeBits}`);
-        const mode = this.assertDefined(this.MODE_MAP[modeBits], VIOError.Code.INVALID_HEADER, `Invalid mode: ${modeBits}`);
-
-        const reserved = view[1];
-
-        if (reserved !== 0) throw new VIOError(VIOError.Code.INVALID_HEADER, `Reserved byte must be 0 (got ${reserved})`);
-
-        const idMeta = view[2];
-        const idTypeBits = idMeta & 0x03;
-        const idReservedBits = idMeta >> 2;
-
-        if (idReservedBits !== 0) throw new VIOError(VIOError.Code.INVALID_HEADER, 'ID_META reserved bits must be 0');
-
-        const idType = this.assertDefined(this.ID_TYPE_MAP[idTypeBits], VIOError.Code.INVALID_HEADER, `Invalid ID_TYPE: ${idTypeBits}`);
-
-        let identifier: Frame.Identifier;
-        let offset = 3;
-        switch (idType) {
-            case 'NONE':
-                identifier = { type: 'NONE' };
-                break;
-            case 'UUID':
-                if (view.length < offset + 16) throw new VIOError(VIOError.Code.BUFFER_TOO_SHORT, 'UUID missing');
-                
-                const raw = view.slice(offset, offset + 16);
-                identifier = {
-                    type: 'UUID',
-                    id: UUID.binToUuid(raw),
-                    idRaw: raw
-                }
-                offset += 16;
-                break;
-            case 'STRING': {
-                const { value: len, offset: next } = Varint.readVarint(view, offset);
-                if (len < 0 || len > MAX_ID_LENGTH) throw new VIOError(VIOError.Code.INVALID_HEADER, `Invalid String ID length: ${len}`);
-                offset = next;
-
-                if (view.length < offset + len) throw new VIOError(VIOError.Code.BUFFER_TOO_SHORT, 'String ID truncated');
-
-                const raw = view.slice(offset, offset + len);
-                identifier = {
-                    type: 'STRING',
-                    id: UTF8Codec.decode(raw),
-                    idRaw: raw
-                }
-
-                offset += len;
-                break;
-            }
-        }
-        const data = this.toArrayBuffer(view.slice(offset));
-        return this.assemble({ type, mode, identifier, data, reservedRaw: reserved });
-    }
-    /**
-     * Assembles a Frame object from the given components, performing additional validation to ensure that the combination of type and identifier adheres to protocol rules.
-     * This method is called after decoding the raw components of a frame to construct the final Frame object with proper typing and validation.
-     * It checks that REQUEST and RESPONSE frames use UUID identifiers, EVENT frames use STRING identifiers, and ERROR frames can use either NONE or UUID identifiers.
-     * If the components are valid, it returns a new Frame object; otherwise, it throws a VIOError indicating the specific protocol violation.
-     * @param parts An object containing the decoded components of the frame (type, mode, identifier, data, reservedRaw) to be assembled into a Frame object.
-     * @returns A Frame object representing the assembled frame with its components.
-     * @throws VIOError if the combination of type and identifier is invalid according to protocol rules.
-     */
-    protected static assemble(parts: Frame.Frame): Frame.FrameUnion {
-        const { type, mode, identifier, data, reservedRaw } = parts;
-        let frame: Frame.FrameUnion;
-        switch (type) {
-            case 'REQUEST':
-            case 'RESPONSE':
-                if (identifier.type !== 'UUID') throw new VIOError(VIOError.Code.INVALID_HEADER, `${type} MUST use UUID`);
-                frame = new Frame(type, mode, identifier, data, reservedRaw);
-                break;
-            case 'EVENT':
-                if (identifier.type !== 'STRING') throw new VIOError(VIOError.Code.INVALID_HEADER, `EVENT MUST use STRING`);
-                frame = new Frame(type, mode, identifier, data, reservedRaw);
-                break;
-            case 'ERROR':
-                if (identifier.type !== 'NONE' && identifier.type !== 'UUID') throw new VIOError(VIOError.Code.INVALID_HEADER, `ERROR MUST use NONE or UUID`);
-                frame = new Frame(type, mode, identifier, data, reservedRaw);
-                break;
-            case 'RAW':
-                frame = new Frame(type, mode, identifier, data, reservedRaw);
-                break;
-        }
-        return frame;
-    }
-    /**
-     * Encodes the given frame components into a binary format according to the protocol specification.
-     * The resulting ArrayBuffer will contain the frame header followed by the identifier (if applicable) and the payload data.
-     * @param type The type of the frame (e.g., 'REQUEST', 'RESPONSE', etc.).
-     * @param mode The mode of the frame (e.g., 'BINARY', 'JSON', etc.).
-     * @param data The payload data to include in the frame, as an ArrayBuffer or Uint8Array.
-     * @param identifier An optional identifier for the frame, which can be of type NONE, UUID, or STRING. Defaults to NONE if not provided.
-     * @returns An ArrayBuffer containing the encoded frame ready for transmission.
-     * @throws VIOError if the provided type, mode, or identifier combination is invalid according to the protocol rules.
-     */
-    public static encode(type: 'RAW', mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier?: Frame.IdentifierMap['RAW']): ArrayBuffer;
-    public static encode(type: 'EVENT', mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier: Frame.IdentifierMap['EVENT']): ArrayBuffer;
-    public static encode(type: 'REQUEST', mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier: Frame.IdentifierMap['REQUEST']): ArrayBuffer;
-    public static encode(type: 'RESPONSE', mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier: Frame.IdentifierMap['RESPONSE']): ArrayBuffer;
-    public static encode(type: 'ERROR', mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier?: Frame.IdentifierMap['ERROR']): ArrayBuffer;
-    public static encode(type: Frame.Type, mode: Frame.Mode, data: ArrayBuffer | Uint8Array, identifier: Frame.Identifier = { type: 'NONE' }): ArrayBuffer {
-        const typeBits = this.assertDefined(this.TYPE_TO_BITS[type], VIOError.Code.UNKNOWN_TYPE, `Unknown type: ${type}`);
-
-        const modeBits = this.assertDefined(this.MODE_TO_BITS[mode], VIOError.Code.UNKNOWN_MODE, `Unknown mode: ${mode}`);
-
-        const idTypeBits = this.assertDefined(this.ID_TYPE_TO_BITS[identifier.type], VIOError.Code.INVALID_HEADER, `Unknown ID_TYPE: ${identifier.type}`);
-
-        this.validate(type, identifier.type);
-
-        let idBytes: Uint8Array = new Uint8Array(0);
-
-        if (identifier.type === 'UUID') {
-            if (!UUID.isValid(identifier.id)) throw new VIOError(VIOError.Code.INVALID_HEADER, `Invalid UUID: ${identifier.id}`);
-            idBytes = UUID.uuidToBin(identifier.id);
-        }
-
-        else if (identifier.type === 'STRING') {
-            const encoded = UTF8Codec.encode(identifier.id);
-            const varint = Varint.writeVarint(encoded.length);
-
-            if (encoded.length > MAX_ID_LENGTH) throw new VIOError(VIOError.Code.INVALID_HEADER, `String ID too long (max ${MAX_ID_LENGTH} bytes)`);
-
-            idBytes = new Uint8Array(varint.length + encoded.length);
-            idBytes.set(varint, 0);
-            idBytes.set(encoded, varint.length);
-        }
-
-        const payload = data instanceof Uint8Array ? data : new Uint8Array(data);
-
-        const totalLength = 3 + idBytes.length + payload.length;
-        const buffer = new Uint8Array(totalLength);
-
-        buffer[0] = (modeBits << 4) | typeBits;
-        buffer[1] = 0;
-        buffer[2] = idTypeBits & 0x03;
-
-        let offset = 3;
-
-        buffer.set(idBytes, offset);
-        offset += idBytes.length;
-
-        buffer.set(payload, offset);
-
-        return this.toArrayBuffer(buffer);
-    }
-    /**
-     * Validates the combination of frame type and identifier type according to protocol rules:
-     * - REQUEST and RESPONSE frames MUST use UUID identifiers.
-     * - EVENT frames MUST NOT use UUID identifiers (they can use STRING or NONE).
-     * - ERROR and RAW frames have no restrictions on identifier type.
-     * @param type The frame type to validate.
-     * @param idType The identifier type to validate against the frame type.
-     * @throws VIOError if the combination of type and idType is invalid according to the protocol rules.
-     */
-    protected static validate(type: Frame.Type, idType: Frame.IDType) {
-        switch (type) {
-            case 'REQUEST':
-            case 'RESPONSE':
-                if (idType !== 'UUID') throw new VIOError(VIOError.Code.INVALID_HEADER, `${type} MUST use UUID`);
-                break;
-            case 'EVENT':
-                if (idType !== 'STRING') throw new VIOError(VIOError.Code.INVALID_HEADER, `EVENT MUST use STRING`);
-                break;
-            case 'ERROR': break;
-            case 'RAW': break;
-        }
-    }
-    /**
-     * Creates a copy of the ArrayBuffer from a Uint8Array view, ensuring it is not a shared buffer.
-     * This is necessary because the input Uint8Array may be a view into a larger buffer, and we want to ensure that the Frame's data is isolated and immutable.
-     * @param view The Uint8Array view to convert into an ArrayBuffer.
-     * @returns A new ArrayBuffer containing the data from the view.
-     */
-    protected static toArrayBuffer(view: Uint8Array): ArrayBuffer {
-        const out = new Uint8Array(view.byteLength);
-        out.set(view);
-        return out.buffer;
-    }
-    /**
-     * Utility method to assert that a value is defined (not undefined) and throw a VIOError with the provided message if it is not.
-     * This is used to ensure that required values are present during decoding and validation processes.
-     * @param value The value to check for being defined.
-     * @param code The VIOError code to use if the value is undefined.
-     * @param msg The error message to include in the VIOError if the value is undefined.
-     * @returns The input value if it is defined, otherwise throws a VIOError.
-     * @throws VIOError if the value is undefined, with the provided message.
-     */
-    protected static assertDefined<T>(value: T | undefined, code: VIOError.Code, msg: string): T {
-        if (value === undefined ) throw new VIOError(code, msg);
-        return value;
-    }
-}
-export namespace Frame {
-    export type Type = 'RAW' | 'EVENT' | 'REQUEST' | 'RESPONSE' | 'ERROR';
-    export type Mode = 'BINARY' | 'JSON' | 'LINE' | 'CUSTOM';
-    export type IDType = 'NONE' | 'UUID' | 'STRING';
-
-    export namespace Identifier {
-        export interface Base {
-            type: IDType;
-        }
-        export interface None extends Base {
-            type: 'NONE';
-        }
-        export interface UUID extends Base {
-            type: 'UUID';
-            id: string;
-            idRaw?: Uint8Array;
-        }
-        export interface String extends Base {
-            type: 'STRING';
-            id: string;
-            idRaw?: Uint8Array;
-        }
-    }
-    export type Identifier = Identifier.None | Identifier.UUID | Identifier.String;
-    export interface IdentifierMap {
-        RAW: Identifier.None | Identifier.UUID | Identifier.String;
-        EVENT: Identifier.String;
-        REQUEST: Identifier.UUID;
-        RESPONSE: Identifier.UUID;
-        ERROR: Identifier.None | Identifier.UUID;
-    }
-    export interface Frame<T extends Type = Type> {
-        type: T;
-        mode: Mode;
-        identifier: IdentifierMap[T];
-        data: ArrayBuffer;
-        reservedRaw: number;
-    }
-    export type FrameUnion = {
-        [K in Type]: Frame<K>
-    }[Type];
-}
-export default Frame;

package/src/Isomorphic.ts

@@ -1,7 +0,0 @@
-export namespace Isomorphic {
-    export type TimeoutHandler = () => void | Promise<void>;
-    export type setTimeout<T> = (handler: TimeoutHandler, timeout: number) => T;
-    export type clearTimeout<T> = (id: T) => void;
-    export type createUUID = () => string;
-}
-export default Isomorphic;

package/src/RequestManager.ts

@@ -1,114 +0,0 @@
-import { Events } from "@netfeez/common";
-
-import UUID from "./support/UUID.js";
-import VIOError from "./VIOError.js";
-
-import type Frame from "./Frame.js";
-import type Isomorphic from "./Isomorphic.js";
-
-export class RequestManager<T extends any> extends Events<RequestManager.EventMap> {
-    protected pending: Map<string, RequestManager.PendingEntry<T>> = new Map();
-
-    protected setTimeout: Isomorphic.setTimeout<T>;
-    protected clearTimeout: Isomorphic.clearTimeout<T>;
-    protected createUUID: Isomorphic.createUUID;
-
-    public constructor(dependencies: RequestManager.DEPENDENCIES<T>) { super();
-        this.setTimeout = dependencies.setTimeout;
-        this.clearTimeout = dependencies.clearTimeout;
-        this.createUUID = dependencies.createUUID || UUID.create;
-    }
-    /**
-     * Send a request with the given data and return a Promise that resolves with the response or rejects with an error.
-     * The method generates a unique UUID for the request, stores the resolve and reject functions in the pending map, and emits a 'send' event with the UUID and data.
-     * The handler method should be called when a response or error is received, which will look up the corresponding entry in the pending map and resolve or reject the Promise accordingly.
-     * @param data The data to be sent with the request. This can be of any type depending on the application's needs.
-     * @param options The options for the request, including a timeout duration.
-     */
-    public send(data: any, options: RequestManager.SendOptions = {}): Promise<RequestManager.Response> {
-        const { timeoutMs = 30000 } = options;
-        const uuid = this.createUUID();
-        return new Promise((resolve, reject) => {
-            const timeout: T = this.setTimeout(() => {
-                this.pending.delete(uuid);
-                reject(new VIOError(VIOError.Code.INVALID_DATA, 'Request timed out'));
-            }, timeoutMs);
-
-            this.pending.set(uuid, { resolve, reject, timeout });
-
-            try {
-                this.emit('send', uuid, data);
-            } catch (error) {
-                this.clearTimeout(timeout);
-                this.pending.delete(uuid);
-                reject(error instanceof VIOError ? error : new VIOError(VIOError.Code.INVALID_DATA, 'Failed to queue request'));
-            }
-        });
-    }
-    /**
-     * Handle a response or error for a request identified by the given UUID. This method should be called when a response or error is received for a previously sent request.
-     * It looks up the corresponding entry in the pending map using the UUID. If an entry is found, it resolves the Promise with the provided data if there is no error, or rejects it with the provided error if there is one. Finally, it removes the entry from the pending map to clean up resources.
-     * @param uuid The unique identifier for the request, which should match the UUID generated when the request was sent.
-     * @param data The response data to resolve the Promise with if there is no error.
-     * @param error The error to reject the Promise with if an error occurred.
-     */
-    public handle(uuid: string, data?: RequestManager.Response, error?: VIOError): void {
-        const entry = this.pending.get(uuid);
-        if (!entry) return;
-
-        this.clearTimeout(entry.timeout);
-
-        if (error) entry.reject(error);
-        else entry.resolve(data ?? { mode: 'BINARY', data: new Uint8Array(0) });
-
-        this.pending.delete(uuid);
-    }
-}
-export namespace RequestManager {
-    export interface DEPENDENCIES<T extends any> {
-        setTimeout: Isomorphic.setTimeout<T>;
-        clearTimeout: Isomorphic.clearTimeout<T>;
-        createUUID?: Isomorphic.createUUID;
-    }
-    export namespace Response {
-        export type Base = { mode: Frame.Mode };
-        export interface Binary extends Base {
-            mode: 'BINARY' | 'CUSTOM';
-            data: Uint8Array;
-        }
-        export interface Json extends Base {
-            mode: 'JSON';
-            data: any;
-        }
-        export interface Line extends Base {
-            mode: 'LINE';
-            data: Record<string, string>;
-        }
-    }
-    export type Response = Response.Binary | Response.Json | Response.Line;
-    export type EventMap = {
-        send: [uuid: string, data?: any];
-        error: [error: VIOError];
-    };
-
-    /**
-     * Represents a pending request entry in the RequestManager.
-     * Each entry contains the resolve and reject functions for the Promise associated with the request, as well as a timeout identifier if a timeout mechanism is implemented.
-     * The resolve function is called with the response data when a successful response is received, while the reject function is called with an error if an error occurs or if a timeout is reached.
-     * The timeout field can be used to store the identifier returned by a setTimeout function, allowing for the implementation of request timeouts where the Promise is rejected if a response is not received within a certain timeframe.
-     * @template T The type of the timeout identifier, which can vary depending on the environment (e.g., NodeJS.Timeout in Node.js or number in browsers).
-     */
-    export interface PendingEntry<T> {
-        resolve: (value: Response) => void;
-        reject: (reason: VIOError) => void;
-        timeout: T;
-    }
-
-    export interface SendOptions {
-        timeoutMs?: number;
-    }
-
-    export type Done<T> = (data: T) => void;
-    export type Fail = (error: VIOError) => void;
-}
-export default RequestManager;

package/src/VIO.ts

@@ -1,194 +0,0 @@
-import { Events } from "@netfeez/common";
-
-import RequestManager from "./RequestManager.js";
-import VIOError from "./VIOError.js";
-import Frame from "./Frame.js";
-import UTF8Codec from "./support/UTF8Codec.js";
-import LineCodec from "./support/LineParser.js";
-
-export class VIO<T extends any> extends Events<VIO.EventMap> {
-    protected mRequest: RequestManager<T>;
-    public vTransport: Events.Emitter<VIO.TransportEventMap>;
-
-    public constructor(dependencies: RequestManager.DEPENDENCIES<T>) {super();
-        this.mRequest = new RequestManager(dependencies);
-        this.mRequest.on('error', (error) => this.emit('error', error));
-        this.mRequest.on('send', this.sendRequest.bind(this));
-        this.vTransport = new Events.Emitter();
-    }
-    public get transport(): Events<VIO.TransportEventMap> { return this.vTransport; }
-    public async request(data: any, options?: RequestManager.SendOptions): Promise<RequestManager.Response> {
-        return this.mRequest.send(data, options);
-    }
-    public event(name: string, data: any): void {
-        this.sendEvent(name, data);
-    }
-    public handle(data: ArrayBuffer | Uint8Array): void {
-        try {
-            const frame = Frame.decode(data);
-            switch (frame.type) {
-                case 'RAW': this.handleRaw(frame); break;
-                case 'EVENT': this.handleEvent(frame); break;
-                case 'REQUEST': this.handleRequest(frame); break;
-                case 'RESPONSE': this.handleResponse(frame); break;
-                case 'ERROR': this.handleError(frame); break;
-                default: this.sendError(new VIOError(VIOError.Code.INVALID_DATA, 'Unknown frame type')); break;
-            }
-        } catch (error) {
-            this.emit('error', error instanceof VIOError ? error : new VIOError(VIOError.Code.INVALID_DATA, 'Failed to decode frame'));
-        }
-    }
-    protected async handleRaw(frame: Frame): Promise<void> {
-        this.emit('raw', frame);
-    }
-    protected async handleEvent(frame: Frame<'EVENT'>): Promise<void> {
-        try {
-            if (frame.mode == 'BINARY' || frame.mode == 'CUSTOM') {
-                const data = new Uint8Array(frame.data);
-                this.emit('event', frame.identifier.id, frame.mode, data);
-            } else if (frame.mode == 'JSON') {
-                const json = UTF8Codec.decode(new Uint8Array(frame.data));
-                const data = JSON.parse(json);
-                this.emit('event', frame.identifier.id, frame.mode, data);
-            } else if (frame.mode == 'LINE') {
-                const data = LineCodec.decode(frame.data);
-                this.emit('event', frame.identifier.id, frame.mode, data);
-            } else this.sendError(new VIOError(VIOError.Code.UNKNOWN_MODE, `Unknown mode: ${frame.mode}`));
-        } catch (error) { this.emit('error', error instanceof VIOError ? error : new VIOError(VIOError.Code.INVALID_DATA, 'Failed to process event data')); }
-    }
-    protected async handleRequest(frame: Frame<'REQUEST'>): Promise<void> {
-        if (!frame.identifier.id) return this.sendError(new VIOError(VIOError.Code.INVALID_HEADER, 'Request frame missing UUID'));
-        const uuid = frame.identifier.id;
-        try {
-            if (frame.mode == 'BINARY' || frame.mode == 'CUSTOM') {
-                const data = new Uint8Array(frame.data);
-                const done = (data: Uint8Array) => this.sendResponse(uuid, data);
-                const fail = (error: VIOError) => this.sendError(error, uuid);
-                this.emit('request', frame.mode, data, done, fail);
-            } else if (frame.mode == 'JSON') {
-                const json = UTF8Codec.decode(new Uint8Array(frame.data));
-                const data = JSON.parse(json);
-                const done = (data: any) => this.sendResponse(uuid, data);
-                const fail = (error: VIOError) => this.sendError(error, uuid);
-                this.emit('request', frame.mode, data, done, fail);
-            } else if (frame.mode == 'LINE') {
-                const data = LineCodec.decode(frame.data);
-                const done = (data: Record<string, string>) => this.sendResponse(uuid, data);
-                const fail = (error: VIOError) => this.sendError(error, uuid);
-                this.emit('request', frame.mode, data, done, fail);
-            } else this.sendError(new VIOError(VIOError.Code.UNKNOWN_MODE, `Unknown mode: ${frame.mode}`), uuid);
-        } catch (error) { this.sendError(new VIOError(VIOError.Code.INVALID_DATA, 'Failed to process request data'), uuid); }
-    }
-    protected async handleResponse(frame: Frame<'RESPONSE'>): Promise<void> {
-        if (!frame.identifier.id) return this.sendError(new VIOError(VIOError.Code.INVALID_HEADER, 'Response frame missing UUID'));
-        try {
-            if (frame.mode == 'BINARY' || frame.mode == 'CUSTOM') {
-                const data = new Uint8Array(frame.data);
-                this.mRequest.handle(frame.identifier.id, { mode: frame.mode, data });
-            } else if (frame.mode == 'JSON') {
-                const json = UTF8Codec.decode(new Uint8Array(frame.data));
-                const data = JSON.parse(json);
-                this.mRequest.handle(frame.identifier.id, { mode: 'JSON', data });
-            } else if (frame.mode == 'LINE') {
-                const data = LineCodec.decode(frame.data);
-                this.mRequest.handle(frame.identifier.id, { mode: 'LINE', data });
-            } else this.mRequest.handle(frame.identifier.id, undefined, new VIOError(VIOError.Code.UNKNOWN_MODE, `Unknown mode: ${frame.mode}`));
-        } catch (error) { this.mRequest.handle(frame.identifier.id, undefined, new VIOError(VIOError.Code.INVALID_DATA, 'Failed to process response data')); }
-    }
-    protected async handleError(frame: Frame<'ERROR'>): Promise<void> {
-        try {
-            if (frame.identifier.type === 'NONE') {
-                const error = new VIOError(VIOError.Code.INVALID_DATA, 'Unknown error');
-                return this.emit('error', error);
-            }
-            if (frame.mode == 'BINARY' || frame.mode == 'CUSTOM') {
-                const data = new Uint8Array(frame.data);
-                const error = new VIOError(VIOError.Code.INVALID_DATA, `Error response with binary data: ${data.length} bytes`);
-                this.mRequest.handle(frame.identifier.id, undefined, error);
-            } else if (frame.mode == 'JSON') {
-                const json = UTF8Codec.decode(new Uint8Array(frame.data));
-                const data = JSON.parse(json);
-                const error = new VIOError(VIOError.Code.INVALID_DATA, data.error || 'Unknown error');
-                this.mRequest.handle(frame.identifier.id, undefined, error);
-            } else if (frame.mode == 'LINE') {
-                const data = LineCodec.decode(frame.data);
-                const error = new VIOError(VIOError.Code.INVALID_DATA, `Error response with line data: ${JSON.stringify(data)}`);
-                this.mRequest.handle(frame.identifier.id, undefined, error);
-            } else {
-                const error = new VIOError(VIOError.Code.UNKNOWN_MODE, `Unknown mode: ${frame.mode}`);
-                this.mRequest.handle(frame.identifier.id, undefined, error);
-            }
-        } catch (error) {
-            const vioError = new VIOError(VIOError.Code.INVALID_DATA, 'Failed to process error data');
-            if (frame.identifier.type === 'UUID') this.mRequest.handle(frame.identifier.id, undefined, vioError);
-            this.emit('error', vioError);
-        }
-    }
-    protected sendEvent(name: string, data: Uint8Array | ArrayBuffer): void;
-    protected sendEvent(name: string, data: LineCodec.ContentMap, mode: 'LINE'): void;
-    protected sendEvent(name: string, data: any): void;
-    protected sendEvent(name: string, data: any, mode?: 'LINE'): void {
-        const { content, finalMode } = this.serialize(data, mode);
-        const frame = Frame.encode('EVENT', finalMode, content, { type: 'STRING', id: name });
-        try { this.vTransport.emit('send', frame); }
-        catch (err) { this.vTransport.emit('transport:error', err instanceof Error ? err : new Error(String(err)), { stage: 'send', frameType: 'EVENT', info: { name } }); }
-    }
-
-    protected sendRequest(uuid: string, data: Uint8Array | ArrayBuffer): void;
-    protected sendRequest(uuid: string, data: LineCodec.ContentMap, mode: 'LINE'): void;
-    protected sendRequest(uuid: string, data: any): void;
-    protected sendRequest(uuid: string, data?: any, mode?: 'LINE'): void {
-        const { content, finalMode } = this.serialize(data, mode);
-        const frame = Frame.encode('REQUEST', finalMode, content, { type: 'UUID', id: uuid });
-        try { this.vTransport.emit('send', frame); }
-        catch (err) { this.vTransport.emit('transport:error', err instanceof Error ? err : new Error(String(err)), { stage: 'send', frameType: 'REQUEST', uuid, info: {} }); }
-    }
-
-    protected sendResponse(uuid: string, data: Uint8Array | ArrayBuffer): void;
-    protected sendResponse(uuid: string, data: LineCodec.ContentMap, mode: 'LINE'): void;
-    protected sendResponse(uuid: string, data: any): void;
-    protected sendResponse(uuid: string, data?: any, mode?: 'LINE'): void {
-        const { content, finalMode } = this.serialize(data, mode);
-        const frame = Frame.encode('RESPONSE', finalMode, content, { type: 'UUID', id: uuid });
-        try { this.vTransport.emit('send', frame); }
-        catch (err) { this.vTransport.emit('transport:error', err instanceof Error ? err : new Error(String(err)), { stage: 'send', frameType: 'RESPONSE', uuid, info: {} }); }
-    }
-    protected sendError(error: VIOError, uuid?: string): void {
-        const json = JSON.stringify({ error: error.message, code: error.code });
-        const content = UTF8Codec.encode(json);
-        const frame = Frame.encode('ERROR', 'JSON', content, uuid ? { type: 'UUID', id: uuid } : { type: 'NONE' });
-        try { this.vTransport.emit('send', frame); }
-        catch (err) { this.vTransport.emit('transport:error', err instanceof Error ? err : new Error(String(err)), { stage: 'send', frameType: 'ERROR', uuid, info: {} }); }
-    }
-    protected serialize(data: any, mode?: 'LINE'): { content: Uint8Array, finalMode: Frame.Mode } {
-        if (data instanceof Uint8Array) return { content: data, finalMode: 'BINARY' };
-        if (data instanceof ArrayBuffer) return { content: new Uint8Array(data), finalMode: 'BINARY' };
-        if (mode === 'LINE') return { content: LineCodec.encode(data), finalMode: 'LINE' };
-        const json = JSON.stringify(data ?? {});
-        return { content: UTF8Codec.encode(json), finalMode: 'JSON' };
-    }
-}
-export namespace VIO {
-    export type TransportEventMap = {
-        send: [data: ArrayBuffer];
-        'transport:error': [err: Error, ctx?: { stage: 'send' | 'recv' | 'connect', frameType?: Frame.Type | string, uuid?: string, info?: any }];
-    }
-    type EventTuple = (
-        [name: string, type: 'BINARY' | 'CUSTOM', data: Uint8Array] |
-        [name: string, type: 'JSON', data: any] |
-        [name: string, type: 'LINE', data: Record<string, string>]
-    );
-    type requestTuple = (
-        [type: 'BINARY' | 'CUSTOM', data: Uint8Array, done: RequestManager.Done<Uint8Array>, fail: RequestManager.Fail] |
-        [type: 'JSON', data: any, done: RequestManager.Done<any>, fail: RequestManager.Fail] |
-        [type: 'LINE', data: Record<string, string>, done: RequestManager.Done<Record<string, string>>, fail: RequestManager.Fail]
-    );
-    export type EventMap = {
-        request: requestTuple;
-        event: EventTuple;
-        error: [error: VIOError];
-        raw: [data: Frame];
-        response: [uuid: string, response: RequestManager.Response];
-    }
-}
-export default VIO;

package/src/VIOError.ts

@@ -1,22 +0,0 @@
-export class VIOError extends Error {
-    public name: string = 'VIOError';
-    public code: VIOError.Code;
-    public constructor(code: VIOError.Code, message: string) { super(message);
-        this.name = 'VIOError';
-        this.code = code;
-    }
-    public toString(): string {
-        return `${this.name} [${this.code}]: ${this.message}`;
-    }
-}
-export namespace VIOError {
-    export enum Code {
-        INVALID_HEADER = 'INVALID_HEADER',
-        INVALID_UUID = 'INVALID_UUID',
-        INVALID_DATA = 'INVALID_DATA',
-        UNKNOWN_TYPE = 'UNKNOWN_TYPE',
-        UNKNOWN_MODE = 'UNKNOWN_MODE',
-        BUFFER_TOO_SHORT = 'BUFFER_TOO_SHORT'
-    }
-}
-export default VIOError;

package/src/VIOStrict.ts

@@ -1,123 +0,0 @@
-import { Events, Schema } from "@netfeez/common";
-import RequestManager from "./RequestManager.js";
-import VIO from "./VIO.js";
-import VIOError from "./VIOError.js";
-import { Frame } from "./Frame.js";
-
-export const RRSchema = Schema.fromObject({
-    name: { type: 'string', required: true },
-    content: { type: 'object', required: true }
-});
-
-export class VIOStrict<
-    const T extends any,
-    const IEMap extends VIOStrict.EMap,
-    const OEMap extends VIOStrict.EMap,
-    const IRRMap extends VIOStrict.RRMap,
-    const ORRMap extends VIOStrict.RRMap
-> {
-    protected readonly VIO: VIO<T>;
-
-    protected readonly vioEmitter: Events.Emitter<VIOStrict.VIOEventMap>;
-    protected readonly eventEmitter: Events.Emitter<VIOStrict.EventMap<IEMap>>;
-    protected readonly requestEmitter: Events.Emitter<VIOStrict.ReqEventMap<IRRMap>>;
-
-    public constructor(
-        dependencies: RequestManager.DEPENDENCIES<T>,
-        protected inEMap: IEMap,
-        protected outEMap: OEMap,
-        protected inRRMap: IRRMap,
-        protected outRRMap: ORRMap
-    ) {
-        this.VIO = new VIO(dependencies);
-        this.vioEmitter = new Events.Emitter();
-        this.eventEmitter = new Events.Emitter();
-        this.requestEmitter = new Events.Emitter();
-
-        this.VIO.on('event', this.eventHandler.bind(this));
-        this.VIO.on('request', this.requestHandler.bind(this));
-        this.VIO.on('raw', (frame) => this.vioEmitter.emit('raw', frame));
-        this.VIO.on('error', (error) => this.vioEmitter.emit('error', error));
-    }
-
-    public get trp() { return this.VIO.transport; }
-    public get vio(): Events<VIOStrict.VIOEventMap> { return this.vioEmitter; }
-    public get evt(): Events<VIOStrict.EventMap<IEMap>> { return this.eventEmitter; }
-    public get rqt(): Events<VIOStrict.ReqEventMap<IRRMap>> { return this.requestEmitter; }
-
-    public event<Name extends string & keyof OEMap>(name: Name, data: OEMap[Name]['infer']): void {
-        const schema = this.outEMap[name];
-        if (!schema) throw new VIOError(VIOError.Code.UNKNOWN_TYPE, `Unknown event type: ${String(name)}`);
-        const processedData = schema.processData(data);
-        this.VIO.event(name, processedData);
-    }
-    public async request<id extends string & keyof ORRMap>(action: id, data: ORRMap[id]['request']['inferToProcess'], options?: RequestManager.SendOptions): Promise<ORRMap[id]['response']['infer']> {
-        const { request: RQS, response: RSS } = this.outRRMap[action];
-        if (!RQS) throw new VIOError(VIOError.Code.UNKNOWN_TYPE, `Unknown request type: ${String(action)}`);
-        if (!RSS) throw new VIOError(VIOError.Code.UNKNOWN_TYPE, `Unknown response type: ${String(action)}`);
-        const readyData = RQS.processData(data);
-        const toSend = RRSchema.processData({ name: action, content: readyData });
-        const response = await this.VIO.request(toSend, options);
-        if (response.mode !== 'JSON') throw new VIOError(VIOError.Code.INVALID_DATA, `Invalid response mode: ${response.mode}`);
-        const parsed = RRSchema.processData(response.data);
-        if (parsed.name !== action) throw new VIOError(VIOError.Code.INVALID_DATA, `Response action mismatch: expected ${action}, got ${parsed.name}`);
-        return RSS.processData(parsed.content);
-    }
-    public handle(data: ArrayBuffer | Uint8Array): void {
-        this.VIO.handle(data);
-    }
-    protected eventHandler(name: string, _mode: Frame.Mode, data: any): void {
-        const schema = this.inEMap[name];
-        if (!schema) throw new VIOError(VIOError.Code.UNKNOWN_TYPE, `Unknown event type: ${String(name)}`);
-        const processedData = schema.processData(data);
-        this.eventEmitter.emit(name, processedData);
-    }
-    protected requestHandler(mode: Frame.Mode, data: any, done: (data: any) => void, fail: (error: VIOError) => void): void {
-        if (mode !== 'JSON') return fail(new VIOError(VIOError.Code.INVALID_DATA, `Invalid request mode: ${mode}`));
-        const parsed = RRSchema.processData(data);
-        const { name, content } = parsed;
-        const rrEntry = this.inRRMap[name];
-        if (!rrEntry) return fail(new VIOError(VIOError.Code.UNKNOWN_TYPE, `Unknown request type: ${String(name)}`));
-        const {request: RQS, response: RSS } = rrEntry;
-        if (!RQS) return fail(new VIOError(VIOError.Code.UNKNOWN_TYPE, `Missing request schema for type: ${String(name)}`));
-        if (!RSS) return fail(new VIOError(VIOError.Code.UNKNOWN_TYPE, `Missing response schema for type: ${String(name)}`));
-        let processedRequest: typeof RQS.infer;
-        try { processedRequest = RQS.processData(content); }
-        catch (error) { return fail(new VIOError(VIOError.Code.INVALID_DATA, `Failed to process request data for type ${String(name)}: ${(error as Error).message}`)); }
-        const respond = (responseData: typeof RSS.inferToProcess) => {
-            let readyResponse: any;
-            try { readyResponse = RSS.processData(responseData); }
-            catch (error) { return fail(new VIOError(VIOError.Code.INVALID_DATA, `Failed to process response data for type ${String(name)}: ${(error as Error).message}`)); }
-            const toSend = RRSchema.processData({ name, content: readyResponse });
-            done(toSend);
-        };
-        this.requestEmitter.emit(name, processedRequest, respond, fail);
-    }
-}
-export namespace VIOStrict {
-    export interface EMap {
-        [name: string]: Schema<Schema.Property>;
-    }
-    export interface RREntry {
-        request: Schema<Schema.Definition.Object>;
-        response: Schema<Schema.Definition.Object>;
-    }
-    export interface RRMap {
-        [name: string]: RREntry;
-    }
-    export type VIOEventMap = {
-        error: [error: VIOError];
-        raw: [frame: Frame];
-    }
-    export type ReqEventMap<RRMap extends VIOStrict.RRMap> = {
-        [Name in string & keyof RRMap]: [
-            data: RRMap[Name]['request']['infer'],
-            respond: (data: RRMap[Name]['response']['inferToProcess']) => void,
-            reject: (error: VIOError) => void
-        ];
-    }
-    export type EventMap<EMap extends VIOStrict.EMap> = {
-        [Name in string & keyof EMap]: [data: EMap[Name]['infer']];
-    }
-}
-export default VIOStrict;

package/src/index.ts

@@ -1,4 +0,0 @@
-export { VIO, VIO as default } from "./VIO.js";
-export { VIOStrict } from "./VIOStrict.js";
-export { VIOError } from "./VIOError.js";
-export { Frame } from "./Frame.js";

package/src/support/LineParser.ts

@@ -1,55 +0,0 @@
-/**
- * @module vortez-io
- * @author NetFeez <netfeez.dev@gemail.com>
- * @license Apache-2.0
- * @description Provides encoding and decoding functionality for line-based content used in the Vortez IO protocol.
- *              The LineCodec class allows for converting between a ContentMap (a mapping of string keys to string values) and a line-based text format where each key-value pair is represented as a block of text with specific formatting rules.
- *              This is useful for encoding structured data in a human-readable format that can be easily transmitted and parsed within the Vortez IO protocol.
- */
-import UTF8Codec from "./UTF8Codec.js";
-
-export class LineCodec {
-    /**
-     * Encodes a ContentMap into a Uint8Array containing line-based content.
-     * Each key-value pair in the ContentMap is converted into a block of text where the key is on the first line, followed by the value on subsequent lines. 
-     * Lines are separated by \r\n, and key-value pairs are separated by \r\n\r\n.
-     * If a value contains multiple lines, each subsequent line after the first will start with a space character to indicate that it is a continuation of the previous line.
-     * @param data A ContentMap object where each key is a string and each value is the corresponding string value to be encoded.
-     * @returns A Uint8Array containing the UTF-8 encoded line-based content representing the input ContentMap.
-     */
-    public static encode(data: LineCodec.ContentMap): Uint8Array {
-        let content = '';
-        for (const [key, value] of Object.entries(data)) {
-            const valueProcessed = value.replace(/\r\n/g, '\r\n ');
-            content += `${key}\r\n${valueProcessed}\r\n\r\n`;
-        }
-        return UTF8Codec.encode(content);
-    }
-    /**
-     * Decodes a Uint8Array containing line-based content into a ContentMap.
-     * The input is expected to be UTF-8 encoded and formatted with lines separated by \r\n, and key-value pairs separated by \r\n\r\n.
-     * Values that span multiple lines should have subsequent lines starting with a space character.
-     * @param content A Uint8Array containing the UTF-8 encoded line-based content.
-     * @returns A ContentMap object where each key is a string and each value is the corresponding string value from the input, with multi-line values properly concatenated.
-     */
-    public static decode(content: ArrayBuffer | Uint8Array): LineCodec.ContentMap {
-        const view = content instanceof ArrayBuffer ? new Uint8Array(content) : content;
-        const decodedContent = UTF8Codec.decode(view);
-        const lines = decodedContent.split('\r\n\r\n');
-        const result: LineCodec.ContentMap = {};
-        
-        for (const line of lines) {
-            const [key, ...valueParts] = line.split('\r\n');
-            if (!key) continue;
-            const value = valueParts.join('\r\n').replace(/\r\n /g, '\r\n');
-            result[key] = value;
-        }
-        return result;
-    }
-}
-export namespace LineCodec {
-    export interface ContentMap {
-        [key: string]: string;
-    }
-}
-export default LineCodec;

package/src/support/UTF8Codec.ts

@@ -1,166 +0,0 @@
-/**
- * @module vortez-io
- * @author NetFeez <netfeez.dev@netfeez.dev>
- * @license Apache-2.0
- * @description UTF-8 encoder/decoder optimized for:
- *              - predictable memory usage (pre-allocation)
- *              - safe decoding (malformed/truncated input)
- *              - zero external dependencies
- *
- * ⚠️ Fully standards-compliant behavior for replacement (U+FFFD)
- */
-export class UTF8Codec {
-    private static readonly REPLACEMENT_CHAR = '\uFFFD';
-    /**
-     * Encodes a string into a UTF-8 byte array.
-     * @param text The string to encode.
-     * @returns A Uint8Array containing the UTF-8 encoded bytes of the input string.
-     */
-    public static encode(text: string): Uint8Array {
-        const len = text.length;
-        let byteLength = 0;
-
-        for (let i = 0; i < len; i++) {
-            const code = text.charCodeAt(i);
-
-            if (code < 0x80) { byteLength += 1; }
-            else if (code < 0x800) { byteLength += 2; }
-            else if (code >= 0xd800 && code <= 0xdbff) {
-                const next = i + 1 < len ? text.charCodeAt(i + 1) : 0;
-
-                if (next >= 0xdc00 && next <= 0xdfff) {
-                    byteLength += 4;
-                    i++;
-                } else { byteLength += 3; }
-            } else { byteLength += 3; }
-        }
-        const out = new Uint8Array(byteLength);
-        let offset = 0;
-
-        for (let i = 0; i < len; i++) {
-            const code = text.charCodeAt(i);
-            if (code < 0x80) {
-                out[offset++] = code;
-                continue;
-            }
-            if (code < 0x800) {
-                out[offset++] = 0xc0 | (code >> 6);
-                out[offset++] = 0x80 | (code & 0x3f);
-                continue;
-            }
-            if (code >= 0xd800 && code <= 0xdbff) {
-                const next = i + 1 < len ? text.charCodeAt(i + 1) : 0;
-
-                if (next >= 0xdc00 && next <= 0xdfff) {
-                    const cp = 0x10000 + ((code & 0x3ff) << 10) + (next & 0x3ff);
-
-                    out[offset++] = 0xf0 | (cp >> 18);
-                    out[offset++] = 0x80 | ((cp >> 12) & 0x3f);
-                    out[offset++] = 0x80 | ((cp >> 6) & 0x3f);
-                    out[offset++] = 0x80 | (cp & 0x3f);
-
-                    i++;
-                    continue;
-                }
-                offset = this.writeReplacement(out, offset);
-                continue;
-            }
-            out[offset++] = 0xe0 | (code >> 12);
-            out[offset++] = 0x80 | ((code >> 6) & 0x3f);
-            out[offset++] = 0x80 | (code & 0x3f);
-        }
-
-        return out;
-    }
-    /**
-     * Decodes a UTF-8 byte array into a string. Malformed sequences are replaced with the Unicode replacement character (U+FFFD).
-     * @param bytes The Uint8Array containing the UTF-8 encoded bytes to decode.
-     * @returns The decoded string, with any malformed sequences replaced by U+FFFD.
-     */
-    public static decode(bytes: Uint8Array): string {
-        let out = '';
-        let i = 0;
-        const len = bytes.length;
-
-        while (i < len) {
-            const b1 = bytes[i++];
-            if (b1 < 0x80) {
-                out += String.fromCharCode(b1);
-                continue;
-            }
-            if ((b1 & 0xe0) === 0xc0) {
-                if (i >= len) {
-                    out += this.REPLACEMENT_CHAR;
-                    break;
-                }
-
-                const b2 = bytes[i++];
-
-                if ((b2 & 0xc0) !== 0x80) {
-                    out += this.REPLACEMENT_CHAR;
-                    continue;
-                }
-
-                const code = ((b1 & 0x1f) << 6) | (b2 & 0x3f);
-                out += String.fromCharCode(code);
-                continue;
-            }
-            if ((b1 & 0xf0) === 0xe0) {
-                if (i + 1 >= len) {
-                    out += this.REPLACEMENT_CHAR;
-                    break;
-                }
-
-                const b2 = bytes[i++];
-                const b3 = bytes[i++];
-
-                if ((b2 & 0xc0) !== 0x80 || (b3 & 0xc0) !== 0x80) {
-                    out += this.REPLACEMENT_CHAR;
-                    continue;
-                }
-
-                const code = ((b1 & 0x0f) << 12) | ((b2 & 0x3f) << 6) | (b3 & 0x3f);
-
-                out += String.fromCharCode(code);
-                continue;
-            }
-            if ((b1 & 0xf8) === 0xf0) {
-                if (i + 2 >= len) {
-                    out += this.REPLACEMENT_CHAR;
-                    break;
-                }
-
-                const b2 = bytes[i++];
-                const b3 = bytes[i++];
-                const b4 = bytes[i++];
-
-                if ((b2 & 0xc0) !== 0x80 || (b3 & 0xc0) !== 0x80 || (b4 & 0xc0) !== 0x80) {
-                    out += this.REPLACEMENT_CHAR;
-                    continue;
-                }
-
-                const cp = ((b1 & 0x07) << 18) | ((b2 & 0x3f) << 12) | ((b3 & 0x3f) << 6) | (b4 & 0x3f);
-
-                out += String.fromCodePoint(cp);
-                continue;
-            }
-            out += this.REPLACEMENT_CHAR;
-        }
-
-        return out;
-    }
-    /**
-     * Writes the UTF-8 encoding of the replacement character (U+FFFD) to the output buffer at the specified offset.
-     * @param out The output buffer to write to.
-     * @param offset The offset in the buffer where the replacement character should be written.
-     * @returns The new offset after writing the replacement character.
-     */
-    protected static writeReplacement(out: Uint8Array, offset: number): number {
-        out[offset++] = 0xef;
-        out[offset++] = 0xbf;
-        out[offset++] = 0xbd;
-        return offset;
-    }
-}
-
-export default UTF8Codec;

package/src/support/UUID.ts

@@ -1,125 +0,0 @@
-/**
- * @module vortez-io
- * @author NetFeez <netfeez.dev@gemail.com>
- * @license Apache-2.0
- * @description Isomorphic UUID v4 generator.
- *
- *              ⚠️ IMPORTANT: READ THIS BEFORE USING.
- *              
- *              IS NO LONGER CRYPTOGRAPHICALLY SECURE.
- *              This module provides a fallback implementation of UUID v4 generation using a Linear Congruential Generator (LCG) algorithm
- *              The generated UUIDs are suitable for non-cryptographic use cases, such as generating unique identifiers for events or requests within the Vortez IO protocol, but should not be used in security-sensitive contexts.
- */
-export class UUID {
-    private static seed = UUID.initSeed();
-
-    private static readonly HEX_TABLE = Array.from(
-        { length: 256 },
-        (_, i) => i.toString(16).padStart(2, '0')
-    );
-
-    /**
-     * Initialize the seed for the LCG fallback using a combination of current time and random value.
-     * This ensures that the generated UUIDs are not the same across different runs of the application, even in fallback mode.
-     * @returns A 32-bit unsigned integer to be used as the initial seed for the LCG.
-     */
-    private static initSeed(): number {
-        return (Date.now() ^ Math.floor(Math.random() * 0xffffffff) ) >>> 0;
-    }
-
-    /**
-     * Generate the next 32-bit unsigned integer using a Linear Congruential Generator (LCG) algorithm.
-     * This method is used as a fallback for generating random values when crypto APIs are not available.
-     * The LCG parameters are chosen to provide a reasonable period and distribution for non-cryptographic use cases.
-     * @returns A 32-bit unsigned integer generated by the LCG algorithm.
-     */
-    private static next32(): number {
-        UUID.seed = (1664525 * UUID.seed + 1013904223) >>> 0;
-        return UUID.seed;
-    }
-
-    /**
-     * Generate a UUID v4 string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
-     * This method uses the createRaw() method to generate a 16-byte Uint8Array and then converts it to the standard UUID string format.
-     * @returns A string representation of the generated UUID.
-     */
-    public static create(): string {
-        return this.binToUuid(this.createRaw());
-    }
-
-    /**
-     * Generate a 16-byte Uint8Array containing a UUID v4.
-     * This method uses the LCG fallback to generate random values when crypto APIs are not available.
-     * @returns A Uint8Array containing the 16 bytes of the UUID.
-     */
-    public static createRaw(): Uint8Array {
-        const bytes = new Uint8Array(16);
-
-        for (let i = 0; i < 16; i += 4) {
-            const n = UUID.next32();
-
-            bytes[i]     = (n >>> 24) & 0xff;
-            bytes[i + 1] = (n >>> 16) & 0xff;
-            bytes[i + 2] = (n >>> 8) & 0xff;
-            bytes[i + 3] = n & 0xff;
-        }
-        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-
-        return bytes;
-    }
-
-    /**
-     * Convert a 16-byte Uint8Array to a UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
-     * @param bin A Uint8Array containing the 16 bytes of the UUID.
-     * @returns A string representation of the UUID.
-     */
-    public static binToUuid(bin: Uint8Array): string {
-        const hex = UUID.HEX_TABLE;
-
-        return (
-            hex[bin[0]] + hex[bin[1]] + hex[bin[2]] + hex[bin[3]] + "-" +
-            hex[bin[4]] + hex[bin[5]] + "-" +
-            hex[bin[6]] + hex[bin[7]] + "-" +
-            hex[bin[8]] + hex[bin[9]] + "-" +
-            hex[bin[10]] + hex[bin[11]] + hex[bin[12]] +
-            hex[bin[13]] + hex[bin[14]] + hex[bin[15]]
-        );
-    }
-    /**
-     * Convert a UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx to a 16-byte Uint8Array.
-     * @param uuid A string representation of the UUID.
-     * @returns A Uint8Array containing the 16 bytes of the UUID.
-     */
-    public static uuidToBin(uuid: string): Uint8Array {
-        const hex = UUID.HEX_TABLE;
-        const bin = new Uint8Array(16);
-
-        const parts = uuid.split('-');
-        if (parts.length !== 5) throw new Error(`Invalid UUID format: ${uuid}`);
-
-        const hexStr = parts.join('');
-        if (hexStr.length !== 32) throw new Error(`Invalid UUID format: ${uuid}`);
-
-        for (let i = 0; i < 16; i++) {
-            const byteHex = hexStr.substr(i * 2, 2);
-            const byteValue = parseInt(byteHex, 16);
-            if (isNaN(byteValue)) throw new Error(`Invalid UUID format: ${uuid}`);
-            bin[i] = byteValue;
-        }
-        return bin;
-    }
-    /**
-     * Validate whether a given string is a valid UUID v4 according to the standard format and version/type bits.
-     * This method checks that the string matches the expected pattern for UUID v4, including the correct placement of hyphens and the specific bits that indicate version 4 and the variant.
-     * @param uuid The string to validate as a UUID v4.
-     * @returns True if the input string is a valid UUID v4, false otherwise.
-     */
-    public static isValid(uuid: string): boolean {
-        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        return uuidRegex.test(uuid);
-    }
-}
-
-export namespace UUID {}
-export default UUID;

package/src/support/Varint.ts

@@ -1,62 +0,0 @@
-/**
- * @module vortez-io
- * @author NetFeez <netfeez.dev@gemail.com>
- * @license Apache-2.0
- * @description Provides encoding and decoding functionality for variable-length integers (varints) used in the Vortez IO protocol.
- *              Varints are a compact way to encode integers, where smaller numbers take fewer bytes. Each byte uses the lower 7 bits to store data and the highest bit as a continuation flag (1 if more bytes follow, 0 if this is the last byte).
- *              This module includes methods for reading varints from a Uint8Array and writing numbers as varints into a Uint8Array, with error handling for invalid input and buffer overflows.
- */
-import VIOError from "../VIOError.js";
-
-export class Varint {
-    /**
-     * Reads a varint-encoded integer from the given Uint8Array starting at the specified offset.
-     * Varints are a compact way to encode integers, where smaller numbers take fewer bytes.
-     * Each byte uses the lower 7 bits to store data and the highest bit as a continuation flag (1 if more bytes follow, 0 if this is the last byte).
-     * @param view The Uint8Array to read from.
-     * @param offset The starting index in the array to read the varint from.
-     * @returns An object containing the decoded integer value and the new offset after reading the varint.
-     */
-    public static readVarint(view: Uint8Array, offset: number): Varint.Result {
-        let value = 0;
-        let shift = 0;
-        let pos = offset;
-
-        while (true) {
-            if (pos >= view.length) throw new VIOError(VIOError.Code.BUFFER_TOO_SHORT, 'Varint truncated');
-            const byte = view[pos++];
-            value |= (byte & 0x7F) << shift;
-            if ((byte & 0x80) === 0) break;
-            shift += 7;
-            if (shift > 35) throw new VIOError(VIOError.Code.INVALID_DATA, 'Varint too large');
-        }
-        return { value, offset: pos };
-    }
-    /**
-     * Encodes a number into a varint format (base-128 encoding) and returns it as a Uint8Array.
-     * Varints are a compact way to encode integers, where smaller numbers take fewer bytes.
-     * Each byte uses the lower 7 bits to store data and the highest bit as a continuation flag (1 if more bytes follow, 0 if this is the last byte).
-     * @param value The number to encode as a varint. Must be a non-negative integer.
-     * @returns A Uint8Array containing the varint-encoded bytes of the input number.
-     */
-    public static writeVarint(value: number): Uint8Array {
-        if (value < 0) throw new VIOError(VIOError.Code.INVALID_DATA, 'Varint cannot be negative');
-        const bytes: number[] = [];
-
-        while (true) {
-            let byte = value & 0x7F;
-            value >>>= 7;
-            if (value !== 0) { byte |= 0x80; }
-            bytes.push(byte);
-            if (value === 0) break;
-        }
-        return new Uint8Array(bytes);
-    }
-}
-export namespace Varint {
-    export interface Result {
-        value: number;
-        offset: number;
-    }
-}
-export default Varint;

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "esModuleInterop": true,
-    "sourceMap": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "rootDir": "src",
-    "outDir": "build",
-    "types": [],
-    "lib": [ "ESNext" ],
-  },
-  "include": [ "src/**/*.ts" ]
-}