vector-framework 0.9.0 → 0.9.2

package/dist/cli.js

@@ -0,0 +1,1372 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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, {
+  RouteGenerator: () => RouteGenerator
+});
+import { promises as fs } from "fs";
+import { dirname, relative } from "path";
+
+class RouteGenerator {
+  outputPath;
+  constructor(outputPath = "./.vector/routes.generated.ts") {
+    this.outputPath = outputPath;
+  }
+  async generate(routes) {
+    const outputDir = dirname(this.outputPath);
+    await fs.mkdir(outputDir, { recursive: true });
+    const imports = [];
+    const groupedByFile = new Map;
+    for (const route of routes) {
+      if (!groupedByFile.has(route.path)) {
+        groupedByFile.set(route.path, []);
+      }
+      groupedByFile.get(route.path).push(route);
+    }
+    let importIndex = 0;
+    const routeEntries = [];
+    for (const [filePath, fileRoutes] of groupedByFile) {
+      const relativePath = relative(dirname(this.outputPath), filePath).replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
+      const importName = `route_${importIndex++}`;
+      const namedImports = fileRoutes.filter((r) => r.name !== "default").map((r) => r.name);
+      if (fileRoutes.some((r) => r.name === "default")) {
+        if (namedImports.length > 0) {
+          imports.push(`import ${importName}, { ${namedImports.join(", ")} } from '${relativePath}';`);
+        } else {
+          imports.push(`import ${importName} from '${relativePath}';`);
+        }
+      } else if (namedImports.length > 0) {
+        imports.push(`import { ${namedImports.join(", ")} } from '${relativePath}';`);
+      }
+      for (const route of fileRoutes) {
+        const routeVar = route.name === "default" ? importName : route.name;
+        routeEntries.push(`  ${routeVar},`);
+      }
+    }
+    const content = `// This file is auto-generated. Do not edit manually.
+// Generated at: ${new Date().toISOString()}
+
+${imports.join(`
+`)}
+
+export const routes = [
+${routeEntries.join(`
+`)}
+];
+
+export default routes;
+`;
+    await fs.writeFile(this.outputPath, content, "utf-8");
+    console.log(`Generated routes file: ${this.outputPath}`);
+  }
+  async generateDynamic(routes) {
+    const routeEntries = [];
+    for (const route of routes) {
+      const routeObj = JSON.stringify({
+        method: route.method,
+        path: route.options.path,
+        options: route.options
+      });
+      routeEntries.push(`  await import('${route.path}').then(m => ({ 
+        ...${routeObj}, 
+        handler: m.${route.name === "default" ? "default" : route.name} 
+      }))`);
+    }
+    return `export const loadRoutes = async () => {
+  return Promise.all([
+${routeEntries.join(`,
+`)}
+  ]);
+};`;
+  }
+}
+var init_route_generator = () => {};
+
+// src/dev/route-scanner.ts
+var exports_route_scanner = {};
+__export(exports_route_scanner, {
+  RouteScanner: () => RouteScanner
+});
+import { existsSync, promises as fs2 } from "fs";
+import { join, relative as relative2, resolve, sep } from "path";
+
+class RouteScanner {
+  routesDir;
+  constructor(routesDir = "./routes") {
+    this.routesDir = resolve(process.cwd(), routesDir);
+  }
+  async scan() {
+    const routes = [];
+    if (!existsSync(this.routesDir)) {
+      console.log(`  \u2192 Routes directory not found: ${this.routesDir}`);
+      console.log("  \u2192 No routes will be auto-discovered");
+      return [];
+    }
+    try {
+      console.log(`  \u2192 Scanning routes from: ${this.routesDir}`);
+      await this.scanDirectory(this.routesDir, routes);
+      if (routes.length > 0) {
+        console.log(`  \u2713 Found ${routes.length} route${routes.length === 1 ? "" : "s"}`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.warn(`  \u2717 Routes directory not accessible: ${this.routesDir}`);
+        return [];
+      }
+      throw error;
+    }
+    return routes;
+  }
+  async scanDirectory(dir, routes, basePath = "") {
+    const entries = await fs2.readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await fs2.stat(fullPath);
+      if (stats.isDirectory()) {
+        const newBasePath = basePath ? `${basePath}/${entry}` : entry;
+        await this.scanDirectory(fullPath, routes, newBasePath);
+      } else if (entry.endsWith(".ts") || entry.endsWith(".js")) {
+        const routePath = relative2(this.routesDir, fullPath).replace(/\.(ts|js)$/, "").split(sep).join("/");
+        try {
+          const importPath = process.platform === "win32" ? `file:///${fullPath.replace(/\\/g, "/")}` : fullPath;
+          const module = await import(importPath);
+          if (module.default && typeof module.default === "function") {
+            routes.push({
+              name: "default",
+              path: fullPath,
+              method: "GET",
+              options: {
+                method: "GET",
+                path: `/${routePath}`,
+                expose: true
+              }
+            });
+          }
+          for (const [name, value] of Object.entries(module)) {
+            if (name === "default")
+              continue;
+            if (value && typeof value === "object" && "entry" in value && "options" in value && "handler" in value) {
+              const routeDef = value;
+              routes.push({
+                name,
+                path: fullPath,
+                method: routeDef.options.method,
+                options: routeDef.options
+              });
+            } else if (Array.isArray(value) && value.length >= 4) {
+              const [method, , , path] = value;
+              routes.push({
+                name,
+                path: fullPath,
+                method,
+                options: {
+                  method,
+                  path,
+                  expose: true
+                }
+              });
+            }
+          }
+        } catch (error) {
+          console.error(`Failed to load route from ${fullPath}:`, error);
+        }
+      }
+    }
+  }
+  enableWatch(callback) {
+    if (typeof Bun !== "undefined" && Bun.env.NODE_ENV === "development") {
+      console.log(`Watching for route changes in ${this.routesDir}`);
+      setInterval(async () => {
+        await callback();
+      }, 1000);
+    }
+  }
+}
+var init_route_scanner = () => {};
+
+// src/middleware/manager.ts
+class MiddlewareManager {
+  beforeHandlers = [];
+  finallyHandlers = [];
+  addBefore(...handlers) {
+    this.beforeHandlers.push(...handlers);
+  }
+  addFinally(...handlers) {
+    this.finallyHandlers.push(...handlers);
+  }
+  async executeBefore(request) {
+    let currentRequest = request;
+    for (const handler of this.beforeHandlers) {
+      const result = await handler(currentRequest);
+      if (result instanceof Response) {
+        return result;
+      }
+      currentRequest = result;
+    }
+    return currentRequest;
+  }
+  async executeFinally(response, request) {
+    let currentResponse = response;
+    for (const handler of this.finallyHandlers) {
+      currentResponse = await handler(currentResponse, request);
+    }
+    return currentResponse;
+  }
+  clone() {
+    const manager = new MiddlewareManager;
+    manager.beforeHandlers = [...this.beforeHandlers];
+    manager.finallyHandlers = [...this.finallyHandlers];
+    return manager;
+  }
+  clear() {
+    this.beforeHandlers = [];
+    this.finallyHandlers = [];
+  }
+}
+
+// src/utils/path.ts
+function toFileUrl(path) {
+  return process.platform === "win32" ? `file:///${path.replace(/\\/g, "/")}` : path;
+}
+
+// node_modules/itty-router/index.mjs
+var r = (e = "text/plain; charset=utf-8", t) => (r2, o = {}) => {
+  if (r2 === undefined || r2 instanceof Response)
+    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 = {}) => {
+  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;
+  }, l = (e2, t2) => {
+    for (const [r3, o3] of Object.entries(t2))
+      o3 && e2.headers.append(r3, o3);
+    return e2;
+  };
+  return { corsify: (e2, t2) => e2?.headers?.get("access-control-allow-origin") || e2.status == 101 ? e2 : l(e2.clone(), { "access-control-allow-origin": n(t2), "access-control-allow-credentials": r2 }), preflight: (e2) => {
+    if (e2.method == "OPTIONS") {
+      const t2 = new Response(null, { status: 204 });
+      return l(t2, { "access-control-allow-origin": n(e2), "access-control-allow-methods": o2?.join?.(",") ?? o2, "access-control-expose-headers": s?.join?.(",") ?? s, "access-control-allow-headers": a?.join?.(",") ?? a ?? e2.headers.get("access-control-request-headers"), "access-control-max-age": c, "access-control-allow-credentials": r2 });
+    }
+  } };
+};
+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
+function stringifyData(data) {
+  return JSON.stringify(data ?? null, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+}
+function createErrorResponse(code, message, contentType) {
+  const errorBody = {
+    error: true,
+    message,
+    statusCode: code,
+    timestamp: new Date().toISOString()
+  };
+  return createResponse(code, errorBody, contentType);
+}
+function createResponse(statusCode, data, contentType = CONTENT_TYPES.JSON) {
+  const body = contentType === CONTENT_TYPES.JSON ? stringifyData(data) : data;
+  return new Response(body, {
+    status: statusCode,
+    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 {
+  middlewareManager;
+  authManager;
+  cacheManager;
+  routes = [];
+  constructor(middlewareManager, authManager, cacheManager) {
+    this.middlewareManager = middlewareManager;
+    this.authManager = authManager;
+    this.cacheManager = cacheManager;
+  }
+  getRouteSpecificity(path) {
+    const STATIC_SEGMENT_WEIGHT = 1000;
+    const PARAM_SEGMENT_WEIGHT = 10;
+    const WILDCARD_WEIGHT = 1;
+    const EXACT_MATCH_BONUS = 1e4;
+    let score = 0;
+    const segments = path.split("/").filter(Boolean);
+    for (const segment of segments) {
+      if (this.isStaticSegment(segment)) {
+        score += STATIC_SEGMENT_WEIGHT;
+      } else if (this.isParamSegment(segment)) {
+        score += PARAM_SEGMENT_WEIGHT;
+      } else if (this.isWildcardSegment(segment)) {
+        score += WILDCARD_WEIGHT;
+      }
+    }
+    score += path.length;
+    if (this.isExactPath(path)) {
+      score += EXACT_MATCH_BONUS;
+    }
+    return score;
+  }
+  isStaticSegment(segment) {
+    return !segment.startsWith(":") && !segment.includes("*");
+  }
+  isParamSegment(segment) {
+    return segment.startsWith(":");
+  }
+  isWildcardSegment(segment) {
+    return segment.includes("*");
+  }
+  isExactPath(path) {
+    return !path.includes(":") && !path.includes("*");
+  }
+  sortRoutes() {
+    this.routes.sort((a, b) => {
+      const pathA = this.extractPath(a);
+      const pathB = this.extractPath(b);
+      const scoreA = this.getRouteSpecificity(pathA);
+      const scoreB = this.getRouteSpecificity(pathB);
+      return scoreB - scoreA;
+    });
+  }
+  extractPath(route) {
+    const PATH_INDEX = 3;
+    return route[PATH_INDEX] || "";
+  }
+  route(options, handler) {
+    const wrappedHandler = this.wrapHandler(options, handler);
+    const routeEntry = [
+      options.method.toUpperCase(),
+      this.createRouteRegex(options.path),
+      [wrappedHandler],
+      options.path
+    ];
+    this.routes.push(routeEntry);
+    this.sortRoutes();
+    return routeEntry;
+  }
+  createRouteRegex(path) {
+    return RegExp(`^${path.replace(/\/+(\/|$)/g, "$1").replace(/(\/?\.?):(\w+)\+/g, "($1(?<$2>*))").replace(/(\/?\.?):(\w+)/g, "($1(?<$2>[^$1/]+?))").replace(/\./g, "\\.").replace(/(\/?)\*/g, "($1.*)?")}/*$`);
+  }
+  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;
+      }
+      request = vectorRequest;
+      try {
+        if (options.expose === false) {
+          return APIError.forbidden("Forbidden");
+        }
+        const beforeResult = await this.middlewareManager.executeBefore(request);
+        if (beforeResult instanceof Response) {
+          return beforeResult;
+        }
+        request = beforeResult;
+        if (options.auth) {
+          try {
+            await this.authManager.authenticate(request);
+          } catch (error) {
+            return APIError.unauthorized(error instanceof Error ? error.message : "Authentication failed", options.responseContentType);
+          }
+        }
+        if (!options.rawRequest && request.method !== "GET" && request.method !== "HEAD") {
+          try {
+            const contentType = request.headers.get("content-type");
+            if (contentType?.includes("application/json")) {
+              request.content = await request.json();
+            } else if (contentType?.includes("application/x-www-form-urlencoded")) {
+              request.content = Object.fromEntries(await request.formData());
+            } else if (contentType?.includes("multipart/form-data")) {
+              request.content = await request.formData();
+            } else {
+              request.content = await request.text();
+            }
+          } catch {
+            request.content = null;
+          }
+        }
+        let result;
+        const cacheOptions = options.cache;
+        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);
+        } 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);
+        } else {
+          result = await handler(request);
+        }
+        let response;
+        if (options.rawResponse || result instanceof Response) {
+          response = result instanceof Response ? result : new Response(result);
+        } else {
+          response = createResponse(200, result, options.responseContentType);
+        }
+        response = await this.middlewareManager.executeFinally(response, request);
+        return response;
+      } catch (error) {
+        if (error instanceof Response) {
+          return error;
+        }
+        console.error("Route handler error:", error);
+        return APIError.internalServerError(error instanceof Error ? error.message : String(error), options.responseContentType);
+      }
+    };
+  }
+  addRoute(routeEntry) {
+    this.routes.push(routeEntry);
+    this.sortRoutes();
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  async handle(request) {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    for (const [method, regex, handlers] 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 || {};
+          for (const handler of handlers) {
+            const response = await handler(req);
+            if (response)
+              return response;
+          }
+        }
+      }
+    }
+    return APIError.notFound("Route not found");
+  }
+  clearRoutes() {
+    this.routes = [];
+  }
+}
+var init_router = __esm(() => {
+  init_http();
+});
+
+// src/core/server.ts
+class VectorServer {
+  server = null;
+  router;
+  config;
+  corsHandler;
+  constructor(router, config) {
+    this.router = router;
+    this.config = config;
+    if (config.cors) {
+      const { preflight: preflight2, corsify: corsify2 } = y(this.normalizeCorsOptions(config.cors));
+      this.corsHandler = { preflight: preflight2, corsify: corsify2 };
+    }
+  }
+  normalizeCorsOptions(options) {
+    return {
+      origin: options.origin || "*",
+      credentials: options.credentials !== false,
+      allowHeaders: Array.isArray(options.allowHeaders) ? options.allowHeaders.join(", ") : options.allowHeaders || "Content-Type, Authorization",
+      allowMethods: Array.isArray(options.allowMethods) ? options.allowMethods.join(", ") : options.allowMethods || "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+      exposeHeaders: Array.isArray(options.exposeHeaders) ? options.exposeHeaders.join(", ") : options.exposeHeaders || "Authorization",
+      maxAge: options.maxAge || 86400
+    };
+  }
+  async start() {
+    const port = this.config.port || 3000;
+    const hostname = this.config.hostname || "localhost";
+    const fetch = async (request) => {
+      try {
+        if (this.corsHandler && request.method === "OPTIONS") {
+          return this.corsHandler.preflight(request);
+        }
+        let response = await this.router.handle(request);
+        if (this.corsHandler) {
+          response = this.corsHandler.corsify(response, request);
+        }
+        return response;
+      } catch (error) {
+        console.error("Server error:", error);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+    };
+    this.server = Bun.serve({
+      port,
+      hostname,
+      reusePort: this.config.reusePort !== false,
+      fetch,
+      error: (error) => {
+        console.error("[ERROR] Server error:", error);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+    });
+    console.log(`\u2192 Vector server running at http://${hostname}:${port}`);
+    return this.server;
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+      console.log("Server stopped");
+    }
+  }
+  getServer() {
+    return this.server;
+  }
+  getPort() {
+    return this.server?.port || this.config.port || 3000;
+  }
+  getHostname() {
+    return this.server?.hostname || this.config.hostname || "localhost";
+  }
+  getUrl() {
+    const port = this.getPort();
+    const hostname = this.getHostname();
+    return `http://${hostname}:${port}`;
+  }
+}
+var init_server = __esm(() => {
+  init_itty_router();
+});
+
+// src/core/vector.ts
+class Vector {
+  static instance;
+  router;
+  server = null;
+  middlewareManager;
+  authManager;
+  cacheManager;
+  config = {};
+  routeScanner = null;
+  routeGenerator = null;
+  _protectedHandler = null;
+  _cacheHandler = null;
+  constructor() {
+    this.middlewareManager = new MiddlewareManager;
+    this.authManager = new AuthManager;
+    this.cacheManager = new CacheManager;
+    this.router = new VectorRouter(this.middlewareManager, this.authManager, this.cacheManager);
+  }
+  static getInstance() {
+    if (!Vector.instance) {
+      Vector.instance = new Vector;
+    }
+    return Vector.instance;
+  }
+  setProtectedHandler(handler) {
+    this._protectedHandler = handler;
+    this.authManager.setProtectedHandler(handler);
+  }
+  getProtectedHandler() {
+    return this._protectedHandler;
+  }
+  setCacheHandler(handler) {
+    this._cacheHandler = handler;
+    this.cacheManager.setCacheHandler(handler);
+  }
+  getCacheHandler() {
+    return this._cacheHandler;
+  }
+  addRoute(options, handler) {
+    return this.router.route(options, handler);
+  }
+  async startServer(config) {
+    this.config = { ...this.config, ...config };
+    this.middlewareManager.clear();
+    if (config?.before) {
+      this.middlewareManager.addBefore(...config.before);
+    }
+    if (config?.finally) {
+      this.middlewareManager.addFinally(...config.finally);
+    }
+    if (this.config.autoDiscover !== false) {
+      await this.discoverRoutes();
+    }
+    this.server = new VectorServer(this.router, this.config);
+    const bunServer = await this.server.start();
+    return bunServer;
+  }
+  async discoverRoutes() {
+    const routesDir = this.config.routesDir || "./routes";
+    if (!this.routeScanner) {
+      this.routeScanner = new RouteScanner(routesDir);
+    }
+    if (!this.routeGenerator) {
+      this.routeGenerator = new RouteGenerator;
+    }
+    try {
+      const routes = await this.routeScanner.scan();
+      if (routes.length > 0) {
+        if (this.config.development) {
+          await this.routeGenerator.generate(routes);
+        }
+        for (const route of routes) {
+          try {
+            const importPath = toFileUrl(route.path);
+            const module = await import(importPath);
+            const exported = route.name === "default" ? module.default : module[route.name];
+            if (exported) {
+              if (this.isRouteDefinition(exported)) {
+                const routeDef = exported;
+                this.router.route(routeDef.options, routeDef.handler);
+                this.logRouteLoaded(routeDef.options);
+              } else if (this.isRouteEntry(exported)) {
+                this.router.addRoute(exported);
+                this.logRouteLoaded(exported);
+              } else if (typeof exported === "function") {
+                this.router.route(route.options, exported);
+                this.logRouteLoaded(route.options);
+              }
+            }
+          } catch (error) {
+            console.error(`Failed to load route ${route.name} from ${route.path}:`, error);
+          }
+        }
+        this.router.sortRoutes();
+        console.log(`\u2705 Loaded ${routes.length} routes from ${routesDir}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ENOTDIR") {
+        console.error("Failed to discover routes:", error);
+      }
+    }
+  }
+  async loadRoute(routeModule) {
+    if (typeof routeModule === "function") {
+      const routeEntry = routeModule();
+      if (Array.isArray(routeEntry)) {
+        this.router.addRoute(routeEntry);
+      }
+    } else if (routeModule && typeof routeModule === "object") {
+      for (const [, value] of Object.entries(routeModule)) {
+        if (typeof value === "function") {
+          const routeEntry = value();
+          if (Array.isArray(routeEntry)) {
+            this.router.addRoute(routeEntry);
+          }
+        }
+      }
+    }
+  }
+  isRouteEntry(value) {
+    return Array.isArray(value) && value.length >= 3;
+  }
+  isRouteDefinition(value) {
+    return value && typeof value === "object" && "entry" in value && "options" in value && "handler" in value;
+  }
+  logRouteLoaded(route) {
+    if (Array.isArray(route)) {
+      console.log(`  \u2713 Loaded route: ${route[0]} ${route[3] || route[1]}`);
+    } else {
+      console.log(`  \u2713 Loaded route: ${route.method} ${route.path}`);
+    }
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+    this.router.clearRoutes();
+  }
+  getServer() {
+    return this.server;
+  }
+  getRouter() {
+    return this.router;
+  }
+  getCacheManager() {
+    return this.cacheManager;
+  }
+  getAuthManager() {
+    return this.authManager;
+  }
+  static resetInstance() {
+    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";
+
+// src/core/config-loader.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+class ConfigLoader {
+  configPath;
+  config = null;
+  configSource = "default";
+  constructor(configPath = "vector.config.ts") {
+    this.configPath = resolve2(process.cwd(), configPath);
+  }
+  async load() {
+    if (existsSync2(this.configPath)) {
+      try {
+        console.log(`\u2192 Loading config from: ${this.configPath}`);
+        const userConfigPath = toFileUrl(this.configPath);
+        const userConfig = await import(userConfigPath);
+        this.config = userConfig.default || userConfig;
+        this.configSource = "user";
+        console.log("  \u2713 User config loaded successfully");
+      } catch (error) {
+        console.error(`  \u2717 Failed to load config from ${this.configPath}:`, error);
+        console.log("  \u2192 Using default configuration");
+        this.config = {};
+      }
+    } else {
+      console.log(`  \u2192 No config file found at: ${this.configPath}`);
+      console.log("  \u2192 Using default configuration");
+      this.config = {};
+    }
+    return await this.buildLegacyConfig();
+  }
+  getConfigSource() {
+    return this.configSource;
+  }
+  async buildLegacyConfig() {
+    const config = {};
+    if (this.config?.server) {
+      config.port = this.config.server.port;
+      config.hostname = this.config.server.hostname;
+      config.reusePort = this.config.server.reusePort;
+      config.development = this.config.server.development;
+    }
+    if (this.config?.routes) {
+      config.routesDir = this.config.routes.dir || "./routes";
+      config.autoDiscover = this.config.routes.autoDiscover !== false;
+    } else {
+      config.routesDir = "./routes";
+      config.autoDiscover = true;
+    }
+    if (this.config?.cors) {
+      if (typeof this.config.cors === "boolean") {
+        config.cors = this.config.cors ? {
+          origin: "*",
+          credentials: true,
+          allowHeaders: "Content-Type, Authorization",
+          allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+          exposeHeaders: "Authorization",
+          maxAge: 86400
+        } : undefined;
+      } else {
+        config.cors = this.config.cors;
+      }
+    }
+    if (this.config?.before) {
+      console.log("Using direct before middleware functions:", this.config.before.length);
+      config.before = this.config.before;
+    } else if (this.config?.middleware?.before) {
+      console.log("Loading before middleware from file paths:", this.config.middleware.before);
+      config.before = await this.loadMiddleware(this.config.middleware.before);
+      console.log("Loaded before middleware:", config.before?.length);
+    }
+    if (this.config?.after) {
+      console.log("Using direct after middleware functions:", this.config.after.length);
+      config.finally = this.config.after;
+    } else if (this.config?.middleware?.after) {
+      console.log("Loading after middleware from file paths:", this.config.middleware.after);
+      config.finally = await this.loadMiddleware(this.config.middleware.after);
+      console.log("Loaded after middleware:", config.finally?.length);
+    }
+    return config;
+  }
+  async loadMiddleware(paths) {
+    const middleware = [];
+    for (const path of paths) {
+      try {
+        const modulePath = resolve2(process.cwd(), path);
+        const importPath = toFileUrl(modulePath);
+        const module = await import(importPath);
+        const handler = module.default || module;
+        if (typeof handler === "function") {
+          middleware.push(handler);
+        } else {
+          console.warn(`Middleware at ${path} does not export a function`);
+        }
+      } catch (error) {
+        console.error(`Failed to load middleware from ${path}:`, error);
+      }
+    }
+    return middleware;
+  }
+  async loadAuthHandler() {
+    if (this.config?.auth) {
+      console.log("Using direct auth handler function");
+      return this.config.auth;
+    }
+    if (!this.config?.handlers?.auth) {
+      return null;
+    }
+    try {
+      const modulePath = resolve2(process.cwd(), this.config.handlers.auth);
+      const importPath = toFileUrl(modulePath);
+      const module = await import(importPath);
+      const handler = module.default || module;
+      if (typeof handler === "function") {
+        return handler;
+      } else {
+        console.warn(`Auth handler at ${this.config.handlers.auth} does not export a function`);
+        return null;
+      }
+    } catch (error) {
+      console.error(`Failed to load auth handler from ${this.config.handlers.auth}:`, error);
+      return null;
+    }
+  }
+  async loadCacheHandler() {
+    if (this.config?.cache) {
+      console.log("Using direct cache handler function");
+      return this.config.cache;
+    }
+    if (!this.config?.handlers?.cache) {
+      return null;
+    }
+    try {
+      const modulePath = resolve2(process.cwd(), this.config.handlers.cache);
+      const importPath = toFileUrl(modulePath);
+      const module = await import(importPath);
+      const handler = module.default || module;
+      if (typeof handler === "function") {
+        return handler;
+      } else {
+        console.warn(`Cache handler at ${this.config.handlers.cache} does not export a function`);
+        return null;
+      }
+    } catch (error) {
+      console.error(`Failed to load cache handler from ${this.config.handlers.cache}:`, error);
+      return null;
+    }
+  }
+  getConfig() {
+    return this.config;
+  }
+}
+
+// src/cli/index.ts
+var args = typeof Bun !== "undefined" ? Bun.argv.slice(2) : process.argv.slice(2);
+var { values, positionals } = parseArgs({
+  args,
+  options: {
+    port: {
+      type: "string",
+      short: "p",
+      default: "3000"
+    },
+    host: {
+      type: "string",
+      short: "h",
+      default: "localhost"
+    },
+    routes: {
+      type: "string",
+      short: "r",
+      default: "./routes"
+    },
+    watch: {
+      type: "boolean",
+      short: "w",
+      default: true
+    },
+    cors: {
+      type: "boolean",
+      default: true
+    }
+  },
+  strict: true,
+  allowPositionals: true
+});
+var command = positionals[0] || "dev";
+async function runDev() {
+  const isDev = command === "dev";
+  console.log(`
+\u2192 Starting Vector ${isDev ? "development" : "production"} server
+`);
+  let server = null;
+  let vector = null;
+  async function startServer() {
+    try {
+      const configLoader = new ConfigLoader;
+      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 = 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}       ${values.cors ? "Enabled" : "Disabled"}`);
+      console.log(`  ${gray}Mode${reset}       ${isDev ? "Development" : "Production"}
+`);
+      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;
+    }
+  }
+  try {
+    const result = await startServer();
+    server = result.server;
+    if (isDev && values.watch) {
+      try {
+        let reloadTimeout = null;
+        watch(process.cwd(), { recursive: true }, async (_, filename) => {
+          if (filename && (filename.endsWith(".ts") || filename.endsWith(".js") || filename.endsWith(".json")) && !filename.includes("node_modules") && !filename.includes(".git")) {
+            if (reloadTimeout) {
+              clearTimeout(reloadTimeout);
+            }
+            reloadTimeout = setTimeout(async () => {
+              console.log(`
+  \uD83D\uDD04 File changed: ${filename}`);
+              console.log(`  \uD83D\uDD04 Reloading server...
+`);
+              if (vector) {
+                vector.stop();
+              }
+              for (const key in __require.cache) {
+                if (!key.includes("node_modules")) {
+                  delete __require.cache[key];
+                }
+              }
+              try {
+                const result2 = await startServer();
+                server = result2.server;
+              } catch (error) {
+                console.error("  \u274C Failed to reload server:", error);
+              }
+            }, 100);
+          }
+        });
+      } catch (err) {
+        console.warn("  \u26A0\uFE0F  File watching not available");
+      }
+    }
+  } catch (error) {
+    console.error("[ERROR] Failed to start server:", error);
+    process.exit(1);
+  }
+}
+async function runBuild() {
+  console.log(`
+\u2192 Building Vector application
+`);
+  try {
+    const { RouteScanner: RouteScanner2 } = await Promise.resolve().then(() => (init_route_scanner(), exports_route_scanner));
+    const { RouteGenerator: RouteGenerator2 } = await Promise.resolve().then(() => (init_route_generator(), exports_route_generator));
+    const scanner = new RouteScanner2(values.routes);
+    const generator = new RouteGenerator2;
+    const routes = await scanner.scan();
+    await generator.generate(routes);
+    console.log(`  Generated ${routes.length} routes`);
+    if (typeof Bun !== "undefined") {
+      const buildProcess = Bun.spawn([
+        "bun",
+        "build",
+        "src/index.ts",
+        "--outdir",
+        "dist",
+        "--minify"
+      ]);
+      await buildProcess.exited;
+    } else {
+      const { spawnSync } = await import("child_process");
+      spawnSync("bun", ["build", "src/index.ts", "--outdir", "dist", "--minify"], {
+        stdio: "inherit",
+        shell: true
+      });
+    }
+    console.log(`
+  \u2713 Build complete
+`);
+  } catch (error) {
+    console.error("[ERROR] Build failed:", error);
+    process.exit(1);
+  }
+}
+switch (command) {
+  case "dev":
+    await runDev();
+    break;
+  case "build":
+    await runBuild();
+    break;
+  case "start":
+    process.env.NODE_ENV = "production";
+    await runDev();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.log(`
+Usage: vector [command] [options]
+
+Commands:
+  dev     Start development server (default)
+  build   Build for production
+  start   Start production server
+
+Options:
+  -p, --port <port>      Port to listen on (default: 3000)
+  -h, --host <host>      Hostname to bind to (default: localhost)
+  -r, --routes <dir>     Routes directory (default: ./routes)
+  -w, --watch            Watch for file changes (default: true)
+  --cors                 Enable CORS (default: true)
+`);
+    process.exit(1);
+}