@boo-labs/server 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Beltran Rodriguez Victor
+
+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

@@ -1,12 +1,8 @@
 # @boo-labs/server
 
-A lightweight, zero-dependency HTTP server for Node.js, designed around
-modular architecture, explicit configuration, and a predictable request
-lifecycle.
+A lightweight, zero-dependency HTTP server for Node.js, designed around modular architecture, explicit configuration, and a predictable request lifecycle.
 
-`@boo-labs/server` provides a small public API for building HTTP applications
-with support for HTTP/1.1, HTTPS, and HTTP/2, along with routing,
-middleware composition, lifecycle events, and graceful resource management.
+`@boo-labs/server` provides a small public API for building HTTP applications with support for HTTP/1.1, HTTPS, and HTTP/2, along with routing, middleware composition, lifecycle events, and graceful resource management.
 
 ## Features
 
@@ -45,14 +41,14 @@ TypeScript declarations for the public API are included in the package.
 ```js
 import Server, { HttpServerConfiguration } from '@boo-labs/server';
 
-const server = new Server(
-  new HttpServerConfiguration({
-    listen: {
-      host: '127.0.0.1',
-      port: 3000,
-    },
-  }),
-);
+const configuration = new HttpServerConfiguration({
+  listen: {
+    host: '127.0.0.1',
+    port: 3000,
+  },
+});
+
+const server = new Server(configuration);
 
 server.get('/hello', (exchange) => {
   exchange.response.json({ message: 'Hello, World!' });
@@ -73,12 +69,9 @@ await server.listen();
 
 ### Exchange
 
-An `Exchange` represents a single HTTP transaction. It couples the incoming
-request with its outgoing response and exposes shared per-request state,
-correlation identifiers, and a cancellation signal.
+An `Exchange` represents a single HTTP transaction. It couples the incoming request with its outgoing response and exposes shared per-request state, correlation identifiers, and a cancellation signal.
 
-Exchanges are created by the runtime and passed to middleware and handlers.
-Consumers do not construct exchanges.
+Exchanges are created by the runtime and passed to middleware and handlers. Consumers do not construct exchanges.
 
 ```js
 server.get('/hello', async (exchange) => {
@@ -86,8 +79,17 @@ server.get('/hello', async (exchange) => {
 });
 ```
 
-Key properties: `id`, `traceId`, `spanId`, `signal`, `request`, `response`,
-and `state` (a mutable plain object for request-scoped data).
+Key properties:
+
+| Property    | Type                      | Description                              |
+|-------------|---------------------------|------------------------------------------|
+| `id`        | `string`                  | Unique identifier for the exchange.      |
+| `traceId`   | `string`                  | W3C trace identifier.                    |
+| `spanId`    | `string`                  | W3C span identifier.                     |
+| `signal`    | `AbortSignal`             | Cancellation signal for the exchange.    |
+| `request`   | `Request`                 | Incoming request.                        |
+| `response`  | `Response`                | Outgoing response.                       |
+| `state`     | `Record<string, unknown>` | Mutable per-request state.               |
 
 ### Request
 
@@ -103,26 +105,31 @@ Supported media types for `body()`:
 | `application/x-www-form-urlencoded` | Parsed key/value object         |
 | `multipart/form-data`               | Parsed multipart representation |
 
-Unsupported media types raise `RequestError`. When the body exceeds the
-configured limit, reading fails with `RequestError` and the connection may
-be closed without a normal error response.
+Unsupported media types raise `RequestError`. When the body exceeds the configured limit, reading fails with `RequestError` and the connection may be closed without a normal error response.
 
 The `CONNECT` method is not supported.
 
 ### Response
 
-Built progressively by configuring status, headers, and body. Body methods
-do not send anything; only `end()` materializes and sends the response.
-A response can describe at most one body.
+Built progressively by configuring status, headers, and body. Body methods do not send anything; only `end()` materializes and sends the response. A response can describe at most one body.
 
-Convenience methods: `json()`, `html()`, `text()`, `send()`, `stream()`,
-`redirect()`, `cache()`, `noCache()`, `vary()`.
+Convenience methods:
+
+| Method       | Purpose                                          |
+|--------------|--------------------------------------------------|
+| `json()`     | Serializes a value as JSON.                      |
+| `html()`     | Sends an HTML body.                              |
+| `text()`     | Sends a plain-text body.                         |
+| `send()`     | Sends a string or binary body.                   |
+| `stream()`   | Streams a readable body.                         |
+| `redirect()` | Sends a redirect response.                       |
+| `cache()`    | Sets a public cache lifetime.                    |
+| `noCache()`  | Disables caching.                                |
+| `vary()`     | Adds fields to the `Vary` header.                |
 
 ### Middleware
 
-Middleware functions receive `(exchange, next)` and run in registration
-order. They may be registered globally, by pathname, on a route, or on a
-router.
+Middleware functions receive `(exchange, next)` and run in registration order. They may be registered globally, by pathname, on a route, or on a router.
 
 ```js
 server.use(async (exchange, next) => {
@@ -141,14 +148,25 @@ server.use(async (exchange, next) => {
 
 Routes associate an HTTP method and a pathname pattern with middleware.
 
-Supported methods: `get`, `post`, `put`, `patch`, `delete`, `head`,
-`trace`, `query`. Routers also support `all()`. `OPTIONS` is handled
-automatically.
+Supported methods:
+
+| Method     | Server | Router |
+|------------|--------|--------|
+| `get()`    | ✅     | ✅     |
+| `post()`   | ✅     | ✅     |
+| `put()`    | ✅     | ✅     |
+| `patch()`  | ✅     | ✅     |
+| `delete()` | ✅     | ✅     |
+| `head()`   | ✅     | ✅     |
+| `trace()`  | ✅     | ✅     |
+| `query()`  | ✅     | ✅     |
+| `all()`    | ❌     | ✅     |
 
-Pathname patterns support literals, named parameters (`:id` or `{id}`),
-and wildcards (`*` / trailing `/*`). Named parameters and wildcards are
-used only for matching; captured values are not exposed on the exchange.
-To read a path segment, parse `exchange.request.pathname` directly.
+**Note:** `OPTIONS` is handled automatically and does not require a dedicated registration method.
+
+Pathname patterns support literals, named parameters (`:id` or `{id}`), and wildcards (`*` / trailing `/*`).
+
+Named parameters and wildcards are used only for matching; captured values are not exposed on the exchange. To read a path segment, parse `exchange.request.pathname` directly.
 
 ```js
 const api = new Router();
@@ -168,15 +186,25 @@ Four configuration classes fix the transport:
 | `Http2CleartextServerConfiguration` | `http`   | `h2c`     |
 | `Http2SecureServerConfiguration`    | `https`  | `h2`      |
 
-Common top-level options: `connection`, `listen`, `request`, `response`,
-`static`, `cors`, `securityHeaders`, `rateLimit`, `cookie`, `csrf`,
-`compress`.
+Common top-level options:
+
+| Option            | Purpose                                       |
+|-------------------|-----------------------------------------------|
+| `connection`      | Transport-specific Node.js server options.    |
+| `listen`          | Host, port, and backlog for binding.          |
+| `request`         | Request parsing and proxy trust.              |
+| `response`        | Response shaping (ETag, charset).             |
+| `static`          | Static file serving.                          |
+| `cors`            | Cross-Origin Resource Sharing.                |
+| `securityHeaders` | HTTP security response headers.               |
+| `rateLimit`       | Request rate limiting.                        |
+| `cookie`          | Cookie parsing and cookie-backed sessions.    |
+| `csrf`            | CSRF protection.                              |
+| `compress`        | Response compression.                         |
 
-These options enable server features. When enabled, the corresponding
-behavior is applied before user-registered middleware.
+These options enable server features. When enabled, the corresponding behavior is applied before user-registered middleware.
 
-See the [full API reference](./Docs/BOO_SERVER_API.md) for the complete
-option shapes and defaults.
+See the [full API reference](https://github.com/vgbr-dev/boo-labs/wiki) for the complete option shapes and defaults.
 
 ## Lifecycle and Events
 
@@ -186,45 +214,75 @@ await server.listen();
 await server.close();
 ```
 
-States: `idle` → `starting` → `listening` → `stopping` → `closed` (or `error`).
+States:
+
+| State       | Description                                          |
+|-------------|------------------------------------------------------|
+| `idle`      | Initial state. The server has not started.           |
+| `starting`  | The server is starting up.                           |
+| `listening` | The server is accepting connections.                 |
+| `stopping`  | The server is shutting down.                         |
+| `closed`    | The server has closed.                               |
+| `error`     | The server encountered an error and cannot continue. |
+
+Events:
 
-Events: `listen`, `close`, `error`, `exchange:start`, `exchange:end`,
-`exchange:error`. Convenience methods: `onListen()`, `onClose()`,
-`onError()`, `onExchangeStart()`, `onExchangeEnd()`, `onExchangeError()`.
+| Event            | Convenience method    | Description                      |
+|------------------|-----------------------|----------------------------------|
+| `listen`         | `onListen()`          | The server started listening.    |
+| `close`          | `onClose()`           | The server has closed.           |
+| `error`          | `onError()`           | A server error occurred.         |
+| `exchange:start` | `onExchangeStart()`   | An exchange began processing.    |
+| `exchange:end`   | `onExchangeEnd()`     | An exchange ended.               |
+| `exchange:error` | `onExchangeError()`   | An exchange failed.              |
 
-`Server` implements `Symbol.asyncDispose` for `await using` when the
-runtime supports it.
+`Server` implements `Symbol.asyncDispose` for `await using` when the runtime supports it.
 
 ## IPC
 
-An IPC API over WebSocket at `/ipc`. Supports request-response channels
-(`handle` / invoke) and one-way events (`on` / event). Available while the
+An IPC API over WebSocket at `/ipc`. Supports request-response channels (`handle` / invoke) and one-way events (`on` / event). Available while the
 server is listening via `server.ipc`.
 
-See the [full API reference](./Docs/BOO_SERVER_API.md) for the wire protocol
-and handler details.
+```js
+await server.listen();
+
+server.ipc.handle('users:get', async (id) => {
+  return usersRepository.findById(id);
+});
+
+server.ipc.on('analytics:event', (event) => {
+  analytics.record(event);
+});
+```
+
+See the [full API reference](https://github.com/vgbr-dev/boo-labs/wiki) for the wire protocol and handler details.
 
 ## Errors
 
 Public APIs throw errors that extend `Error` and expose a stable `code`
-property. Error types include `ServerConfigurationError`, `RequestError`,
-`ResponseError`, `RouterError`, `PathnamePatternError`, `MiddlewareError`,
-`ServerError`, and `IPCError`.
+property.
+
+| Error                      | Domain                                       |
+|----------------------------|----------------------------------------------|
+| `ServerConfigurationError` | Server configuration validation.             |
+| `RequestError`             | Incoming request processing.                 |
+| `ResponseError`            | Outgoing response construction.              |
+| `RouterError`              | Router route registration.                   |
+| `PathnamePatternError`     | Pathname pattern validation.                 |
+| `MiddlewareError`          | Middleware validation.                       |
+| `ServerError`              | Server lifecycle and state transitions.      |
+| `IPCError`                 | IPC operations.                              |
 
-Error codes are documented in the
-[project wiki](https://github.com/vgbr-dev/boo-labs/wiki/Errors).
+Error codes are documented in the [project wiki](https://github.com/vgbr-dev/boo-labs/wiki/Errors).
 
 ## Documentation
 
-- [Full API reference](./Docs/SERVER_API.md) — complete public API,
-  configuration options, response methods, IPC protocol, and more.
+- [Full API reference](https://github.com/vgbr-dev/boo-labs/wiki) — complete public API, configuration options, response methods, IPC protocol, and more.
 
 ## License
 
-Distributed under the MIT License. See the [LICENSE](./LICENSE) file for
-details.
+Distributed under the MIT License. See the [LICENSE](./LICENSE) file for details.
 
 ## Dedication
 
-This project is named after my sister — "Boo". Her nickname gave this
-project its name.
+This project is named after my sister — "Boo". Her nickname gave this project its name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boo-labs/server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A zero-dependency, frameworkless HTTP server for Node.js, built around Clean Architecture principles.",
   "keywords": [
     "http-server",

package/source/core/IPCMain/IPCProtocol.mjs

@@ -17,6 +17,20 @@
 import Result from '#shared/outcome/Result';
 
 // ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * A successful {@link Result} instance.
+ *
+ * @template T
+ * @typedef {import('#shared/outcome/Result').SuccessResult<T>} SuccessResult
+ */
+
+/**
+ * A failed {@link Result} instance.
+ *
+ * @template {Error} E
+ * @typedef {import('#shared/outcome/Result').FailureResult<E>} FailureResult
+ */
+
 /**
  * Represents an IPC invocation request.
  *
@@ -99,6 +113,18 @@ function isPlainObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+/**
+ * Attaches a machine-readable code to an Error instance.
+ *
+ * @template {Error} E
+ * @param {E} error - Error instance to annotate.
+ * @param {string} code - Machine-readable error code.
+ * @returns {E & { code: string }} The annotated error.
+ */
+function withCode(error, code) {
+  return Object.assign(error, { code });
+}
+
 // ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 /**
  * Implements the IPC wire protocol for decoding requests and serializing responses.
@@ -243,25 +269,19 @@ class IPCProtocol {
    * a failure describing the first structural violation encountered.
    *
    * @param {unknown} message - Parsed IPC payload.
-   * @returns {Result<IPCRequest>} Successful result containing the normalized request, or a failure describing the validation error.
+   * @returns {SuccessResult<IPCRequest>|FailureResult<TypeError|ReferenceError>} Successful result containing the normalized request, or a failure describing the validation error.
    */
   #ensureRequest(message) {
     if (!isPlainObject(message)) {
-      return Result.failure({
-        error: TypeError,
-        message: 'IPC message must be a plain object.',
-        code: 'IPC_INVALID_MESSAGE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new TypeError('IPC message must be a plain object.'), 'IPC_INVALID_MESSAGE'),
+      );
     }
 
     if (!('type' in message)) {
-      return Result.failure({
-        error: ReferenceError,
-        message: 'IPC message requires a "type" property.',
-        code: 'IPC_MISSING_TYPE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new ReferenceError('IPC message requires a "type" property.'), 'IPC_MISSING_TYPE'),
+      );
     }
 
     if (message.type === 'invoke') {
@@ -272,73 +292,61 @@ class IPCProtocol {
       return this.#ensureEventRequest(message);
     }
 
-    return Result.failure({
-      error: TypeError,
-      message: 'IPC message type must be "invoke" or "event".',
-      code: 'IPC_INVALID_TYPE',
-      custom: false,
-    });
+    return Result.failure(
+      withCode(new TypeError('IPC message type must be "invoke" or "event".'), 'IPC_INVALID_TYPE'),
+    );
   }
 
   /**
    * Ensures a parsed IPC payload is a valid invocation request.
    *
    * @param {Record<string, unknown>} message - Parsed IPC payload.
-   * @returns {Result<IPCInvokeRequest>} Successful result containing the normalized request, or a failure describing the validation error.
+   * @returns {SuccessResult<IPCInvokeRequest>|FailureResult<TypeError|ReferenceError|RangeError>} Successful result containing the normalized request, or a failure describing the validation error.
    */
   #ensureInvokeRequest(message) {
     if (!('channel' in message)) {
-      return Result.failure({
-        error: ReferenceError,
-        message: 'IPC message requires a "channel" property.',
-        code: 'IPC_MISSING_CHANNEL',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(
+          new ReferenceError('IPC message requires a "channel" property.'),
+          'IPC_MISSING_CHANNEL',
+        ),
+      );
     }
 
     if (typeof message.channel !== 'string') {
-      return Result.failure({
-        error: TypeError,
-        message: 'IPC channel must be a string.',
-        code: 'IPC_INVALID_CHANNEL_TYPE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new TypeError('IPC channel must be a string.'), 'IPC_INVALID_CHANNEL_TYPE'),
+      );
     }
 
     if (message.channel.trim().length === 0) {
-      return Result.failure({
-        error: RangeError,
-        message: 'IPC channel must be a non-empty string.',
-        code: 'IPC_INVALID_CHANNEL_RANGE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(
+          new RangeError('IPC channel must be a non-empty string.'),
+          'IPC_INVALID_CHANNEL_RANGE',
+        ),
+      );
     }
 
     if (!('id' in message)) {
-      return Result.failure({
-        error: ReferenceError,
-        message: 'IPC invocation requires an "id" property.',
-        code: 'IPC_MISSING_ID',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new ReferenceError('IPC invocation requires an "id" property.'), 'IPC_MISSING_ID'),
+      );
     }
 
     if (typeof message.id !== 'string') {
-      return Result.failure({
-        error: TypeError,
-        message: 'IPC invocation id must be a string.',
-        code: 'IPC_INVALID_ID_TYPE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new TypeError('IPC invocation id must be a string.'), 'IPC_INVALID_ID_TYPE'),
+      );
     }
 
     if (message.id.trim().length === 0) {
-      return Result.failure({
-        error: RangeError,
-        message: 'IPC invocation id must be a non-empty string.',
-        code: 'IPC_INVALID_ID_RANGE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(
+          new RangeError('IPC invocation id must be a non-empty string.'),
+          'IPC_INVALID_ID_RANGE',
+        ),
+      );
     }
 
     return Result.success({
@@ -353,34 +361,31 @@ class IPCProtocol {
    * Ensures a parsed IPC payload is a valid event request.
    *
    * @param {Record<string, unknown>} message - Parsed IPC payload.
-   * @returns {Result<IPCEventRequest>} Successful result containing the normalized request, or a failure describing the validation error.
+   * @returns {SuccessResult<IPCEventRequest>|FailureResult<TypeError|ReferenceError|RangeError>} Successful result containing the normalized request, or a failure describing the validation error.
    */
   #ensureEventRequest(message) {
     if (!('channel' in message)) {
-      return Result.failure({
-        error: ReferenceError,
-        message: 'IPC message requires a "channel" property.',
-        code: 'IPC_MISSING_CHANNEL',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(
+          new ReferenceError('IPC message requires a "channel" property.'),
+          'IPC_MISSING_CHANNEL',
+        ),
+      );
     }
 
     if (typeof message.channel !== 'string') {
-      return Result.failure({
-        error: TypeError,
-        message: 'IPC channel must be a string.',
-        code: 'IPC_INVALID_CHANNEL_TYPE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(new TypeError('IPC channel must be a string.'), 'IPC_INVALID_CHANNEL_TYPE'),
+      );
     }
 
     if (message.channel.trim().length === 0) {
-      return Result.failure({
-        error: RangeError,
-        message: 'IPC channel must be a non-empty string.',
-        code: 'IPC_INVALID_CHANNEL_RANGE',
-        custom: false,
-      });
+      return Result.failure(
+        withCode(
+          new RangeError('IPC channel must be a non-empty string.'),
+          'IPC_INVALID_CHANNEL_RANGE',
+        ),
+      );
     }
 
     return Result.success({

package/source/shared/domain/UUIDV7/index.mjs

@@ -13,6 +13,20 @@
  * @module UUIDV7
  */
 
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * A successful {@link Validation} instance.
+ *
+ * @typedef {import('#shared/outcome/Validation').SuccessValidation} SuccessValidation
+ */
+
+/**
+ * A failed {@link Validation} instance.
+ *
+ * @template {Error} E
+ * @typedef {import('#shared/outcome/Validation').FailureValidation<E>} FailureValidation
+ */
+
 // ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 // » IMPORT NATIVE NODEJS MODULES
 import { randomBytes } from 'node:crypto';
@@ -42,6 +56,11 @@ const UUIDV7_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[
  * sortable.
  */
 class UUIDV7 {
+  /**
+   * The UUID value.
+   *
+   * @type {string}
+   */
   #uuid;
 
   /**
@@ -235,8 +254,9 @@ class UUIDV7 {
    * timestamp, and a UUID v7 string represents the timestamp encoded in that
    * UUID.
    *
-   * @param {*} value - Value to validate.
-   * @returns {Validation} Validation result.
+   * @param {unknown} value - Value to validate.
+   * @returns {SuccessValidation|FailureValidation<RangeError|TypeError>} Validation result.
+   *
    * @example
    * ```js
    * const result = UUIDV7.validate();
@@ -249,41 +269,27 @@ class UUIDV7 {
 
     if (value instanceof Date) {
       if (Number.isNaN(value.getTime())) {
-        return Validation.failure({
-          error: RangeError,
-          message: 'Invalid timestamp.',
-          code: 'INVALID_TIMESTAMP',
-          custom: false,
-        });
+        return Validation.failure(new RangeError('Invalid timestamp.'));
       }
       return Validation.success();
     }
 
     if (typeof value === 'string') {
       if (!UUIDV7_REGEXP.test(value)) {
-        return Validation.failure({
-          error: RangeError,
-          message: 'Invalid UUID v7.',
-          code: 'INVALID_UUID',
-          custom: false,
-        });
+        return Validation.failure(new RangeError('Invalid UUID v7.'));
       }
       return Validation.success();
     }
 
-    return Validation.failure({
-      error: TypeError,
-      message: 'Timestamp must be a Date, string, or undefined.',
-      code: 'INVALID_TIMESTAMP_SOURCE',
-      custom: false,
-    });
+    return Validation.failure(new TypeError('Timestamp must be a Date, string, or undefined.'));
   }
 
   /**
    * Validates that a value is a valid UUID v7 string.
    *
    * @param {unknown} value - Value to validate.
-   * @returns {Validation} Validation result.
+   * @returns {SuccessValidation|FailureValidation<ReferenceError|RangeError|TypeError>} Validation result.
+   *
    * @example
    * ```js
    * const result = UUIDV7.validateUUIDString('019937f2-1234-7abc-8def-123456789abc');
@@ -291,30 +297,15 @@ class UUIDV7 {
    */
   static validateUUIDString(value) {
     if (value === undefined) {
-      return Validation.failure({
-        error: ReferenceError,
-        message: 'UUID must be a string.',
-        custom: false,
-        code: 'MISSING_UUID',
-      });
+      return Validation.failure(new ReferenceError('UUID must be a string.'));
     }
 
     if (typeof value !== 'string') {
-      return Validation.failure({
-        error: TypeError,
-        message: 'UUID must be a string.',
-        custom: false,
-        code: 'INVALID_UUID_TYPE',
-      });
+      return Validation.failure(new TypeError('UUID must be a string.'));
     }
 
     if (!UUIDV7_REGEXP.test(value)) {
-      return Validation.failure({
-        error: RangeError,
-        message: 'Invalid UUID v7 format.',
-        custom: false,
-        code: 'INVALID_UUID',
-      });
+      return Validation.failure(new RangeError('Invalid UUID v7 format.'));
     }
 
     return Validation.success();
@@ -328,6 +319,7 @@ class UUIDV7 {
    * @param {unknown} value - Value to validate.
    * @throws {TypeError} If the value has an unsupported type.
    * @throws {RangeError} If the value is invalid.
+   *
    * @example
    * ```js
    * UUIDV7.assert(new Date());