viojs-core 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# viojs-core
+
+High-performance Node.js framework core built on uWebSockets.js.
+
+## Features
+- uWebSockets.js integration
+- Koa-style middleware
+- TypeScript Decorators
+- IoC / Dependency Injection
+- WebSocket Hub
+
+## Installation
+```bash
+npm install viojs-core
+```

package/dist/core/Application.d.ts

@@ -0,0 +1,16 @@
+import { us_listen_socket } from 'uWebSockets.js';
+import { Middleware } from './Context';
+export declare class Application {
+    private app;
+    private middlewares;
+    private router;
+    constructor();
+    use(middleware: Middleware): this;
+    publish(topic: string, message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): void;
+    registerWsRoute(pattern: string, behavior: any): void;
+    registerRoutes(controllers: any[]): void;
+    listen(port: number, cb?: (token: us_listen_socket) => void): Promise<void>;
+    private writeHeaders;
+    private sendResponse;
+    private compose;
+}

package/dist/core/Application.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const uWebSockets_js_1 = require("uWebSockets.js");
+const Context_1 = require("./Context");
+const Router_1 = require("./Router");
+const Container_1 = require("./Container");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class Application {
+    app;
+    middlewares = [];
+    router;
+    constructor() {
+        this.app = (0, uWebSockets_js_1.App)();
+        this.router = new Router_1.Router(this);
+        // Bind the current Application instance to the DI container for global retrieval
+        Container_1.container.instances.set(Application, this);
+    }
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    // Global fast broadcast
+    publish(topic, message, isBinary = false, compress = false) {
+        this.app.publish(topic, message, isBinary, compress);
+    }
+    // Register a WebSocket namespace
+    registerWsRoute(pattern, behavior) {
+        // pattern must be uWS format, e.g. /* or /room/*
+        this.app.ws(pattern, behavior);
+    }
+    // Register router routes
+    registerRoutes(controllers) {
+        console.error("Application.registerRoutes called with", controllers.length, "controllers");
+        this.router.register(controllers);
+        this.use(this.router.middleware());
+    }
+    async listen(port, cb) {
+        this.app.any('/*', async (res, req) => {
+            const isUpgrade = req.getHeader('upgrade') === 'websocket';
+            if (isUpgrade) {
+                res.setYield(true);
+                return;
+            }
+            console.error("DEBUG ENTERED HANDLER");
+            const url = req.getUrl();
+            console.error("URL:", url);
+            let contextAborted = false;
+            try {
+                // Create context
+                const ctx = new Context_1.BaseContext(res, req);
+                console.log(`Incoming request: ${ctx.method} ${ctx.url}`);
+                // Keep track of abort safely beyond context setup since we are going async heavily
+                res.onAborted(() => {
+                    ctx.aborted = true;
+                    contextAborted = true;
+                });
+                // Execute middleware chain
+                try {
+                    if (contextAborted)
+                        return;
+                    const composed = this.compose(this.middlewares);
+                    await composed(ctx);
+                    if (!contextAborted && !ctx.responded) {
+                        this.sendResponse(ctx, contextAborted);
+                    }
+                }
+                catch (err) {
+                    console.error('Middleware error:', err);
+                    if (!contextAborted) {
+                        res.writeStatus('500 Internal Server Error').end('Internal Server Error');
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Context creation error:', err);
+                if (!contextAborted) {
+                    res.writeStatus('500 Internal Server Error').end('Context Error');
+                }
+            }
+        });
+        this.app.listen(port, (token) => {
+            if (cb)
+                cb(token);
+            else {
+                if (token) {
+                    console.log('Listening to port ' + port);
+                }
+                else {
+                    console.log('Failed to listen to port ' + port);
+                }
+            }
+        });
+    }
+    // Extracted headers writer
+    writeHeaders(ctx) {
+        const { res, status, responseHeaders } = ctx;
+        const statusMap = {
+            200: '200 OK',
+            201: '201 Created',
+            204: '204 No Content',
+            400: '400 Bad Request',
+            401: '401 Unauthorized',
+            403: '403 Forbidden',
+            404: '404 Not Found',
+            500: '500 Internal Server Error'
+        };
+        const statusText = statusMap[status] || `${status} Status`;
+        res.writeStatus(statusText);
+        for (const [key, value] of Object.entries(responseHeaders)) {
+            if (Array.isArray(value)) {
+                value.forEach(v => res.writeHeader(key, v));
+            }
+            else {
+                res.writeHeader(key, value);
+            }
+        }
+    }
+    sendResponse(ctx, contextAborted) {
+        if (contextAborted)
+            return;
+        const { res, body, _filePath } = ctx;
+        // --- BRANCH A: FILE STREAMING ---
+        if (_filePath) {
+            fs.stat(_filePath, (err, stats) => {
+                if (err || !stats.isFile() || contextAborted || ctx.aborted) {
+                    if (!contextAborted && !ctx.aborted) {
+                        ctx.status = 404;
+                        res.cork(() => {
+                            this.writeHeaders(ctx);
+                            res.end('File Not Found');
+                        });
+                    }
+                    return;
+                }
+                const totalSize = stats.size;
+                // Basic Mime type guess if not set
+                if (!ctx.responseHeaders['Content-Type']) {
+                    const ext = path.extname(_filePath).toLowerCase();
+                    const mimeTypes = {
+                        '.json': 'application/json',
+                        '.png': 'image/png',
+                        '.atlas': 'text/plain',
+                        '.txt': 'text/plain',
+                        '.jpg': 'image/jpeg',
+                        '.jpeg': 'image/jpeg'
+                    };
+                    ctx.responseHeaders['Content-Type'] = mimeTypes[ext] || 'application/octet-stream';
+                }
+                res.cork(() => {
+                    this.writeHeaders(ctx);
+                });
+                let readStream = fs.createReadStream(_filePath);
+                readStream.on('data', (chunk) => {
+                    if (typeof chunk === 'string') {
+                        chunk = Buffer.from(chunk);
+                    }
+                    // Try to send chunk via uWebSockets
+                    const chunkArrayBuffer = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+                    let ok = false;
+                    let done = false;
+                    res.cork(() => {
+                        const result = res.tryEnd(chunkArrayBuffer, totalSize);
+                        ok = result[0];
+                        done = result[1];
+                    });
+                    if (done) {
+                        // Current chunk ended successfully and stream completed (if it was the last piece)
+                    }
+                    else if (ok) {
+                        // Chunk successfully buffered to C++ space
+                    }
+                    else {
+                        // **Backpressure activated!**
+                        // C++ buffer is full (Client network is slow) -> Pause reading from Disk!
+                        readStream.pause();
+                        // Wait for C++ buffer to drain
+                        res.onWritable((offset) => {
+                            // C++ buffer drained, we can resume reading from Disk
+                            readStream.resume();
+                            // Important: You must return true explicitly to tell uWebSockets the stream is still alive
+                            return true;
+                        });
+                    }
+                });
+                readStream.on('error', () => {
+                    if (!contextAborted && !ctx.aborted) {
+                        res.cork(() => {
+                            res.end();
+                        });
+                    }
+                });
+            });
+            ctx.responded = true;
+            return;
+        }
+        // --- BRANCH B: NORMAL JSON / TEXT PAYLOAD ---
+        res.cork(() => {
+            this.writeHeaders(ctx);
+            if (typeof body === 'object') {
+                res.writeHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify(body));
+            }
+            else if (body) {
+                res.end(String(body));
+            }
+            else {
+                // Default 404 behavior if no body is set
+                res.writeStatus('404 Not Found');
+                res.writeHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: "Not Found", url: ctx.url, method: ctx.method }));
+            }
+        });
+        ctx.responded = true;
+    }
+    compose(middlewares) {
+        return function (ctx, next) {
+            let index = -1;
+            return dispatch(0);
+            function dispatch(i) {
+                if (i <= index)
+                    return Promise.reject(new Error('next() called multiple times'));
+                index = i;
+                let fn = middlewares[i];
+                if (i === middlewares.length)
+                    fn = next; // End of chain
+                if (!fn)
+                    return Promise.resolve();
+                try {
+                    return Promise.resolve(fn(ctx, dispatch.bind(null, i + 1)));
+                }
+                catch (err) {
+                    return Promise.reject(err);
+                }
+            }
+        };
+    }
+}
+exports.Application = Application;

