vector-framework 0.9.6 → 0.9.8

package/dist/cli.js

@@ -28,210 +28,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/auth/protected.ts
-class AuthManager {
-  protectedHandler = null;
-  setProtectedHandler(handler) {
-    this.protectedHandler = handler;
-  }
-  async authenticate(request) {
-    if (!this.protectedHandler) {
-      throw new Error("Protected handler not configured. Use vector.protected() to set authentication handler.");
-    }
-    try {
-      const authUser = await this.protectedHandler(request);
-      request.authUser = authUser;
-      return authUser;
-    } catch (error) {
-      throw new Error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  isAuthenticated(request) {
-    return !!request.authUser;
-  }
-  getUser(request) {
-    return request.authUser || null;
-  }
-}
-
-// src/constants/index.ts
-var HTTP_STATUS, DEFAULT_CONFIG, CONTENT_TYPES;
-var init_constants = __esm(() => {
-  HTTP_STATUS = {
-    OK: 200,
-    CREATED: 201,
-    ACCEPTED: 202,
-    NON_AUTHORITATIVE_INFORMATION: 203,
-    NO_CONTENT: 204,
-    RESET_CONTENT: 205,
-    PARTIAL_CONTENT: 206,
-    MULTI_STATUS: 207,
-    ALREADY_REPORTED: 208,
-    IM_USED: 226,
-    MULTIPLE_CHOICES: 300,
-    MOVED_PERMANENTLY: 301,
-    FOUND: 302,
-    SEE_OTHER: 303,
-    NOT_MODIFIED: 304,
-    USE_PROXY: 305,
-    TEMPORARY_REDIRECT: 307,
-    PERMANENT_REDIRECT: 308,
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    PAYMENT_REQUIRED: 402,
-    FORBIDDEN: 403,
-    NOT_FOUND: 404,
-    METHOD_NOT_ALLOWED: 405,
-    NOT_ACCEPTABLE: 406,
-    PROXY_AUTHENTICATION_REQUIRED: 407,
-    REQUEST_TIMEOUT: 408,
-    CONFLICT: 409,
-    GONE: 410,
-    LENGTH_REQUIRED: 411,
-    PRECONDITION_FAILED: 412,
-    PAYLOAD_TOO_LARGE: 413,
-    URI_TOO_LONG: 414,
-    UNSUPPORTED_MEDIA_TYPE: 415,
-    RANGE_NOT_SATISFIABLE: 416,
-    EXPECTATION_FAILED: 417,
-    IM_A_TEAPOT: 418,
-    MISDIRECTED_REQUEST: 421,
-    UNPROCESSABLE_ENTITY: 422,
-    LOCKED: 423,
-    FAILED_DEPENDENCY: 424,
-    TOO_EARLY: 425,
-    UPGRADE_REQUIRED: 426,
-    PRECONDITION_REQUIRED: 428,
-    TOO_MANY_REQUESTS: 429,
-    REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-    UNAVAILABLE_FOR_LEGAL_REASONS: 451,
-    INTERNAL_SERVER_ERROR: 500,
-    NOT_IMPLEMENTED: 501,
-    BAD_GATEWAY: 502,
-    SERVICE_UNAVAILABLE: 503,
-    GATEWAY_TIMEOUT: 504,
-    HTTP_VERSION_NOT_SUPPORTED: 505,
-    VARIANT_ALSO_NEGOTIATES: 506,
-    INSUFFICIENT_STORAGE: 507,
-    LOOP_DETECTED: 508,
-    NOT_EXTENDED: 510,
-    NETWORK_AUTHENTICATION_REQUIRED: 511
-  };
-  DEFAULT_CONFIG = {
-    PORT: 3000,
-    HOSTNAME: "localhost",
-    ROUTES_DIR: "./routes",
-    CACHE_TTL: 0,
-    CORS_MAX_AGE: 86400
-  };
-  CONTENT_TYPES = {
-    JSON: "application/json",
-    TEXT: "text/plain",
-    HTML: "text/html",
-    FORM_URLENCODED: "application/x-www-form-urlencoded",
-    MULTIPART: "multipart/form-data"
-  };
-});
-
-// src/cache/manager.ts
-class CacheManager {
-  cacheHandler = null;
-  memoryCache = new Map;
-  cleanupInterval = null;
-  setCacheHandler(handler) {
-    this.cacheHandler = handler;
-  }
-  async get(key, factory, ttl = DEFAULT_CONFIG.CACHE_TTL) {
-    if (ttl <= 0) {
-      return factory();
-    }
-    if (this.cacheHandler) {
-      return this.cacheHandler(key, factory, ttl);
-    }
-    return this.getFromMemoryCache(key, factory, ttl);
-  }
-  async getFromMemoryCache(key, factory, ttl) {
-    const now = Date.now();
-    const cached = this.memoryCache.get(key);
-    if (this.isCacheValid(cached, now)) {
-      return cached.value;
-    }
-    const value = await factory();
-    this.setInMemoryCache(key, value, ttl);
-    return value;
-  }
-  isCacheValid(entry, now) {
-    return entry !== undefined && entry.expires > now;
-  }
-  setInMemoryCache(key, value, ttl) {
-    const expires = Date.now() + ttl * 1000;
-    this.memoryCache.set(key, { value, expires });
-    this.scheduleCleanup();
-  }
-  scheduleCleanup() {
-    if (this.cleanupInterval)
-      return;
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupExpired();
-    }, 60000);
-  }
-  cleanupExpired() {
-    const now = Date.now();
-    for (const [key, entry] of this.memoryCache.entries()) {
-      if (entry.expires <= now) {
-        this.memoryCache.delete(key);
-      }
-    }
-    if (this.memoryCache.size === 0 && this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-  clear() {
-    this.memoryCache.clear();
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-  async set(key, value, ttl = DEFAULT_CONFIG.CACHE_TTL) {
-    if (ttl <= 0) {
-      return;
-    }
-    if (this.cacheHandler) {
-      await this.cacheHandler(key, async () => value, ttl);
-      return;
-    }
-    this.setInMemoryCache(key, value, ttl);
-  }
-  delete(key) {
-    return this.memoryCache.delete(key);
-  }
-  has(key) {
-    const entry = this.memoryCache.get(key);
-    if (!entry)
-      return false;
-    if (entry.expires <= Date.now()) {
-      this.memoryCache.delete(key);
-      return false;
-    }
-    return true;
-  }
-  generateKey(request, options) {
-    const url = new URL(request.url);
-    const parts = [
-      request.method,
-      url.pathname,
-      url.search,
-      options?.authUser?.id || "anonymous"
-    ];
-    return parts.join(":");
-  }
-}
-var init_manager = __esm(() => {
-  init_constants();
-});
-
 // src/dev/route-generator.ts
 var exports_route_generator = {};
 __export(exports_route_generator, {
@@ -410,6 +206,212 @@ class RouteScanner {
 }
 var init_route_scanner = () => {};
 
+// src/cli/index.ts
+import { watch } from "fs";
+import { parseArgs } from "util";
+
+// src/auth/protected.ts
+class AuthManager {
+  protectedHandler = null;
+  setProtectedHandler(handler) {
+    this.protectedHandler = handler;
+  }
+  async authenticate(request) {
+    if (!this.protectedHandler) {
+      throw new Error("Protected handler not configured. Use vector.protected() to set authentication handler.");
+    }
+    try {
+      const authUser = await this.protectedHandler(request);
+      request.authUser = authUser;
+      return authUser;
+    } catch (error) {
+      throw new Error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  isAuthenticated(request) {
+    return !!request.authUser;
+  }
+  getUser(request) {
+    return request.authUser || null;
+  }
+}
+
+// src/constants/index.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+var DEFAULT_CONFIG = {
+  PORT: 3000,
+  HOSTNAME: "localhost",
+  ROUTES_DIR: "./routes",
+  CACHE_TTL: 0,
+  CORS_MAX_AGE: 86400
+};
+var CONTENT_TYPES = {
+  JSON: "application/json",
+  TEXT: "text/plain",
+  HTML: "text/html",
+  FORM_URLENCODED: "application/x-www-form-urlencoded",
+  MULTIPART: "multipart/form-data"
+};
+
+// src/cache/manager.ts
+class CacheManager {
+  cacheHandler = null;
+  memoryCache = new Map;
+  cleanupInterval = null;
+  setCacheHandler(handler) {
+    this.cacheHandler = handler;
+  }
+  async get(key, factory, ttl = DEFAULT_CONFIG.CACHE_TTL) {
+    if (ttl <= 0) {
+      return factory();
+    }
+    if (this.cacheHandler) {
+      return this.cacheHandler(key, factory, ttl);
+    }
+    return this.getFromMemoryCache(key, factory, ttl);
+  }
+  async getFromMemoryCache(key, factory, ttl) {
+    const now = Date.now();
+    const cached = this.memoryCache.get(key);
+    if (this.isCacheValid(cached, now)) {
+      return cached.value;
+    }
+    const value = await factory();
+    this.setInMemoryCache(key, value, ttl);
+    return value;
+  }
+  isCacheValid(entry, now) {
+    return entry !== undefined && entry.expires > now;
+  }
+  setInMemoryCache(key, value, ttl) {
+    const expires = Date.now() + ttl * 1000;
+    this.memoryCache.set(key, { value, expires });
+    this.scheduleCleanup();
+  }
+  scheduleCleanup() {
+    if (this.cleanupInterval)
+      return;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired();
+    }, 60000);
+  }
+  cleanupExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.memoryCache.entries()) {
+      if (entry.expires <= now) {
+        this.memoryCache.delete(key);
+      }
+    }
+    if (this.memoryCache.size === 0 && this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  clear() {
+    this.memoryCache.clear();
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  async set(key, value, ttl = DEFAULT_CONFIG.CACHE_TTL) {
+    if (ttl <= 0) {
+      return;
+    }
+    if (this.cacheHandler) {
+      await this.cacheHandler(key, async () => value, ttl);
+      return;
+    }
+    this.setInMemoryCache(key, value, ttl);
+  }
+  delete(key) {
+    return this.memoryCache.delete(key);
+  }
+  has(key) {
+    const entry = this.memoryCache.get(key);
+    if (!entry)
+      return false;
+    if (entry.expires <= Date.now()) {
+      this.memoryCache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  generateKey(request, options) {
+    const url = new URL(request.url);
+    const parts = [
+      request.method,
+      url.pathname,
+      url.search,
+      options?.authUser?.id || "anonymous"
+    ];
+    return parts.join(":");
+  }
+}
+
+// src/core/vector.ts
+init_route_generator();
+init_route_scanner();
+
 // src/middleware/manager.ts
 class MiddlewareManager {
   beforeHandlers = [];
@@ -461,7 +463,17 @@ var r = (e = "text/plain; charset=utf-8", t) => (r2, o = {}) => {
     return r2;
   const a = new Response(t?.(r2) ?? r2, o.url ? undefined : o);
   return a.headers.set("content-type", e), a;
-}, o, p, f, u, h, g, y = (e = {}) => {
+};
+var o = r("application/json; charset=utf-8", JSON.stringify);
+var p = r("text/plain; charset=utf-8", String);
+var f = r("text/html");
+var u = r("image/jpeg");
+var h = r("image/png");
+var g = r("image/webp");
+var w = (e) => {
+  e.cookies = (e.headers.get("Cookie") || "").split(/;\s*/).map((e2) => e2.split(/=(.+)/)).reduce((e2, [t, r2]) => r2 ? (e2[t] = r2, e2) : e2, {});
+};
+var y = (e = {}) => {
   const { origin: t = "*", credentials: r2 = false, allowMethods: o2 = "*", allowHeaders: a, exposeHeaders: s, maxAge: c } = e, n = (e2) => {
     const o3 = e2?.headers.get("origin");
     return t === true ? o3 : t instanceof RegExp ? t.test(o3) ? o3 : undefined : Array.isArray(t) ? t.includes(o3) ? o3 : undefined : t instanceof Function ? t(o3) : t == "*" && r2 ? o3 : t;
@@ -477,16 +489,16 @@ var r = (e = "text/plain; charset=utf-8", t) => (r2, o = {}) => {
     }
   } };
 };
-var init_itty_router = __esm(() => {
-  o = r("application/json; charset=utf-8", JSON.stringify);
-  p = r("text/plain; charset=utf-8", String);
-  f = r("text/html");
-  u = r("image/jpeg");
-  h = r("image/png");
-  g = r("image/webp");
-});
 
 // src/http.ts
+var { preflight, corsify } = y({
+  origin: "*",
+  credentials: true,
+  allowHeaders: "Content-Type, Authorization",
+  allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+  exposeHeaders: "Authorization",
+  maxAge: 86400
+});
 function stringifyData(data) {
   return JSON.stringify(data ?? null, (_key, value) => typeof value === "bigint" ? value.toString() : value);
 }
@@ -499,6 +511,51 @@ function createErrorResponse(code, message, contentType) {
   };
   return createResponse(code, errorBody, contentType);
 }
+var APIError = {
+  badRequest: (msg = "Bad Request", contentType) => createErrorResponse(HTTP_STATUS.BAD_REQUEST, msg, contentType),
+  unauthorized: (msg = "Unauthorized", contentType) => createErrorResponse(HTTP_STATUS.UNAUTHORIZED, msg, contentType),
+  paymentRequired: (msg = "Payment Required", contentType) => createErrorResponse(402, msg, contentType),
+  forbidden: (msg = "Forbidden", contentType) => createErrorResponse(HTTP_STATUS.FORBIDDEN, msg, contentType),
+  notFound: (msg = "Not Found", contentType) => createErrorResponse(HTTP_STATUS.NOT_FOUND, msg, contentType),
+  methodNotAllowed: (msg = "Method Not Allowed", contentType) => createErrorResponse(405, msg, contentType),
+  notAcceptable: (msg = "Not Acceptable", contentType) => createErrorResponse(406, msg, contentType),
+  requestTimeout: (msg = "Request Timeout", contentType) => createErrorResponse(408, msg, contentType),
+  conflict: (msg = "Conflict", contentType) => createErrorResponse(HTTP_STATUS.CONFLICT, msg, contentType),
+  gone: (msg = "Gone", contentType) => createErrorResponse(410, msg, contentType),
+  lengthRequired: (msg = "Length Required", contentType) => createErrorResponse(411, msg, contentType),
+  preconditionFailed: (msg = "Precondition Failed", contentType) => createErrorResponse(412, msg, contentType),
+  payloadTooLarge: (msg = "Payload Too Large", contentType) => createErrorResponse(413, msg, contentType),
+  uriTooLong: (msg = "URI Too Long", contentType) => createErrorResponse(414, msg, contentType),
+  unsupportedMediaType: (msg = "Unsupported Media Type", contentType) => createErrorResponse(415, msg, contentType),
+  rangeNotSatisfiable: (msg = "Range Not Satisfiable", contentType) => createErrorResponse(416, msg, contentType),
+  expectationFailed: (msg = "Expectation Failed", contentType) => createErrorResponse(417, msg, contentType),
+  imATeapot: (msg = "I'm a teapot", contentType) => createErrorResponse(418, msg, contentType),
+  misdirectedRequest: (msg = "Misdirected Request", contentType) => createErrorResponse(421, msg, contentType),
+  unprocessableEntity: (msg = "Unprocessable Entity", contentType) => createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
+  locked: (msg = "Locked", contentType) => createErrorResponse(423, msg, contentType),
+  failedDependency: (msg = "Failed Dependency", contentType) => createErrorResponse(424, msg, contentType),
+  tooEarly: (msg = "Too Early", contentType) => createErrorResponse(425, msg, contentType),
+  upgradeRequired: (msg = "Upgrade Required", contentType) => createErrorResponse(426, msg, contentType),
+  preconditionRequired: (msg = "Precondition Required", contentType) => createErrorResponse(428, msg, contentType),
+  tooManyRequests: (msg = "Too Many Requests", contentType) => createErrorResponse(429, msg, contentType),
+  requestHeaderFieldsTooLarge: (msg = "Request Header Fields Too Large", contentType) => createErrorResponse(431, msg, contentType),
+  unavailableForLegalReasons: (msg = "Unavailable For Legal Reasons", contentType) => createErrorResponse(451, msg, contentType),
+  internalServerError: (msg = "Internal Server Error", contentType) => createErrorResponse(HTTP_STATUS.INTERNAL_SERVER_ERROR, msg, contentType),
+  notImplemented: (msg = "Not Implemented", contentType) => createErrorResponse(501, msg, contentType),
+  badGateway: (msg = "Bad Gateway", contentType) => createErrorResponse(502, msg, contentType),
+  serviceUnavailable: (msg = "Service Unavailable", contentType) => createErrorResponse(503, msg, contentType),
+  gatewayTimeout: (msg = "Gateway Timeout", contentType) => createErrorResponse(504, msg, contentType),
+  httpVersionNotSupported: (msg = "HTTP Version Not Supported", contentType) => createErrorResponse(505, msg, contentType),
+  variantAlsoNegotiates: (msg = "Variant Also Negotiates", contentType) => createErrorResponse(506, msg, contentType),
+  insufficientStorage: (msg = "Insufficient Storage", contentType) => createErrorResponse(507, msg, contentType),
+  loopDetected: (msg = "Loop Detected", contentType) => createErrorResponse(508, msg, contentType),
+  notExtended: (msg = "Not Extended", contentType) => createErrorResponse(510, msg, contentType),
+  networkAuthenticationRequired: (msg = "Network Authentication Required", contentType) => createErrorResponse(511, msg, contentType),
+  invalidArgument: (msg = "Invalid Argument", contentType) => createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
+  rateLimitExceeded: (msg = "Rate Limit Exceeded", contentType) => createErrorResponse(429, msg, contentType),
+  maintenance: (msg = "Service Under Maintenance", contentType) => createErrorResponse(503, msg, contentType),
+  custom: (statusCode, msg, contentType) => createErrorResponse(statusCode, msg, contentType)
+};
 function createResponse(statusCode, data, contentType = CONTENT_TYPES.JSON) {
   const body = contentType === CONTENT_TYPES.JSON ? stringifyData(data) : data;
   return new Response(body, {
@@ -506,64 +563,6 @@ function createResponse(statusCode, data, contentType = CONTENT_TYPES.JSON) {
     headers: { "content-type": contentType }
   });
 }
-var preflight, corsify, APIError;
-var init_http = __esm(() => {
-  init_itty_router();
-  init_constants();
-  ({ preflight, corsify } = y({
-    origin: "*",
-    credentials: true,
-    allowHeaders: "Content-Type, Authorization",
-    allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-    exposeHeaders: "Authorization",
-    maxAge: 86400
-  }));
-  APIError = {
-    badRequest: (msg = "Bad Request", contentType) => createErrorResponse(HTTP_STATUS.BAD_REQUEST, msg, contentType),
-    unauthorized: (msg = "Unauthorized", contentType) => createErrorResponse(HTTP_STATUS.UNAUTHORIZED, msg, contentType),
-    paymentRequired: (msg = "Payment Required", contentType) => createErrorResponse(402, msg, contentType),
-    forbidden: (msg = "Forbidden", contentType) => createErrorResponse(HTTP_STATUS.FORBIDDEN, msg, contentType),
-    notFound: (msg = "Not Found", contentType) => createErrorResponse(HTTP_STATUS.NOT_FOUND, msg, contentType),
-    methodNotAllowed: (msg = "Method Not Allowed", contentType) => createErrorResponse(405, msg, contentType),
-    notAcceptable: (msg = "Not Acceptable", contentType) => createErrorResponse(406, msg, contentType),
-    requestTimeout: (msg = "Request Timeout", contentType) => createErrorResponse(408, msg, contentType),
-    conflict: (msg = "Conflict", contentType) => createErrorResponse(HTTP_STATUS.CONFLICT, msg, contentType),
-    gone: (msg = "Gone", contentType) => createErrorResponse(410, msg, contentType),
-    lengthRequired: (msg = "Length Required", contentType) => createErrorResponse(411, msg, contentType),
-    preconditionFailed: (msg = "Precondition Failed", contentType) => createErrorResponse(412, msg, contentType),
-    payloadTooLarge: (msg = "Payload Too Large", contentType) => createErrorResponse(413, msg, contentType),
-    uriTooLong: (msg = "URI Too Long", contentType) => createErrorResponse(414, msg, contentType),
-    unsupportedMediaType: (msg = "Unsupported Media Type", contentType) => createErrorResponse(415, msg, contentType),
-    rangeNotSatisfiable: (msg = "Range Not Satisfiable", contentType) => createErrorResponse(416, msg, contentType),
-    expectationFailed: (msg = "Expectation Failed", contentType) => createErrorResponse(417, msg, contentType),
-    imATeapot: (msg = "I'm a teapot", contentType) => createErrorResponse(418, msg, contentType),
-    misdirectedRequest: (msg = "Misdirected Request", contentType) => createErrorResponse(421, msg, contentType),
-    unprocessableEntity: (msg = "Unprocessable Entity", contentType) => createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
-    locked: (msg = "Locked", contentType) => createErrorResponse(423, msg, contentType),
-    failedDependency: (msg = "Failed Dependency", contentType) => createErrorResponse(424, msg, contentType),
-    tooEarly: (msg = "Too Early", contentType) => createErrorResponse(425, msg, contentType),
-    upgradeRequired: (msg = "Upgrade Required", contentType) => createErrorResponse(426, msg, contentType),
-    preconditionRequired: (msg = "Precondition Required", contentType) => createErrorResponse(428, msg, contentType),
-    tooManyRequests: (msg = "Too Many Requests", contentType) => createErrorResponse(429, msg, contentType),
-    requestHeaderFieldsTooLarge: (msg = "Request Header Fields Too Large", contentType) => createErrorResponse(431, msg, contentType),
-    unavailableForLegalReasons: (msg = "Unavailable For Legal Reasons", contentType) => createErrorResponse(451, msg, contentType),
-    internalServerError: (msg = "Internal Server Error", contentType) => createErrorResponse(HTTP_STATUS.INTERNAL_SERVER_ERROR, msg, contentType),
-    notImplemented: (msg = "Not Implemented", contentType) => createErrorResponse(501, msg, contentType),
-    badGateway: (msg = "Bad Gateway", contentType) => createErrorResponse(502, msg, contentType),
-    serviceUnavailable: (msg = "Service Unavailable", contentType) => createErrorResponse(503, msg, contentType),
-    gatewayTimeout: (msg = "Gateway Timeout", contentType) => createErrorResponse(504, msg, contentType),
-    httpVersionNotSupported: (msg = "HTTP Version Not Supported", contentType) => createErrorResponse(505, msg, contentType),
-    variantAlsoNegotiates: (msg = "Variant Also Negotiates", contentType) => createErrorResponse(506, msg, contentType),
-    insufficientStorage: (msg = "Insufficient Storage", contentType) => createErrorResponse(507, msg, contentType),
-    loopDetected: (msg = "Loop Detected", contentType) => createErrorResponse(508, msg, contentType),
-    notExtended: (msg = "Not Extended", contentType) => createErrorResponse(510, msg, contentType),
-    networkAuthenticationRequired: (msg = "Network Authentication Required", contentType) => createErrorResponse(511, msg, contentType),
-    invalidArgument: (msg = "Invalid Argument", contentType) => createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
-    rateLimitExceeded: (msg = "Rate Limit Exceeded", contentType) => createErrorResponse(429, msg, contentType),
-    maintenance: (msg = "Service Under Maintenance", contentType) => createErrorResponse(503, msg, contentType),
-    custom: (statusCode, msg, contentType) => createErrorResponse(statusCode, msg, contentType)
-  };
-});
 
 // src/core/router.ts
 class VectorRouter {
@@ -638,23 +637,45 @@ class VectorRouter {
   createRouteRegex(path) {
     return RegExp(`^${path.replace(/\/+(\/|$)/g, "$1").replace(/(\/?\.?):(\w+)\+/g, "($1(?<$2>*))").replace(/(\/?\.?):(\w+)/g, "($1(?<$2>[^$1/]+?))").replace(/\./g, "\\.").replace(/(\/?)\*/g, "($1.*)?")}/*$`);
   }
+  prepareRequest(request, options) {
+    if (!request.context) {
+      request.context = {};
+    }
+    if (options?.params !== undefined) {
+      request.params = options.params;
+    }
+    if (options?.route !== undefined) {
+      request.route = options.route;
+    }
+    if (options?.metadata !== undefined) {
+      request.metadata = options.metadata;
+    }
+    if (!request.query && request.url) {
+      const url = new URL(request.url);
+      const query = {};
+      for (const [key, value] of url.searchParams) {
+        if (key in query) {
+          if (Array.isArray(query[key])) {
+            query[key].push(value);
+          } else {
+            query[key] = [query[key], value];
+          }
+        } else {
+          query[key] = value;
+        }
+      }
+      request.query = query;
+    }
+    if (!request.cookies) {
+      w(request);
+    }
+  }
   wrapHandler(options, handler) {
     return async (request) => {
       const vectorRequest = request;
-      if (!vectorRequest.context) {
-        vectorRequest.context = {};
-      }
-      if (!vectorRequest.query && vectorRequest.url) {
-        const url = new URL(vectorRequest.url);
-        const query = {};
-        for (let [k, v] of url.searchParams) {
-          query[k] = query[k] ? [].concat(query[k], v) : v;
-        }
-        vectorRequest.query = query;
-      }
-      if (options.metadata) {
-        vectorRequest.metadata = options.metadata;
-      }
+      this.prepareRequest(vectorRequest, {
+        metadata: options.metadata
+      });
       request = vectorRequest;
       try {
         if (options.expose === false) {
@@ -690,19 +711,37 @@ class VectorRouter {
         }
         let result;
         const cacheOptions = options.cache;
+        const cacheFactory = async () => {
+          const res = await handler(request);
+          if (res instanceof Response) {
+            return {
+              _isResponse: true,
+              body: await res.text(),
+              status: res.status,
+              headers: Object.fromEntries(res.headers.entries())
+            };
+          }
+          return res;
+        };
         if (cacheOptions && typeof cacheOptions === "number" && cacheOptions > 0) {
           const cacheKey = this.cacheManager.generateKey(request, {
             authUser: request.authUser
           });
-          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions);
+          result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions);
         } else if (cacheOptions && typeof cacheOptions === "object" && cacheOptions.ttl) {
           const cacheKey = cacheOptions.key || this.cacheManager.generateKey(request, {
             authUser: request.authUser
           });
-          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions.ttl);
+          result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions.ttl);
         } else {
           result = await handler(request);
         }
+        if (result && typeof result === "object" && result._isResponse === true) {
+          result = new Response(result.body, {
+            status: result.status,
+            headers: result.headers
+          });
+        }
         let response;
         if (options.rawResponse || result instanceof Response) {
           response = result instanceof Response ? result : new Response(result);
@@ -730,15 +769,15 @@ class VectorRouter {
   async handle(request) {
     const url = new URL(request.url);
     const pathname = url.pathname;
-    for (const [method, regex, handlers] of this.routes) {
+    for (const [method, regex, handlers, path] of this.routes) {
       if (request.method === "OPTIONS" || request.method === method) {
         const match = pathname.match(regex);
         if (match) {
           const req = request;
-          if (!req.context) {
-            req.context = {};
-          }
-          req.params = match.groups || {};
+          this.prepareRequest(req, {
+            params: match.groups || {},
+            route: path || pathname
+          });
           for (const handler of handlers) {
             const response = await handler(req);
             if (response)
@@ -753,9 +792,6 @@ class VectorRouter {
     this.routes = [];
   }
 }
-var init_router = __esm(() => {
-  init_http();
-});
 
 // src/core/server.ts
 class VectorServer {
@@ -799,19 +835,36 @@ class VectorServer {
         return new Response("Internal Server Error", { status: 500 });
       }
     };
-    this.server = Bun.serve({
-      port,
-      hostname,
-      reusePort: this.config.reusePort !== false,
-      fetch,
-      idleTimeout: this.config.idleTimeout || 60,
-      error: (error) => {
-        console.error("[ERROR] Server error:", error);
-        return new Response("Internal Server Error", { status: 500 });
+    try {
+      this.server = Bun.serve({
+        port,
+        hostname,
+        reusePort: this.config.reusePort !== false,
+        fetch,
+        idleTimeout: this.config.idleTimeout || 60,
+        error: (error) => {
+          console.error("[ERROR] Server error:", error);
+          return new Response("Internal Server Error", { status: 500 });
+        }
+      });
+      if (!this.server || !this.server.port) {
+        throw new Error(`Failed to start server on ${hostname}:${port} - server object is invalid`);
       }
-    });
-    console.log(`\u2192 Vector server running at http://${hostname}:${port}`);
-    return this.server;
+      console.log(`\u2192 Vector server running at http://${hostname}:${port}`);
+      return this.server;
+    } catch (error) {
+      if (error.code === "EADDRINUSE" || error.message?.includes("address already in use")) {
+        error.message = `Port ${port} is already in use`;
+        error.port = port;
+      } else if (error.code === "EACCES" || error.message?.includes("permission denied")) {
+        error.message = `Permission denied to bind to port ${port}`;
+        error.port = port;
+      } else if (error.message?.includes("EADDRNOTAVAIL")) {
+        error.message = `Cannot bind to hostname ${hostname}`;
+        error.hostname = hostname;
+      }
+      throw error;
+    }
   }
   stop() {
     if (this.server) {
@@ -835,9 +888,6 @@ class VectorServer {
     return `http://${hostname}:${port}`;
   }
 }
-var init_server = __esm(() => {
-  init_itty_router();
-});
 
 // src/core/vector.ts
 class Vector {
@@ -986,25 +1036,11 @@ class Vector {
     Vector.instance = null;
   }
 }
-var getVectorInstance;
-var init_vector = __esm(() => {
-  init_manager();
-  init_route_generator();
-  init_route_scanner();
-  init_router();
-  init_server();
-  getVectorInstance = Vector.getInstance;
-});
-
-// src/cli/index.ts
-init_vector();
-import { watch } from "fs";
-import { parseArgs } from "util";
+var getVectorInstance = Vector.getInstance;
 
 // src/core/config-loader.ts
 import { existsSync as existsSync2 } from "fs";
 import { resolve as resolve2, isAbsolute } from "path";
-
 class ConfigLoader {
   configPath;
   config = null;
@@ -1127,54 +1163,64 @@ async function runDev() {
   let server = null;
   let vector = null;
   async function startServer() {
-    try {
-      const configLoader = new ConfigLoader(values.config);
-      const config = await configLoader.load();
-      const configSource = configLoader.getConfigSource();
-      config.port = config.port ?? Number.parseInt(values.port);
-      config.hostname = config.hostname ?? values.host;
-      config.routesDir = config.routesDir ?? values.routes;
-      config.development = config.development ?? isDev;
-      config.autoDiscover = true;
-      if (!config.cors && values.cors) {
-        config.cors = {
-          origin: "*",
-          credentials: true,
-          allowHeaders: "Content-Type, Authorization",
-          allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-          exposeHeaders: "Authorization",
-          maxAge: 86400
-        };
-      }
-      vector = getVectorInstance();
-      const authHandler = await configLoader.loadAuthHandler();
-      if (authHandler) {
-        vector.setProtectedHandler(authHandler);
-      }
-      const cacheHandler = await configLoader.loadCacheHandler();
-      if (cacheHandler) {
-        vector.setCacheHandler(cacheHandler);
-      }
-      server = await vector.startServer(config);
-      const gray = "\x1B[90m";
-      const reset = "\x1B[0m";
-      const cyan = "\x1B[36m";
-      const green = "\x1B[32m";
-      console.log(`  ${gray}Config${reset}     ${configSource === "user" ? "User config loaded" : "Using defaults"}`);
-      console.log(`  ${gray}Routes${reset}     ${config.routesDir}`);
-      if (isDev && values.watch) {
-        console.log(`  ${gray}Watching${reset}   All project files`);
-      }
-      console.log(`  ${gray}CORS${reset}       ${config.cors ? "Enabled" : "Disabled"}`);
-      console.log(`  ${gray}Mode${reset}       ${config.development ? "Development" : "Production"}
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error("Server startup timed out (10s)"));
+      }, 1e4);
+    });
+    const serverStartPromise = (async () => {
+      try {
+        const configLoader = new ConfigLoader(values.config);
+        const config = await configLoader.load();
+        const configSource = configLoader.getConfigSource();
+        config.port = config.port ?? Number.parseInt(values.port);
+        config.hostname = config.hostname ?? values.host;
+        config.routesDir = config.routesDir ?? values.routes;
+        config.development = config.development ?? isDev;
+        config.autoDiscover = true;
+        if (!config.cors && values.cors) {
+          config.cors = {
+            origin: "*",
+            credentials: true,
+            allowHeaders: "Content-Type, Authorization",
+            allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+            exposeHeaders: "Authorization",
+            maxAge: 86400
+          };
+        }
+        vector = getVectorInstance();
+        const authHandler = await configLoader.loadAuthHandler();
+        if (authHandler) {
+          vector.setProtectedHandler(authHandler);
+        }
+        const cacheHandler = await configLoader.loadCacheHandler();
+        if (cacheHandler) {
+          vector.setCacheHandler(cacheHandler);
+        }
+        server = await vector.startServer(config);
+        if (!server || !server.port) {
+          throw new Error("Server started but is not responding correctly");
+        }
+        const gray = "\x1B[90m";
+        const reset = "\x1B[0m";
+        const cyan = "\x1B[36m";
+        const green = "\x1B[32m";
+        console.log(`  ${gray}Config${reset}     ${configSource === "user" ? "User config loaded" : "Using defaults"}`);
+        console.log(`  ${gray}Routes${reset}     ${config.routesDir}`);
+        if (isDev && values.watch) {
+          console.log(`  ${gray}Watching${reset}   All project files`);
+        }
+        console.log(`  ${gray}CORS${reset}       ${config.cors ? "Enabled" : "Disabled"}`);
+        console.log(`  ${gray}Mode${reset}       ${config.development ? "Development" : "Production"}
 `);
-      console.log(`  ${green}Ready${reset} \u2192 ${cyan}http://${config.hostname}:${config.port}${reset}
+        console.log(`  ${green}Ready${reset} \u2192 ${cyan}http://${config.hostname}:${config.port}${reset}
 `);
-      return { server, vector, config };
-    } catch (error) {
-      console.error("[ERROR] Failed to start server:", error);
-      throw error;
-    }
+        return { server, vector, config };
+      } catch (error) {
+        throw error;
+      }
+    })();
+    return await Promise.race([serverStartPromise, timeoutPromise]);
   }
   try {
     const result = await startServer();
@@ -1214,7 +1260,8 @@ async function runDev() {
                 server = result2.server;
                 vector = result2.vector;
               } catch (error) {
-                console.error("  \u274C Failed to reload server:", error);
+                console.error(`
+[Reload Error]`, error.message || error);
               } finally {
                 setTimeout(() => {
                   isReloading = false;
@@ -1228,7 +1275,21 @@ async function runDev() {
       }
     }
   } catch (error) {
-    console.error("[ERROR] Failed to start server:", error);
+    const red = "\x1B[31m";
+    const reset = "\x1B[0m";
+    console.error(`
+${red}[ERROR] Failed to start server${reset}
+`);
+    if (error.message) {
+      console.error(`Message: ${error.message}`);
+    }
+    if (error.stack) {
+      console.error(`
+Stack trace:`);
+      console.error(error.stack);
+    } else if (!error.message) {
+      console.error(`Raw error:`, error);
+    }
     process.exit(1);
   }
 }