vortez-io 1.0.0

package/docs/PROTOCOL-PROPOSE.md

@@ -0,0 +1,252 @@
+> [!IMPORTANT]
+> THIS IS THE FIRST REVISION OF THE PROTOCOL, THIS IS NOT APPLICABLE
+> THIS DOCUMENT IS ONLY FOR HISTORIC DOCUMENTATION
+> SEE THE [REAL SPECIFICATION HERE](https://github.com/NetFeez/vortez-io-protocol/blob/main/PROTOCOL.md)
+
+# Vortez IO Protocol
+
+Vortez IO Protocol works over WebSocket protocol and defines a binary frame structure for multiplexed messaging (events, requests, responses and errors).
+
+Each WebSocket frame **MUST** contain exactly **one Vortez frame**.
+
+---
+
+## Protocol Frame Description
+
+### Header description map
+
+| byte | bit | Function | description                 |
+| ---- | --- | -------- | --------------------------- |
+| 0    | 0-3 | TYPE     | [Reference for type](#type) |
+| 0    | 4-6 | MODE     | [Reference for mode](#mode) |
+| 0    | 7   | HUID     | [Reference for huid](#huid) |
+
+> [!IMPORTANT]
+>
+> 🔒 **Invariant:** Header byte (byte 0) is always present.
+>
+> 🔒 **Invariant:** Header byte (byte 1) is always present and reserved.
+
+---
+
+## Frame Layout
+
+### If `HUID = 0b1`
+
+| byte | Function | description                 |
+| ---- | -------- | --------------------------- |
+| 2-17 | UUID     | 16-byte identifier (binary) |
+| 18.. | DATA     | Payload                     |
+
+### If `HUID = 0b0`
+
+| byte | Function | description |
+| ---- | -------- | ----------- |
+| 2..  | DATA     | Payload     |
+
+---
+
+## UUID Specification
+
+* UUID **MUST** be exactly **16 bytes**
+* UUID **MUST** be treated as opaque binary (no string encoding)
+* Endianness is **network order (big-endian)**
+* UUID is used for **request-response correlation**
+
+---
+
+## TYPE
+
+Defines the semantic meaning of the frame.
+
+| Value | Name     | Description                |
+| ----- | -------- | -------------------------- |
+| `0x0` | RAW      | Unstructured binary data   |
+| `0x1` | EVENT    | Fire-and-forget message    |
+| `0x2` | REQUEST  | Request expecting response |
+| `0x3` | RESPONSE | Response to a request      |
+| `0x4` | ERROR    | Error frame                |
+
+---
+
+### TYPE Rules
+
+#### `0x0` RAW
+
+* **MAY** include any MODE
+* **MUST NOT** rely on protocol-level semantics
+* **MUST NOT** require UUID
+* Receiver **MUST NOT** assume structure
+
+---
+
+#### `0x1` EVENT
+
+* **MUST NOT** include UUID (`HUID = 0`)
+* **MUST** be treated as one-way message
+* Receiver **MUST NOT** send RESPONSE automatically
+
+---
+
+#### `0x2` REQUEST
+
+* **MUST** include UUID (`HUID = 1`)
+* UUID **MUST** be unique per connection (until resolved)
+* Receiver **MUST** respond with either:
+
+  * `RESPONSE (0x3)`
+  * or `ERROR (0x4)`
+
+---
+
+#### `0x3` RESPONSE
+
+* **MUST** include UUID (`HUID = 1`)
+* UUID **MUST** match an existing REQUEST
+* Receiver **MUST** resolve the associated request
+
+---
+
+#### `0x4` ERROR
+
+Error frames represent protocol or application failures.
+
+* **MAY** include UUID
+* If UUID is present:
+
+  * it **MUST** reference the related REQUEST
+* If UUID is absent:
+
+  * it represents a **connection-level or protocol-level error**
+
+---
+
+## ERROR Semantics
+
+We define two clear categories:
+
+### 1. Error Response (Request-bound)
+
+Used as a response to a request.
+
+* TYPE: `0x4`
+* HUID: `1`
+* MUST include UUID
+* MUST correspond to a REQUEST
+
+Example causes:
+
+* invalid payload
+* handler failure
+* validation error
+
+---
+
+### 2. Error Feedback (Unbound / Protocol-level)
+
+Used when no request context exists.
+
+* TYPE: `0x4`
+* HUID: `0`
+* MUST NOT include UUID
+
+Example causes:
+
+* malformed frame
+* invalid header bits
+* unsupported TYPE or MODE
+* protocol violation
+
+---
+
+### Error Behavior Rules
+
+If a frame violates protocol:
+
+* Receiver **MUST** send `ERROR (0x4)`
+* If UUID is available → **MUST include it**
+* Otherwise → **MUST send without UUID**
+
+---
+
+## MODE
+
+Defines how DATA should be interpreted.
+
+| Value | Name   | Description                          |
+| ----- | ------ | ------------------------------------ |
+| `0x0` | BINARY | Binary                               |
+| `0x1` | JSON   | UTF-8 encoded JSON                   |
+| `0x2` | LINE   | UTF-8 text terminated by LF (`0x0A`) |
+| `0x3` | CUSTOM | Application-defined                  |
+
+---
+
+### MODE Rules
+
+#### JSON (`0x1`)
+
+* DATA **MUST** be valid UTF-8 JSON
+* Receiver **MUST** parse as JSON
+
+---
+
+#### LINE (`0x2`)
+
+* DATA **MUST** be UTF-8 text
+* Messages **SHOULD** end with `\n` (`0x0A`)
+* Receiver **MAY** trim trailing newline
+
+---
+
+#### CUSTOM (`0x3`)
+
+* Interpretation is application-defined
+* Protocol **MUST NOT** enforce structure
+
+---
+
+## HUID
+
+Defines presence of UUID.
+
+| Value | Meaning      |
+| ----- | ------------ |
+| `0b0` | No UUID      |
+| `0b1` | UUID present |
+
+---
+
+## HUID Rules
+
+| TYPE             | HUID | Rule                  |
+| ---------------- | ---- | --------------------- |
+| RAW (`0x0`)      | ANY  | MAY include UUID      |
+| EVENT (`0x1`)    | 0    | MUST NOT include UUID |
+| REQUEST (`0x2`)  | 1    | MUST include UUID     |
+| RESPONSE (`0x3`) | 1    | MUST include UUID     |
+| ERROR (`0x4`)    | ANY  | Context-dependent     |
+
+---
+
+## Reserved Space (Future Use)
+
+* Byte `1` is **implicitly reserved**
+* Future versions **MAY** introduce:
+
+  * length prefix
+  * flags
+  * versioning
+
+Current implementations:
+
+* **MUST ignore** any future extension unless negotiated
+
+---
+
+## Protocol Guarantees
+
+* One WebSocket frame = one Vortez frame
+* No internal framing is used
+* Ordering is delegated to WebSocket
+* Reliability is delegated to transport

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "vortez-io",
+  "version": "1.0.0",
+  "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"
+  },
+  "keywords": [
+    "vortez",
+    "vortez-io",
+    "websocket",
+    "protocol",
+    "binary protocol",
+    "request response",
+    "event-driven",
+    "messaging",
+    "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/scripts/build.sh

@@ -0,0 +1,14 @@
+#!/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

@@ -0,0 +1,312 @@
+/**
+ * @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

@@ -0,0 +1,7 @@
+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;