package/dist/core/Container.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export declare class Container {
+    instances: Map<any, any>;
+    resolve<T>(target: any): T;
+}
+export declare const container: Container;

package/dist/core/Container.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.container = exports.Container = void 0;
+require("reflect-metadata");
+const decorators_1 = require("../decorators");
+class Container {
+    instances = new Map();
+    resolve(target) {
+        // Find if target has been marked as injectable (explicitly or via Controller)
+        const isInjectable = Reflect.getMetadata(decorators_1.INJECTABLE_METADATA, target) || target.name !== 'Object';
+        if (!isInjectable) {
+            throw new Error(`Cannot resolve ${target.name || target}. Make sure it has @Injectable() or @Controller() decorator.`);
+        }
+        // Return singleton if already instantiated
+        if (this.instances.has(target)) {
+            return this.instances.get(target);
+        }
+        // Check constructor dependencies
+        const tokens = Reflect.getMetadata('design:paramtypes', target) || [];
+        let injections = [];
+        if (tokens.length > 0) {
+            injections = tokens.map((token) => {
+                // Circular dependency or undefined typescript output guard
+                if (!token || token === target) {
+                    throw new Error(`Failed to resolve dependencies for ${target.name}. Circular dependency detected or bad type.`);
+                }
+                return this.resolve(token);
+            });
+        }
+        // Instantiate
+        const instance = new target(...injections);
+        this.instances.set(target, instance);
+        return instance;
+    }
+}
+exports.Container = Container;
+exports.container = new Container();

package/dist/core/Context.d.ts

@@ -0,0 +1,27 @@
+export type Next = () => Promise<void>;
+export type Middleware<TContext extends BaseContext = BaseContext> = (ctx: TContext, next: Next) => Promise<void>;
+import { HttpRequest, HttpResponse } from 'uWebSockets.js';
+export declare class BaseContext {
+    req: HttpRequest;
+    res: HttpResponse;
+    aborted: boolean;
+    responded: boolean;
+    method: string;
+    url: string;
+    query: string;
+    headers: Record<string, string>;
+    params: Record<string, string>;
+    body: any;
+    status: number;
+    responseHeaders: Record<string, string | string[]>;
+    _filePath?: string;
+    private bodyPromise;
+    constructor(res: HttpResponse, req: HttpRequest);
+    json(): Promise<any>;
+    text(): Promise<string>;
+    private _parsedQuery?;
+    get queries(): Record<string, string>;
+    throw(status: number, message?: string): never;
+    redirect(url: string, status?: number): void;
+    sendFile(path: string): void;
+}

package/dist/core/Context.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+class BaseContext {
+    req;
+    res;
+    aborted = false;
+    responded = false; // Tracks if response has been sent to uWebSockets
+    // Request properties
+    method;
+    url;
+    query;
+    headers;
+    params;
+    // Response properties
+    body;
+    status = 200;
+    responseHeaders = {};
+    // File streaming properties
+    _filePath;
+    bodyPromise;
+    constructor(res, req) {
+        this.res = res;
+        this.req = req;
+        this.method = req.getMethod().toUpperCase();
+        this.url = req.getUrl();
+        // query params
+        this.query = req.getQuery();
+        this.headers = {};
+        req.forEach((k, v) => {
+            this.headers[k] = v;
+        });
+        this.params = {};
+        // Important: Handle abort
+        res.onAborted(() => {
+            this.aborted = true;
+        });
+        // Check if we expect a body
+        const contentLength = this.headers['content-length'];
+        const transferEncoding = this.headers['transfer-encoding'];
+        const hasBody = (contentLength && parseInt(contentLength) > 0) || (transferEncoding && transferEncoding.includes('chunked'));
+        if (hasBody) {
+            this.bodyPromise = new Promise((resolve, reject) => {
+                let buffer;
+                res.onData((chunk, isLast) => {
+                    const chunkBuffer = Buffer.from(chunk);
+                    if (isLast) {
+                        if (buffer) {
+                            resolve(Buffer.concat([buffer, chunkBuffer]));
+                        }
+                        else {
+                            resolve(chunkBuffer);
+                        }
+                    }
+                    else {
+                        if (buffer) {
+                            buffer = Buffer.concat([buffer, chunkBuffer]);
+                        }
+                        else {
+                            buffer = Buffer.concat([chunkBuffer]);
+                        }
+                    }
+                });
+            });
+        }
+        else {
+            this.bodyPromise = Promise.resolve(Buffer.alloc(0));
+        }
+    }
+    // Helper to read body (async because we might need to buffer)
+    async json() {
+        const buffer = await this.bodyPromise;
+        if (!buffer || buffer.length === 0)
+            return {};
+        try {
+            return JSON.parse(buffer.toString());
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    async text() {
+        const buffer = await this.bodyPromise;
+        return buffer ? buffer.toString() : '';
+    }
+    // Lazy initialization for query parameters
+    _parsedQuery;
+    get queries() {
+        if (!this._parsedQuery) {
+            this._parsedQuery = {};
+            if (this.query) {
+                const searchParams = new URLSearchParams(this.query);
+                for (const [key, value] of searchParams.entries()) {
+                    this._parsedQuery[key] = value;
+                }
+            }
+        }
+        return this._parsedQuery;
+    }
+    throw(status, message) {
+        this.status = status;
+        throw new Error(message || `Error ${status}`);
+    }
+    redirect(url, status = 302) {
+        this.status = status;
+        this.responseHeaders['Location'] = url;
+        this.body = '';
+    }
+    sendFile(path) {
+        this._filePath = path;
+    }
+}
+exports.BaseContext = BaseContext;

package/dist/core/Router.d.ts

@@ -0,0 +1,13 @@
+import { Middleware } from './Context';
+import { Application } from './Application';
+export declare class Router {
+    private app;
+    private routes;
+    constructor(app: Application);
+    register(controllers: any[]): void;
+    private registerWs;
+    private compose;
+    private pathToRegexp;
+    middleware(): Middleware;
+    private findRoute;
+}

package/dist/core/Router.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const decorators_1 = require("../decorators");
+const WsContext_1 = require("./WsContext");
+const validation_1 = require("../validation");
+const Container_1 = require("./Container");
+class Router {
+    app;
+    routes = [];
+    constructor(app) {
+        this.app = app;
+    }
+    register(controllers) {
+        console.log("HELLO FROM ROUTER REGISTER");
+        controllers.forEach(controllerClass => {
+            // Instantiate securely with DI Container!
+            const instance = Container_1.container.resolve(controllerClass);
+            // Check if this is a WebSocket Controller
+            const wsPrefix = Reflect.getMetadata(decorators_1.WS_CONTROLLER_METADATA, controllerClass);
+            if (wsPrefix !== undefined) {
+                this.registerWs(wsPrefix, controllerClass, instance);
+                return; // Skip normal HTTP routing
+            }
+            const prefix = Reflect.getMetadata(decorators_1.CONTROLLER_METADATA, controllerClass);
+            const routes = Reflect.getMetadata(decorators_1.ROUTE_METADATA, controllerClass);
+            const controllerMiddlewares = Reflect.getMetadata(decorators_1.MIDDLEWARE_METADATA, controllerClass) || [];
+            if (!routes)
+                return;
+            routes.forEach(route => {
+                const fullPath = (prefix + route.path).replace(/\/+/g, '/');
+                // Convert path to regex /users/:id -> /^\/users\/([^/]+)$/
+                const { re, keys } = this.pathToRegexp(fullPath);
+                const routeMiddlewares = Reflect.getMetadata(decorators_1.MIDDLEWARE_METADATA, controllerClass.prototype, route.methodName) || [];
+                const paramsMetadata = Reflect.getOwnMetadata(decorators_1.PARAM_METADATA, controllerClass.prototype, route.methodName) || [];
+                // Compose: Controller Middlewares -> Route Middlewares -> Handler
+                const allMiddlewares = [...controllerMiddlewares, ...routeMiddlewares];
+                console.log(`Registering route: ${route.method.toUpperCase()} ${fullPath} -> regex: ${re}`);
+                this.routes.push({
+                    method: route.method.toUpperCase(),
+                    path: re,
+                    paramNames: keys,
+                    handler: async (ctx) => {
+                        const handler = instance[route.methodName].bind(instance);
+                        console.log("Handler loaded for", route.methodName);
+                        // Create a mini-chain for this route
+                        const chain = [...allMiddlewares, async (ctx, next) => {
+                                let args = [ctx]; // Default backwards-compatible fallback array
+                                // If parameter decorators are used, we switch into reflection injection mode
+                                if (paramsMetadata.length > 0) {
+                                    const maxIndex = Math.max(...paramsMetadata.map(p => p.index));
+                                    args = new Array(maxIndex + 1).fill(undefined);
+                                    const hasBody = paramsMetadata.some(p => p.type === 'body');
+                                    let bodyData = null;
+                                    if (hasBody) {
+                                        bodyData = await ctx.json();
+                                    }
+                                    for (const meta of paramsMetadata) {
+                                        let value;
+                                        switch (meta.type) {
+                                            case 'ctx':
+                                                value = ctx;
+                                                break;
+                                            case 'param':
+                                                value = meta.name ? ctx.params[meta.name] : ctx.params;
+                                                break;
+                                            case 'query':
+                                                value = meta.name ? ctx.queries[meta.name] : ctx.queries;
+                                                break;
+                                            case 'body':
+                                                value = meta.name ? (bodyData ? bodyData[meta.name] : undefined) : bodyData;
+                                                break;
+                                        }
+                                        // Simple auto-casting for strongly typed metadata via typescript design:paramtypes
+                                        if (value !== undefined && meta.designType) {
+                                            if (meta.designType === Number) {
+                                                const parsed = Number(value);
+                                                if (isNaN(parsed))
+                                                    throw new validation_1.ValidationError([`Parameter '${meta.name}' must be a number`]);
+                                                value = parsed;
+                                            }
+                                            else if (meta.designType === Boolean) {
+                                                value = value === 'true' || value === '1' || value === true;
+                                            }
+                                            else if (meta.designType === String) {
+                                                value = String(value);
+                                            }
+                                            else if (meta.designType.name !== 'Object' && meta.designType.name !== 'Array') {
+                                                // It's a potential DTO class! Execute native Validation layer
+                                                value = (0, validation_1.validateDTO)(meta.designType, value);
+                                            }
+                                        }
+                                        else if (value === undefined && meta.designType && meta.designType.name !== 'Object' && meta.designType.name !== 'String' && meta.designType.name !== 'Number' && meta.designType.name !== 'Boolean') {
+                                            // Body was undefined/null, let validation engine check if @IsRequired complains!
+                                            value = (0, validation_1.validateDTO)(meta.designType, {});
+                                        }
+                                        args[meta.index] = value;
+                                    }
+                                }
+                                // Execute handler with injected args (passing undefined will trigger ES6 default arguments)
+                                const result = await handler(...args);
+                                console.log("Handler returned:", result);
+                                if (result !== undefined) {
+                                    ctx.body = result;
+                                }
+                            }];
+                        const composed = this.compose(chain);
+                        await composed(ctx);
+                    }
+                });
+            });
+        });
+    }
+    registerWs(prefix, controllerClass, instance) {
+        const fullPath = prefix.replace(/\/+/g, '/');
+        const openMethod = Reflect.getMetadata(decorators_1.WS_ON_OPEN_METADATA, controllerClass);
+        const messageMethod = Reflect.getMetadata(decorators_1.WS_ON_MESSAGE_METADATA, controllerClass);
+        const closeMethod = Reflect.getMetadata(decorators_1.WS_ON_CLOSE_METADATA, controllerClass);
+        const drainMethod = Reflect.getMetadata(decorators_1.WS_ON_DRAIN_METADATA, controllerClass);
+        console.log(`Registering WS route: ${fullPath}`);
+        this.app.registerWsRoute(fullPath, {
+            idleTimeout: 32,
+            maxBackpressure: 1024 * 1024 * 10,
+            maxPayloadLength: 1024 * 1024 * 16,
+            upgrade: (res, req, context) => {
+                // Must read req here safely because req is invalidated outside
+                const url = req.getUrl();
+                const queryStr = req.getQuery();
+                // Extremely simple query parser
+                const query = {};
+                if (queryStr) {
+                    queryStr.split('&').forEach((pair) => {
+                        const [k, v] = pair.split('=');
+                        query[k] = decodeURIComponent(v || '');
+                    });
+                }
+                res.upgrade({ url, query }, req.getHeader('sec-websocket-key'), req.getHeader('sec-websocket-protocol'), req.getHeader('sec-websocket-extensions'), context);
+            },
+            open: (ws) => {
+                const ctx = new WsContext_1.WsContext(ws);
+                ws.customCtx = ctx;
+                if (openMethod) {
+                    instance[openMethod](ctx);
+                }
+            },
+            message: (ws, message, isBinary) => {
+                if (messageMethod) {
+                    let data = message;
+                    if (!isBinary && message instanceof ArrayBuffer) {
+                        data = Buffer.from(message).toString('utf8');
+                    }
+                    instance[messageMethod](ws.customCtx, data, isBinary);
+                }
+            },
+            close: (ws, code, message) => {
+                if (closeMethod) {
+                    instance[closeMethod](ws.customCtx, code, message);
+                }
+            },
+            drain: (ws) => {
+                if (drainMethod) {
+                    instance[drainMethod](ws.customCtx);
+                }
+            }
+        });
+    }
+    // Helper to compose middlewares (similar to Application.compose but specific for this scope if needed)
+    // Actually we can reuse or duplicate it. Let's duplicate for simplicity to keep Router standalone.
+    compose(middlewares) {
+        return function (ctx, next) {
+            let index = -1;
+            return dispatch(0);
+            function dispatch(i) {
+                if (i <= index)
+                    return Promise.reject(new Error('next() called multiple times'));
+                index = i;
+                let fn = middlewares[i];
+                if (i === middlewares.length)
+                    fn = next;
+                if (!fn)
+                    return Promise.resolve();
+                try {
+                    return Promise.resolve(fn(ctx, dispatch.bind(null, i + 1)));
+                }
+                catch (err) {
+                    return Promise.reject(err);
+                }
+            }
+        };
+    }
+    pathToRegexp(path) {
+        const keys = [];
+        // Escape special chars except :
+        let pattern = path.replace(/([.+*?^$(){}|[\]\\])/g, '\\$1');
+        // Replace :param with capture group
+        pattern = pattern.replace(/:(\w+)/g, (_, key) => {
+            keys.push(key);
+            return '([^/]+)';
+        });
+        // Add start/end anchors
+        return { re: new RegExp(`^${pattern}$`), keys };
+    }
+    middleware() {
+        return async (ctx, next) => {
+            // Find matching route
+            const matched = this.findRoute(ctx.method, ctx.url);
+            if (matched) {
+                console.log(`Route matched: ${ctx.method} ${ctx.url}`);
+                ctx.params = matched.params;
+                await matched.handler(ctx);
+            }
+            else {
+                console.log(`No route matched for: ${ctx.method} ${ctx.url}`);
+                await next();
+            }
+        };
+    }
+    findRoute(method, url) {
+        for (const route of this.routes) {
+            // console.log(`Checking route: ${route.method} ${route.path} vs ${method} ${url}`);
+            if (route.method !== method && route.method !== 'ANY')
+                continue;
+            const match = route.path.exec(url); // url in uWS does not include query string
+            if (match) {
+                const params = {};
+                route.paramNames.forEach((name, index) => {
+                    params[name] = decodeURIComponent(match[index + 1] || '');
+                });
+                return { handler: route.handler, params };
+            }
+        }
+        return null;
+    }
+}
+exports.Router = Router;

package/dist/core/WsContext.d.ts

@@ -0,0 +1,32 @@
+import { WebSocket } from 'uWebSockets.js';
+export declare class WsContext {
+    private readonly ws;
+    data: Record<string, any>;
+    query: Record<string, string>;
+    url: string;
+    constructor(ws: WebSocket<any>);
+    /**
+     * Extremely fast corked C++ network send
+     */
+    send(message: string | ArrayBuffer, isBinary?: boolean): boolean;
+    /**
+     * Subscribe to a High-Performance C++ Pub/Sub topic
+     */
+    subscribe(topic: string): boolean;
+    /**
+     * Unsubscribe from a topic
+     */
+    unsubscribe(topic: string): boolean;
+    /**
+     * Broadcast to all sockets subscribed to this topic globally.
+     */
+    publish(topic: string, message: string | ArrayBuffer, isBinary?: boolean): boolean;
+    /**
+     * Close the connection securely
+     */
+    close(code?: number, shortMessage?: string | ArrayBuffer): void;
+    /**
+     * Extract Player IP
+     */
+    getRemoteAddressAsText(): string;
+}

package/dist/core/WsContext.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsContext = void 0;
+class WsContext {
+    ws;
+    data = {};
+    query = {};
+    url = '';
+    constructor(ws) {
+        this.ws = ws;
+        // Retrieve custom data injected during Upgrade
+        const userData = ws.getUserData();
+        if (userData) {
+            this.url = userData.url || '';
+            this.query = userData.query || {};
+            // Copy everything else so businesses can use it
+            Object.assign(this.data, userData);
+        }
+    }
+    /**
+     * Extremely fast corked C++ network send
+     */
+    send(message, isBinary = false) {
+        let result = false;
+        // Wrapped in cork to prevent socket chunk fragmentation warning during concurrent IO
+        this.ws.cork(() => {
+            // Returns: 0 = Backpressure | 1 = Success | 2 = Dropped Max Connections
+            result = this.ws.send(message, isBinary, false) === 1;
+        });
+        return result;
+    }
+    /**
+     * Subscribe to a High-Performance C++ Pub/Sub topic
+     */
+    subscribe(topic) {
+        return this.ws.subscribe(topic);
+    }
+    /**
+     * Unsubscribe from a topic
+     */
+    unsubscribe(topic) {
+        return this.ws.unsubscribe(topic);
+    }
+    /**
+     * Broadcast to all sockets subscribed to this topic globally.
+     */
+    publish(topic, message, isBinary = false) {
+        let result = false;
+        try {
+            // C++ underlying publish. If the socket is detached during @OnClose this will throw.
+            // Safely swallow here so Node doesn't crash from wild user attempts.
+            this.ws.cork(() => {
+                result = this.ws.publish(topic, message, isBinary);
+            });
+        }
+        catch (e) {
+            console.warn('[WsContext] Local socket publish failed (likely closed). Use Application.publish for global broadcasts.');
+        }
+        return result;
+    }
+    /**
+     * Close the connection securely
+     */
+    close(code, shortMessage) {
+        if (code) {
+            this.ws.end(code, shortMessage);
+        }
+        else {
+            this.ws.close();
+        }
+    }
+    /**
+     * Extract Player IP
+     */
+    getRemoteAddressAsText() {
+        try {
+            const buffer = this.ws.getRemoteAddressAsText();
+            return Buffer.from(buffer).toString('utf-8');
+        }
+        catch (e) {
+            return 'Unknown';
+        }
+    }
+}
+exports.WsContext = WsContext;

package/dist/decorators/index.d.ts

@@ -0,0 +1,41 @@
+import 'reflect-metadata';
+export declare const CONTROLLER_METADATA = "CONTROLLER_METADATA";
+export declare const ROUTE_METADATA = "ROUTE_METADATA";
+export declare const INJECTABLE_METADATA = "INJECTABLE_METADATA";
+export declare function Injectable(): ClassDecorator;
+export declare function Controller(prefix?: string): ClassDecorator;
+export interface RouteDefinition {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+    methodName: string | symbol;
+}
+export declare const MIDDLEWARE_METADATA = "MIDDLEWARE_METADATA";
+export declare function Use(...middlewares: Function[]): ClassDecorator & MethodDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+export declare const Head: (path?: string) => MethodDecorator;
+export declare const Options: (path?: string) => MethodDecorator;
+export declare const PARAM_METADATA = "PARAM_METADATA";
+export interface ParamDefinition {
+    index: number;
+    type: 'param' | 'query' | 'body' | 'ctx';
+    name?: string;
+    designType?: any;
+}
+export declare const Param: (name?: string) => ParameterDecorator;
+export declare const Query: (name?: string) => ParameterDecorator;
+export declare const Body: (name?: string) => ParameterDecorator;
+export declare const Ctx: () => ParameterDecorator;
+export declare const WS_CONTROLLER_METADATA = "WS_CONTROLLER_METADATA";
+export declare const WS_ON_OPEN_METADATA = "WS_ON_OPEN_METADATA";
+export declare const WS_ON_MESSAGE_METADATA = "WS_ON_MESSAGE_METADATA";
+export declare const WS_ON_CLOSE_METADATA = "WS_ON_CLOSE_METADATA";
+export declare const WS_ON_DRAIN_METADATA = "WS_ON_DRAIN_METADATA";
+export declare function WebSocketController(path?: string): ClassDecorator;
+export declare const OnOpen: () => MethodDecorator;
+export declare const OnMessage: () => MethodDecorator;
+export declare const OnClose: () => MethodDecorator;
+export declare const OnDrain: () => MethodDecorator;

package/dist/decorators/index.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnDrain = exports.OnClose = exports.OnMessage = exports.OnOpen = exports.WS_ON_DRAIN_METADATA = exports.WS_ON_CLOSE_METADATA = exports.WS_ON_MESSAGE_METADATA = exports.WS_ON_OPEN_METADATA = exports.WS_CONTROLLER_METADATA = exports.Ctx = exports.Body = exports.Query = exports.Param = exports.PARAM_METADATA = exports.Options = exports.Head = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.MIDDLEWARE_METADATA = exports.INJECTABLE_METADATA = exports.ROUTE_METADATA = exports.CONTROLLER_METADATA = void 0;
+exports.Injectable = Injectable;
+exports.Controller = Controller;
+exports.Use = Use;
+exports.WebSocketController = WebSocketController;
+require("reflect-metadata");
+exports.CONTROLLER_METADATA = 'CONTROLLER_METADATA';
+exports.ROUTE_METADATA = 'ROUTE_METADATA';
+exports.INJECTABLE_METADATA = 'INJECTABLE_METADATA';
+function Injectable() {
+    return (target) => {
+        Reflect.defineMetadata(exports.INJECTABLE_METADATA, true, target);
+    };
+}
+function Controller(prefix = '') {
+    return (target) => {
+        Reflect.defineMetadata(exports.CONTROLLER_METADATA, prefix, target);
+        // Controllers are automatically considered injectable
+        Reflect.defineMetadata(exports.INJECTABLE_METADATA, true, target);
+    };
+}
+function createRouteDecorator(method) {
+    return (path = '/') => {
+        return (target, propertyKey, descriptor) => {
+            console.log(`@${method} called for ${String(propertyKey)}`);
+            if (!Reflect.hasMetadata(exports.ROUTE_METADATA, target.constructor)) {
+                Reflect.defineMetadata(exports.ROUTE_METADATA, [], target.constructor);
+            }
+            const routes = Reflect.getMetadata(exports.ROUTE_METADATA, target.constructor);
+            routes.push({
+                method: method,
+                path,
+                methodName: propertyKey,
+            });
+            Reflect.defineMetadata(exports.ROUTE_METADATA, routes, target.constructor);
+        };
+    };
+}
+exports.MIDDLEWARE_METADATA = 'MIDDLEWARE_METADATA';
+function Use(...middlewares) {
+    return (target, propertyKey, descriptor) => {
+        try {
+            console.log(`@Use called for ${String(propertyKey || target.name)}`);
+            if (propertyKey) {
+                // Method decorator
+                // target is prototype for instance members
+                if (!Reflect.hasMetadata(exports.MIDDLEWARE_METADATA, target, propertyKey)) {
+                    Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [], target, propertyKey);
+                }
+                const existing = Reflect.getMetadata(exports.MIDDLEWARE_METADATA, target, propertyKey);
+                Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [...existing, ...middlewares], target, propertyKey);
+            }
+            else {
+                // Class decorator
+                if (!Reflect.hasMetadata(exports.MIDDLEWARE_METADATA, target)) {
+                    Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [], target);
+                }
+                const existing = Reflect.getMetadata(exports.MIDDLEWARE_METADATA, target);
+                Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [...existing, ...middlewares], target);
+            }
+        }
+        catch (e) {
+            console.error(`Error in @Use decorator:`, e);
+            throw e;
+        }
+    };
+}
+exports.Get = createRouteDecorator('get');
+exports.Post = createRouteDecorator('post');
+exports.Put = createRouteDecorator('put');
+exports.Delete = createRouteDecorator('delete');
+exports.Patch = createRouteDecorator('patch');
+exports.Head = createRouteDecorator('head');
+exports.Options = createRouteDecorator('options');
+exports.PARAM_METADATA = 'PARAM_METADATA';
+function createParamDecorator(type) {
+    return (name) => {
+        return (target, propertyKey, parameterIndex) => {
+            if (!propertyKey)
+                return;
+            const params = Reflect.getOwnMetadata(exports.PARAM_METADATA, target, propertyKey) || [];
+            // Extract the strong type info. "design:paramtypes" is generated by TS when emitDecoratorMetadata is true.
+            const designTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+            const designType = designTypes ? designTypes[parameterIndex] : undefined;
+            params.push({
+                index: parameterIndex,
+                type,
+                name,
+                designType
+            });
+            Reflect.defineMetadata(exports.PARAM_METADATA, params, target, propertyKey);
+        };
+    };
+}
+exports.Param = createParamDecorator('param');
+exports.Query = createParamDecorator('query');
+exports.Body = createParamDecorator('body');
+const Ctx = () => createParamDecorator('ctx')();
+exports.Ctx = Ctx;
+// --- WebSocket Decorators ---
+exports.WS_CONTROLLER_METADATA = 'WS_CONTROLLER_METADATA';
+exports.WS_ON_OPEN_METADATA = 'WS_ON_OPEN_METADATA';
+exports.WS_ON_MESSAGE_METADATA = 'WS_ON_MESSAGE_METADATA';
+exports.WS_ON_CLOSE_METADATA = 'WS_ON_CLOSE_METADATA';
+exports.WS_ON_DRAIN_METADATA = 'WS_ON_DRAIN_METADATA';
+function WebSocketController(path = '/*') {
+    return (target) => {
+        Reflect.defineMetadata(exports.WS_CONTROLLER_METADATA, path, target);
+        // WS Controllers are also injectable
+        Reflect.defineMetadata(exports.INJECTABLE_METADATA, true, target);
+    };
+}
+function createWsMethodDecorator(metadataKey) {
+    return (target, propertyKey) => {
+        Reflect.defineMetadata(metadataKey, propertyKey, target.constructor);
+    };
+}
+const OnOpen = () => createWsMethodDecorator(exports.WS_ON_OPEN_METADATA);
+exports.OnOpen = OnOpen;
+const OnMessage = () => createWsMethodDecorator(exports.WS_ON_MESSAGE_METADATA);
+exports.OnMessage = OnMessage;
+const OnClose = () => createWsMethodDecorator(exports.WS_ON_CLOSE_METADATA);
+exports.OnClose = OnClose;
+const OnDrain = () => createWsMethodDecorator(exports.WS_ON_DRAIN_METADATA);
+exports.OnDrain = OnDrain;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core/Context';
+export * from './core/WsContext';
+export * from './core/Router';
+export * from './core/Application';
+export * from './core/Container';
+export * from './decorators';
+export * from './validation';
+export type { Middleware, Next } from './core/Context';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/Context"), exports);
+__exportStar(require("./core/WsContext"), exports);
+__exportStar(require("./core/Router"), exports);
+__exportStar(require("./core/Application"), exports);
+__exportStar(require("./core/Container"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./validation"), exports);

package/dist/middlewares/cookie.d.ts

@@ -0,0 +1,16 @@
+import { BaseContext, Next } from '../core/Context';
+export interface CookieOptions {
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+declare module '../core/Context' {
+    interface BaseContext {
+        getCookie(name: string): string | undefined;
+        setCookie(name: string, value: string, options?: CookieOptions): void;
+    }
+}
+export declare const cookieMiddleware: () => (ctx: BaseContext, next: Next) => Promise<void>;

package/dist/middlewares/cookie.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookieMiddleware = void 0;
+const cookieMiddleware = () => {
+    return async (ctx, next) => {
+        let parsedCookies;
+        ctx.getCookie = (name) => {
+            if (!parsedCookies) {
+                parsedCookies = {};
+                const cookieHeader = ctx.headers['cookie'];
+                if (cookieHeader) {
+                    cookieHeader.split(';').forEach(c => {
+                        const [k, v] = c.split('=');
+                        if (k && v) {
+                            parsedCookies[k.trim()] = decodeURIComponent(v.trim());
+                        }
+                    });
+                }
+            }
+            return parsedCookies[name];
+        };
+        ctx.setCookie = (name, value, options = {}) => {
+            let cookieStr = `${name}=${encodeURIComponent(value)}`;
+            if (options.maxAge !== undefined)
+                cookieStr += `; Max-Age=${options.maxAge}`;
+            if (options.path)
+                cookieStr += `; Path=${options.path}`;
+            if (options.domain)
+                cookieStr += `; Domain=${options.domain}`;
+            if (options.secure)
+                cookieStr += `; Secure`;
+            if (options.httpOnly)
+                cookieStr += `; HttpOnly`;
+            if (options.sameSite)
+                cookieStr += `; SameSite=${options.sameSite}`;
+            if (!ctx.responseHeaders['Set-Cookie']) {
+                ctx.responseHeaders['Set-Cookie'] = [];
+            }
+            else if (typeof ctx.responseHeaders['Set-Cookie'] === 'string') {
+                ctx.responseHeaders['Set-Cookie'] = [ctx.responseHeaders['Set-Cookie']];
+            }
+            ctx.responseHeaders['Set-Cookie'].push(cookieStr);
+        };
+        await next();
+    };
+};
+exports.cookieMiddleware = cookieMiddleware;

package/dist/validation/index.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+export declare const VALIDATION_METADATA_KEY = "VIO:VALIDATION";
+export interface ValidationRule {
+    property: string;
+    type: string;
+    value?: any;
+    message?: string;
+}
+export declare class ValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+export declare function IsRequired(message?: string): PropertyDecorator;
+export declare function IsString(message?: string): PropertyDecorator;
+export declare function IsNumber(message?: string): PropertyDecorator;
+export declare function IsInt(message?: string): PropertyDecorator;
+export declare function IsBoolean(message?: string): PropertyDecorator;
+export declare function Min(val: number, message?: string): PropertyDecorator;
+export declare function Max(val: number, message?: string): PropertyDecorator;
+export declare function validateDTO(dtoClass: any, plainObject: any): any;

package/dist/validation/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.VALIDATION_METADATA_KEY = void 0;
+exports.IsRequired = IsRequired;
+exports.IsString = IsString;
+exports.IsNumber = IsNumber;
+exports.IsInt = IsInt;
+exports.IsBoolean = IsBoolean;
+exports.Min = Min;
+exports.Max = Max;
+exports.validateDTO = validateDTO;
+require("reflect-metadata");
+exports.VALIDATION_METADATA_KEY = 'VIO:VALIDATION';
+function addValidationRule(target, propertyKey, rule) {
+    const rules = Reflect.getMetadata(exports.VALIDATION_METADATA_KEY, target.constructor) || [];
+    rules.push({ property: propertyKey, ...rule });
+    Reflect.defineMetadata(exports.VALIDATION_METADATA_KEY, rules, target.constructor);
+}
+// Validation Error Exception class
+class ValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(errors.join(' | ')); // Joined by pipe for error message output
+        this.errors = errors;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+// Built-in Validation Property Decorators
+function IsRequired(message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'required', message });
+}
+function IsString(message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'string', message });
+}
+function IsNumber(message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'number', message });
+}
+function IsInt(message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'int', message });
+}
+function IsBoolean(message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'boolean', message });
+}
+function Min(val, message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'min', value: val, message });
+}
+function Max(val, message) {
+    return (target, propertyKey) => addValidationRule(target, propertyKey, { type: 'max', value: val, message });
+}
+// High performance native DTO Validator Engine
+function validateDTO(dtoClass, plainObject) {
+    const rules = Reflect.getMetadata(exports.VALIDATION_METADATA_KEY, dtoClass) || [];
+    // No decorators, immediately return transparent wrapper
+    if (rules.length === 0) {
+        if (plainObject && typeof plainObject === 'object') {
+            const temp = new dtoClass();
+            Object.assign(temp, plainObject);
+            return temp;
+        }
+        return plainObject;
+    }
+    const errors = [];
+    const instance = new dtoClass();
+    // Copy arbitrary fields ignoring safety for now to support nested objects
+    if (plainObject && typeof plainObject === 'object') {
+        Object.assign(instance, plainObject);
+    }
+    for (const rule of rules) {
+        const val = instance[rule.property];
+        const isMissing = (val === undefined || val === null || val === '');
+        if (rule.type === 'required' && isMissing) {
+            errors.push(rule.message || `Parameter [${rule.property}] is required.`);
+            continue;
+        }
+        if (!isMissing) {
+            if (rule.type === 'string' && typeof val !== 'string') {
+                errors.push(rule.message || `Parameter [${rule.property}] must be a valid string.`);
+            }
+            else if (rule.type === 'number') {
+                const num = Number(val);
+                if (isNaN(num))
+                    errors.push(rule.message || `Parameter [${rule.property}] must be a number.`);
+                else
+                    instance[rule.property] = num;
+            }
+            else if (rule.type === 'int') {
+                const num = Number(val);
+                if (isNaN(num) || !Number.isInteger(num))
+                    errors.push(rule.message || `Parameter [${rule.property}] must be an integer.`);
+                else
+                    instance[rule.property] = num;
+            }
+            else if (rule.type === 'boolean') {
+                if (val !== 'true' && val !== 'false' && val !== true && val !== false && val !== 1 && val !== 0 && val !== '1' && val !== '0') {
+                    errors.push(rule.message || `Parameter [${rule.property}] must be a boolean.`);
+                }
+                else
+                    instance[rule.property] = (val === 'true' || val === '1' || val === true || val === 1);
+            }
+            else if (rule.type === 'min') {
+                if (Number(val) < rule.value)
+                    errors.push(rule.message || `Parameter [${rule.property}] must be >= ${rule.value}.`);
+            }
+            else if (rule.type === 'max') {
+                if (Number(val) > rule.value)
+                    errors.push(rule.message || `Parameter [${rule.property}] must be <= ${rule.value}.`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw new ValidationError(errors);
+    }
+    return instance; // Cleanly parsed and casted Data Transfer Object (DTO)
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "viojs-core",
+  "version": "1.0.0",
+  "description": "Core functionality for vio framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "mime-types": "^3.0.2",
+    "reflect-metadata": "^0.2.1",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.58.0"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.15.11",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^20.11.19",
+    "tsup": "^8.5.1",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.2.1"
+  }
+}