blaizejs 0.1.0 → 0.2.2

package/dist/index.js

@@ -1,37 +1,12 @@
 /**
- * blaizejs v0.1.0
- * A blazing-fast, type-safe Node.js framework with file-based routing, powerful middleware, and end-to-end type safety
+ * blaizejs v0.2.2
+ * A blazing-fast, TypeScript-first Node.js framework with HTTP/2 support, file-based routing, powerful middleware system, and end-to-end type safety for building modern APIs.
  * 
  * Copyright (c) 2025 BlaizeJS Contributors
  * @license MIT
  */
 
 
-// src/middleware/create.ts
-function create(handlerOrOptions) {
-  if (typeof handlerOrOptions === "function") {
-    return {
-      name: "anonymous",
-      // Default name for function middleware
-      execute: handlerOrOptions,
-      debug: false
-    };
-  }
-  const { name = "anonymous", handler, skip, debug = false } = handlerOrOptions;
-  const middleware = {
-    name,
-    execute: handler,
-    debug
-  };
-  if (skip !== void 0) {
-    return {
-      ...middleware,
-      skip
-    };
-  }
-  return middleware;
-}
-
 // src/middleware/execute.ts
 function execute(middleware, ctx, next) {
   if (!middleware) {
@@ -79,54 +54,80 @@ function compose(middlewareStack) {
   };
 }
 
-// src/plugins/create.ts
-function create2(name, version, setup, _defaultOptions = {}) {
-  throw new Error("Plugin system not yet available");
+// src/middleware/create.ts
+function create(handlerOrOptions) {
+  if (typeof handlerOrOptions === "function") {
+    return {
+      name: "anonymous",
+      // Default name for function middleware
+      execute: handlerOrOptions,
+      debug: false
+    };
+  }
+  const { name = "anonymous", handler, skip, debug = false } = handlerOrOptions;
+  const middleware = {
+    name,
+    execute: handler,
+    debug
+  };
+  if (skip !== void 0) {
+    return {
+      ...middleware,
+      skip
+    };
+  }
+  return middleware;
 }
 
-// src/router/discovery/finder.ts
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-async function findRouteFiles(routesDir, options = {}) {
-  const absoluteDir = path.isAbsolute(routesDir) ? routesDir : path.resolve(process.cwd(), routesDir);
-  console.log("Creating router with routes directory:", absoluteDir);
-  try {
-    const stats = await fs.stat(absoluteDir);
-    if (!stats.isDirectory()) {
-      throw new Error(`Route directory is not a directory: ${absoluteDir}`);
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`Route directory not found: ${absoluteDir}`);
-    }
-    throw error;
-  }
-  const routeFiles = [];
-  const ignore = options.ignore || ["node_modules", ".git"];
-  async function scanDirectory(dir) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory() && ignore.includes(entry.name)) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        await scanDirectory(fullPath);
-      } else if (isRouteFile(entry.name)) {
-        routeFiles.push(fullPath);
+// src/plugins/create.ts
+function create2(name, version, setup, defaultOptions = {}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Plugin name must be a non-empty string");
+  }
+  if (!version || typeof version !== "string") {
+    throw new Error("Plugin version must be a non-empty string");
+  }
+  if (typeof setup !== "function") {
+    throw new Error("Plugin setup must be a function");
+  }
+  return function pluginFactory(userOptions) {
+    const mergedOptions = { ...defaultOptions, ...userOptions };
+    const plugin = {
+      name,
+      version,
+      // The register hook calls the user's setup function
+      register: async (app) => {
+        const result = await setup(app, mergedOptions);
+        if (result && typeof result === "object") {
+          Object.assign(plugin, result);
+        }
       }
-    }
-  }
-  await scanDirectory(absoluteDir);
-  return routeFiles;
+    };
+    return plugin;
+  };
 }
-function isRouteFile(filename) {
-  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js")) && filename !== "index.ts" && filename !== "index.js";
+
+// src/config.ts
+var config = {};
+function setRuntimeConfig(newConfig) {
+  config = { ...config, ...newConfig };
+}
+function getRoutesDir() {
+  if (!config.routesDir) {
+    throw new Error("Routes directory not configured. Make sure server is properly initialized.");
+  }
+  return config.routesDir;
 }
 
 // src/router/discovery/parser.ts
-import * as path2 from "node:path";
+import * as path from "node:path";
 function parseRoutePath(filePath, basePath) {
+  if (filePath.startsWith("file://")) {
+    filePath = filePath.replace("file://", "");
+  }
+  if (basePath.startsWith("file://")) {
+    basePath = basePath.replace("file://", "");
+  }
   const forwardSlashFilePath = filePath.replace(/\\/g, "/");
   const forwardSlashBasePath = basePath.replace(/\\/g, "/");
   const normalizedBasePath = forwardSlashBasePath.endsWith("/") ? forwardSlashBasePath : `${forwardSlashBasePath}/`;
@@ -139,7 +140,7 @@ function parseRoutePath(filePath, basePath) {
       relativePath = relativePath.substring(1);
     }
   } else {
-    relativePath = path2.relative(forwardSlashBasePath, forwardSlashFilePath).replace(/\\/g, "/");
+    relativePath = path.relative(forwardSlashBasePath, forwardSlashFilePath).replace(/\\/g, "/");
   }
   relativePath = relativePath.replace(/\.[^.]+$/, "");
   const segments = relativePath.split("/").filter(Boolean);
@@ -163,1450 +164,1723 @@ function parseRoutePath(filePath, basePath) {
   };
 }
 
-// src/router/discovery/loader.ts
-async function dynamicImport(filePath) {
-  return import(filePath);
-}
-async function loadRouteModule(filePath, basePath) {
+// src/router/create.ts
+function getCallerFilePath() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
   try {
-    const parsedRoute = parseRoutePath(filePath, basePath);
-    console.log("parsedRoute:", parsedRoute);
-    const module = await dynamicImport(filePath);
-    console.log("Module exports:", Object.keys(module));
-    const routes = [];
-    if (module.default && typeof module.default === "object") {
-      console.log("Found default export:", module.default);
-      const route = {
-        ...module.default,
-        path: parsedRoute.routePath
-      };
-      routes.push(route);
+    Error.prepareStackTrace = (_, stack2) => stack2;
+    const stack = new Error().stack;
+    const callerFrame = stack[3];
+    if (!callerFrame || typeof callerFrame.getFileName !== "function") {
+      throw new Error("Unable to determine caller file frame");
     }
-    Object.entries(module).forEach(([exportName, exportValue]) => {
-      if (exportName === "default" || !exportValue || typeof exportValue !== "object") {
-        return;
-      }
-      const potentialRoute = exportValue;
-      if (isValidRoute(potentialRoute)) {
-        console.log(`Found named route export: ${exportName}`, potentialRoute);
-        const route = {
-          ...potentialRoute,
-          // Use the route's own path if it has one, otherwise derive from file
-          path: parsedRoute.routePath
-        };
-        routes.push(route);
-      }
-    });
-    if (routes.length === 0) {
-      console.warn(`Route file ${filePath} does not export any valid route definitions`);
-      return [];
+    const fileName = callerFrame.getFileName();
+    if (!fileName) {
+      throw new Error("Unable to determine caller file name");
     }
-    console.log(`Loaded ${routes.length} route(s) from ${filePath}`);
-    return routes;
-  } catch (error) {
-    console.error(`Failed to load route module ${filePath}:`, error);
-    return [];
+    return fileName;
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
   }
 }
-function isValidRoute(obj) {
-  if (!obj || typeof obj !== "object") {
-    return false;
-  }
-  const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-  const hasHttpMethod = httpMethods.some(
-    (method) => obj[method] && typeof obj[method] === "object" && obj[method].handler
-  );
-  return hasHttpMethod;
+function getRoutePath() {
+  console.log("getRoutePath called");
+  const callerPath = getCallerFilePath();
+  const routesDir = getRoutesDir();
+  const parsedRoute = parseRoutePath(callerPath, routesDir);
+  console.log(`Parsed route path: ${parsedRoute.routePath} from file: ${callerPath}`);
+  return parsedRoute.routePath;
 }
-
-// src/router/discovery/index.ts
-async function findRoutes(routesDir, options = {}) {
-  const routeFiles = await findRouteFiles(routesDir, {
-    ignore: options.ignore
-  });
-  const routes = [];
-  for (const filePath of routeFiles) {
-    const moduleRoutes = await loadRouteModule(filePath, routesDir);
-    if (moduleRoutes.length > 0) {
-      routes.push(...moduleRoutes);
-    }
+var createGetRoute = (config2) => {
+  validateMethodConfig("GET", config2);
+  const path5 = getRoutePath();
+  return {
+    GET: config2,
+    path: path5
+  };
+};
+var createPostRoute = (config2) => {
+  validateMethodConfig("POST", config2);
+  const path5 = getRoutePath();
+  return {
+    POST: config2,
+    path: path5
+  };
+};
+var createPutRoute = (config2) => {
+  validateMethodConfig("PUT", config2);
+  const path5 = getRoutePath();
+  return {
+    PUT: config2,
+    path: path5
+  };
+};
+var createDeleteRoute = (config2) => {
+  validateMethodConfig("DELETE", config2);
+  const path5 = getRoutePath();
+  return {
+    DELETE: config2,
+    path: path5
+  };
+};
+var createPatchRoute = (config2) => {
+  validateMethodConfig("PATCH", config2);
+  const path5 = getRoutePath();
+  return {
+    PATCH: config2,
+    path: path5
+  };
+};
+var createHeadRoute = (config2) => {
+  validateMethodConfig("HEAD", config2);
+  const path5 = getRoutePath();
+  return {
+    HEAD: config2,
+    path: path5
+  };
+};
+var createOptionsRoute = (config2) => {
+  validateMethodConfig("OPTIONS", config2);
+  const path5 = getRoutePath();
+  return {
+    OPTIONS: config2,
+    path: path5
+  };
+};
+function validateMethodConfig(method, config2) {
+  if (!config2.handler || typeof config2.handler !== "function") {
+    throw new Error(`Handler for method ${method} must be a function`);
+  }
+  if (config2.middleware && !Array.isArray(config2.middleware)) {
+    throw new Error(`Middleware for method ${method} must be an array`);
+  }
+  if (config2.schema) {
+    validateSchema(method, config2.schema);
+  }
+  switch (method) {
+    case "GET":
+    case "HEAD":
+    case "DELETE":
+      if (config2.schema?.body) {
+        console.warn(`Warning: ${method} requests typically don't have request bodies`);
+      }
+      break;
   }
-  return routes;
 }
-
-// src/router/discovery/watchers.ts
-import * as path3 from "node:path";
-import { watch } from "chokidar";
-function watchRoutes(routesDir, options = {}) {
-  const routesByPath = /* @__PURE__ */ new Map();
-  async function loadInitialRoutes() {
-    try {
-      const files = await findRouteFiles(routesDir, {
-        ignore: options.ignore
-      });
-      for (const filePath of files) {
-        await loadAndNotify(filePath);
-      }
-    } catch (error) {
-      handleError(error);
-    }
+function validateSchema(method, schema) {
+  const { params, query, body, response } = schema;
+  if (params && (!params._def || typeof params.parse !== "function")) {
+    throw new Error(`Params schema for ${method} must be a valid Zod schema`);
   }
-  async function loadAndNotify(filePath) {
-    try {
-      const routes = await loadRouteModule(filePath, routesDir);
-      if (!routes || routes.length === 0) {
-        return;
-      }
-      const existingRoutes = routesByPath.get(filePath);
-      if (existingRoutes) {
-        routesByPath.set(filePath, routes);
-        if (options.onRouteChanged) {
-          options.onRouteChanged(routes);
-        }
-      } else {
-        routesByPath.set(filePath, routes);
-        if (options.onRouteAdded) {
-          options.onRouteAdded(routes);
-        }
-      }
-    } catch (error) {
-      handleError(error);
-    }
+  if (query && (!query._def || typeof query.parse !== "function")) {
+    throw new Error(`Query schema for ${method} must be a valid Zod schema`);
   }
-  function handleRemoved(filePath) {
-    const normalizedPath = path3.normalize(filePath);
-    const routes = routesByPath.get(normalizedPath);
-    if (routes && routes.length > 0 && options.onRouteRemoved) {
-      options.onRouteRemoved(normalizedPath, routes);
-    }
-    routesByPath.delete(normalizedPath);
+  if (body && (!body._def || typeof body.parse !== "function")) {
+    throw new Error(`Body schema for ${method} must be a valid Zod schema`);
   }
-  function handleError(error) {
-    if (options.onError && error instanceof Error) {
-      options.onError(error);
-    } else {
-      console.error("Route watcher error:", error);
-    }
+  if (response && (!response._def || typeof response.parse !== "function")) {
+    throw new Error(`Response schema for ${method} must be a valid Zod schema`);
   }
-  const watcher = watch(routesDir, {
-    ignored: [
-      /(^|[/\\])\../,
-      // Ignore dot files
-      /node_modules/,
-      ...options.ignore || []
-    ],
-    persistent: true,
-    ignoreInitial: false,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100
-    }
-  });
-  watcher.on("add", loadAndNotify).on("change", loadAndNotify).on("unlink", handleRemoved).on("error", handleError);
-  loadInitialRoutes().catch(handleError);
-  return {
-    /**
-     * Close the watcher
-     */
-    close: () => watcher.close(),
-    /**
-     * Get all currently loaded routes (flattened)
-     */
-    getRoutes: () => {
-      const allRoutes = [];
-      for (const routes of routesByPath.values()) {
-        allRoutes.push(...routes);
-      }
-      return allRoutes;
-    },
-    /**
-     * Get routes organized by file path
-     */
-    getRoutesByFile: () => new Map(routesByPath)
-  };
 }
 
-// src/router/handlers/error.ts
-function handleRouteError(ctx, error, options = {}) {
-  if (options.log) {
-    console.error("Route error:", error);
-  }
-  const status = getErrorStatus(error);
-  const response = {
-    error: getErrorType(error),
-    message: getErrorMessage(error)
-  };
-  if (options.detailed) {
-    if (error instanceof Error) {
-      response.stack = error.stack;
-    }
-    if (error && typeof error === "object" && "details" in error && error.details) {
-      response.details = error.details;
-    }
-  }
-  ctx.response.status(status).json(response);
-}
-function getErrorStatus(error) {
-  if (error && typeof error === "object") {
-    if ("status" in error && typeof error.status === "number") {
-      return error.status;
-    }
-    if ("statusCode" in error && typeof error.statusCode === "number") {
-      return error.statusCode;
-    }
-    if ("code" in error && typeof error.code === "string") {
-      return getStatusFromCode(error.code);
-    }
+// src/server/create.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import EventEmitter from "node:events";
+
+// src/server/start.ts
+import * as fs2 from "node:fs";
+import * as http from "node:http";
+import * as http2 from "node:http2";
+
+// src/server/dev-certificate.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import * as selfsigned from "selfsigned";
+async function generateDevCertificates() {
+  const certDir = path2.join(process.cwd(), ".blaizejs", "certs");
+  const keyPath = path2.join(certDir, "dev.key");
+  const certPath = path2.join(certDir, "dev.cert");
+  if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+    return {
+      keyFile: keyPath,
+      certFile: certPath
+    };
   }
-  return 500;
-}
-function getStatusFromCode(code) {
-  switch (code) {
-    case "NOT_FOUND":
-      return 404;
-    case "UNAUTHORIZED":
-      return 401;
-    case "FORBIDDEN":
-      return 403;
-    case "BAD_REQUEST":
-      return 400;
-    case "CONFLICT":
-      return 409;
-    default:
-      return 500;
+  if (!fs.existsSync(certDir)) {
+    fs.mkdirSync(certDir, { recursive: true });
   }
+  const attrs = [{ name: "commonName", value: "localhost" }];
+  const options = {
+    days: 365,
+    algorithm: "sha256",
+    keySize: 2048,
+    extensions: [
+      { name: "basicConstraints", cA: true },
+      {
+        name: "keyUsage",
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true
+      },
+      {
+        name: "extKeyUsage",
+        serverAuth: true,
+        clientAuth: true
+      },
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          { type: 7, ip: "127.0.0.1" }
+        ]
+      }
+    ]
+  };
+  const pems = selfsigned.generate(attrs, options);
+  fs.writeFileSync(keyPath, Buffer.from(pems.private, "utf-8"));
+  fs.writeFileSync(certPath, Buffer.from(pems.cert, "utf-8"));
+  console.log(`
+\u{1F512} Generated self-signed certificates for development at ${certDir}
+`);
+  return {
+    keyFile: keyPath,
+    certFile: certPath
+  };
 }
-function getErrorType(error) {
-  if (error && typeof error === "object") {
-    if ("type" in error && typeof error.type === "string") {
-      return error.type;
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return error.name;
-    }
-    if (error instanceof Error) {
-      return error.constructor.name;
-    }
+
+// src/context/errors.ts
+var ResponseSentError = class extends Error {
+  constructor(message = "\u274C Response has already been sent") {
+    super(message);
+    this.name = "ResponseSentError";
   }
-  return "Error";
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
+};
+var ResponseSentHeaderError = class extends ResponseSentError {
+  constructor(message = "Cannot set header after response has been sent") {
+    super(message);
   }
-  if (error && typeof error === "object") {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
-    }
+};
+var ResponseSentContentError = class extends ResponseSentError {
+  constructor(message = "Cannot set content type after response has been sent") {
+    super(message);
   }
-  return String(error);
-}
-
-// src/router/validation/body.ts
-import { z } from "zod";
-function validateBody(body, schema) {
-  if (schema instanceof z.ZodObject) {
-    return schema.strict().parse(body);
+};
+var ParseUrlError = class extends ResponseSentError {
+  constructor(message = "Invalide URL") {
+    super(message);
   }
-  return schema.parse(body);
-}
+};
 
-// src/router/validation/params.ts
-import { z as z2 } from "zod";
-function validateParams(params, schema) {
-  if (schema instanceof z2.ZodObject) {
-    return schema.strict().parse(params);
-  }
-  return schema.parse(params);
+// src/context/store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var contextStorage = new AsyncLocalStorage();
+function runWithContext(context, callback) {
+  return contextStorage.run(context, callback);
 }
 
-// src/router/validation/query.ts
-import { z as z3 } from "zod";
-function validateQuery(query, schema) {
-  if (schema instanceof z3.ZodObject) {
-    return schema.strict().parse(query);
+// src/context/create.ts
+var CONTENT_TYPE_HEADER = "Content-Type";
+function parseRequestUrl(req) {
+  const originalUrl = req.url || "/";
+  const host = req.headers.host || "localhost";
+  const protocol = req.socket && req.socket.encrypted ? "https" : "http";
+  const fullUrl = `${protocol}://${host}${originalUrl.startsWith("/") ? "" : "/"}${originalUrl}`;
+  try {
+    const url = new URL(fullUrl);
+    const path5 = url.pathname;
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+      if (query[key] !== void 0) {
+        if (Array.isArray(query[key])) {
+          query[key].push(value);
+        } else {
+          query[key] = [query[key], value];
+        }
+      } else {
+        query[key] = value;
+      }
+    });
+    return { path: path5, url, query };
+  } catch (error) {
+    console.warn(`Invalid URL: ${fullUrl}`, error);
+    throw new ParseUrlError(`Invalid URL: ${fullUrl}`);
   }
-  return schema.parse(query);
 }
-
-// src/router/validation/response.ts
-import { z as z4 } from "zod";
-function validateResponse(response, schema) {
-  if (schema instanceof z4.ZodObject) {
-    return schema.strict().parse(response);
-  }
-  return schema.parse(response);
+function isHttp2Request(req) {
+  return "stream" in req || "httpVersionMajor" in req && req.httpVersionMajor === 2;
 }
-
-// src/router/validation/schema.ts
-function createRequestValidator(schema, debug = false) {
-  const middlewareFn = async (ctx, next) => {
-    const errors = {};
-    if (schema.params && ctx.request.params) {
-      try {
-        ctx.request.params = validateParams(ctx.request.params, schema.params);
-      } catch (error) {
-        errors.params = formatValidationError(error);
-      }
-    }
-    if (schema.query && ctx.request.query) {
-      try {
-        ctx.request.query = validateQuery(ctx.request.query, schema.query);
-      } catch (error) {
-        errors.query = formatValidationError(error);
-      }
-    }
-    if (schema.body) {
-      try {
-        ctx.request.body = validateBody(ctx.request.body, schema.body);
-      } catch (error) {
-        errors.body = formatValidationError(error);
-      }
-    }
-    if (Object.keys(errors).length > 0) {
-      ctx.response.status(400).json({
-        error: "Validation Error",
-        details: errors
-      });
-      return;
+function getProtocol(req) {
+  const encrypted = req.socket && req.socket.encrypted;
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  if (forwardedProto) {
+    if (Array.isArray(forwardedProto)) {
+      return forwardedProto[0]?.split(",")[0]?.trim() || "http";
+    } else {
+      return forwardedProto.split(",")[0]?.trim() || "http";
     }
-    await next();
+  }
+  return encrypted ? "https" : "http";
+}
+async function createContext(req, res, options = {}) {
+  const { path: path5, url, query } = parseRequestUrl(req);
+  const method = req.method || "GET";
+  const isHttp2 = isHttp2Request(req);
+  const protocol = getProtocol(req);
+  const params = {};
+  const state = { ...options.initialState || {} };
+  const responseState = { sent: false };
+  const ctx = {
+    request: createRequestObject(req, {
+      path: path5,
+      url,
+      query,
+      params,
+      method,
+      isHttp2,
+      protocol
+    }),
+    response: {},
+    state
   };
+  ctx.response = createResponseObject(res, responseState, ctx);
+  if (options.parseBody) {
+    await parseBodyIfNeeded(req, ctx);
+  }
+  return ctx;
+}
+function createRequestObject(req, info) {
   return {
-    name: "RequestValidator",
-    execute: middlewareFn,
-    debug
+    raw: req,
+    ...info,
+    header: createRequestHeaderGetter(req),
+    headers: createRequestHeadersGetter(req),
+    body: void 0
   };
 }
-function createResponseValidator(responseSchema, debug = false) {
-  const middlewareFn = async (ctx, next) => {
-    const originalJson = ctx.response.json;
-    ctx.response.json = (body, status) => {
-      try {
-        const validatedBody = validateResponse(body, responseSchema);
-        ctx.response.json = originalJson;
-        return originalJson.call(ctx.response, validatedBody, status);
-      } catch (error) {
-        ctx.response.json = originalJson;
-        console.error("Response validation error:", error);
-        ctx.response.status(500).json({
-          error: "Internal Server Error",
-          message: "Response validation failed"
-        });
-        return ctx.response;
-      }
-    };
-    await next();
+function createRequestHeaderGetter(req) {
+  return (name) => {
+    const value = req.headers[name.toLowerCase()];
+    if (Array.isArray(value)) {
+      return value.join(", ");
+    }
+    return value || void 0;
+  };
+}
+function createRequestHeadersGetter(req) {
+  const headerGetter = createRequestHeaderGetter(req);
+  return (names) => {
+    if (names && Array.isArray(names) && names.length > 0) {
+      return names.reduce((acc, name) => {
+        acc[name] = headerGetter(name);
+        return acc;
+      }, {});
+    } else {
+      return Object.entries(req.headers).reduce(
+        (acc, [key, value]) => {
+          acc[key] = Array.isArray(value) ? value.join(", ") : value || void 0;
+          return acc;
+        },
+        {}
+      );
+    }
   };
+}
+function createResponseObject(res, responseState, ctx) {
   return {
-    name: "ResponseValidator",
-    execute: middlewareFn,
-    debug
+    raw: res,
+    get sent() {
+      return responseState.sent;
+    },
+    status: createStatusSetter(res, responseState, ctx),
+    header: createHeaderSetter(res, responseState, ctx),
+    headers: createHeadersSetter(res, responseState, ctx),
+    type: createContentTypeSetter(res, responseState, ctx),
+    json: createJsonResponder(res, responseState),
+    text: createTextResponder(res, responseState),
+    html: createHtmlResponder(res, responseState),
+    redirect: createRedirectResponder(res, responseState),
+    stream: createStreamResponder(res, responseState)
   };
 }
-function formatValidationError(error) {
-  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
-    return error.format();
-  }
-  return error instanceof Error ? error.message : String(error);
+function createStatusSetter(res, responseState, ctx) {
+  return function statusSetter(code) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    res.statusCode = code;
+    return ctx.response;
+  };
 }
-
-// src/router/handlers/executor.ts
-async function executeHandler(ctx, routeOptions, params) {
-  const middleware = [...routeOptions.middleware || []];
-  if (routeOptions.schema) {
-    if (routeOptions.schema.params || routeOptions.schema.query || routeOptions.schema.body) {
-      middleware.unshift(createRequestValidator(routeOptions.schema));
+function createHeaderSetter(res, responseState, ctx) {
+  return function headerSetter(name, value) {
+    if (responseState.sent) {
+      throw new ResponseSentHeaderError();
     }
-    if (routeOptions.schema.response) {
-      middleware.push(createResponseValidator(routeOptions.schema.response));
+    res.setHeader(name, value);
+    return ctx.response;
+  };
+}
+function createHeadersSetter(res, responseState, ctx) {
+  return function headersSetter(headers) {
+    if (responseState.sent) {
+      throw new ResponseSentHeaderError();
     }
-  }
-  const handler = compose([...middleware]);
-  await handler(ctx, async () => {
-    const result = await routeOptions.handler(ctx, params);
-    if (!ctx.response.sent && result !== void 0) {
-      ctx.response.json(result);
+    for (const [name, value] of Object.entries(headers)) {
+      res.setHeader(name, value);
     }
-  });
+    return ctx.response;
+  };
 }
-
-// src/router/matching/params.ts
-function extractParams(path5, pattern, paramNames) {
-  const match = pattern.exec(path5);
-  if (!match) {
-    return {};
-  }
-  const params = {};
-  for (let i = 0; i < paramNames.length; i++) {
-    params[paramNames[i]] = match[i + 1] || "";
-  }
-  return params;
+function createContentTypeSetter(res, responseState, ctx) {
+  return function typeSetter(type) {
+    if (responseState.sent) {
+      throw new ResponseSentContentError();
+    }
+    res.setHeader(CONTENT_TYPE_HEADER, type);
+    return ctx.response;
+  };
 }
-function compilePathPattern(path5) {
-  const paramNames = [];
-  if (path5 === "/") {
-    return {
-      pattern: /^\/$/,
-      paramNames: []
-    };
-  }
-  let patternString = path5.replace(/([.+*?^$(){}|\\])/g, "\\$1");
-  patternString = patternString.replace(/\/:([^/]+)/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return "/([^/]+)";
-  }).replace(/\/\[([^\]]+)\]/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return "/([^/]+)";
-  });
-  patternString = `${patternString}(?:/)?`;
-  const pattern = new RegExp(`^${patternString}$`);
-  return {
-    pattern,
-    paramNames
+function createJsonResponder(res, responseState) {
+  return function jsonResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (status !== void 0) {
+      res.statusCode = status;
+    }
+    res.setHeader(CONTENT_TYPE_HEADER, "application/json");
+    res.end(JSON.stringify(body));
+    responseState.sent = true;
   };
 }
-
-// src/router/matching/matcher.ts
-function createMatcher() {
-  const routes = [];
-  return {
-    /**
-     * Add a route to the matcher
-     */
-    add(path5, method, routeOptions) {
-      const { pattern, paramNames } = compilePathPattern(path5);
-      const newRoute = {
-        path: path5,
-        method,
-        pattern,
-        paramNames,
-        routeOptions
-      };
-      const insertIndex = routes.findIndex((route) => paramNames.length < route.paramNames.length);
-      if (insertIndex === -1) {
-        routes.push(newRoute);
-      } else {
-        routes.splice(insertIndex, 0, newRoute);
-      }
-    },
-    /**
-     * Match a URL path to a route
-     */
-    match(path5, method) {
-      const pathname = path5.split("?")[0];
-      if (!pathname) return null;
-      for (const route of routes) {
-        if (route.method !== method) continue;
-        const match = route.pattern.exec(pathname);
-        if (match) {
-          const params = extractParams(path5, route.pattern, route.paramNames);
-          return {
-            route: route.routeOptions,
-            params
-          };
-        }
-      }
-      const matchingPath = routes.find(
-        (route) => route.method !== method && route.pattern.test(path5)
-      );
-      if (matchingPath) {
-        return {
-          route: null,
-          params: {},
-          methodNotAllowed: true,
-          allowedMethods: routes.filter((route) => route.pattern.test(path5)).map((route) => route.method)
-        };
-      }
-      return null;
-    },
-    /**
-     * Get all registered routes
-     */
-    getRoutes() {
-      return routes.map((route) => ({
-        path: route.path,
-        method: route.method
-      }));
-    },
-    /**
-     * Find routes matching a specific path
-     */
-    findRoutes(path5) {
-      return routes.filter((route) => route.pattern.test(path5)).map((route) => ({
-        path: route.path,
-        method: route.method,
-        params: extractParams(path5, route.pattern, route.paramNames)
-      }));
+function createTextResponder(res, responseState) {
+  return function textResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (status !== void 0) {
+      res.statusCode = status;
     }
+    res.setHeader(CONTENT_TYPE_HEADER, "text/plain");
+    res.end(body);
+    responseState.sent = true;
   };
 }
-
-// src/router/router.ts
-var DEFAULT_ROUTER_OPTIONS = {
-  routesDir: "./routes",
-  basePath: "/",
-  watchMode: process.env.NODE_ENV === "development"
-};
-function createRouter(options) {
-  const routerOptions = {
-    ...DEFAULT_ROUTER_OPTIONS,
-    ...options
+function createHtmlResponder(res, responseState) {
+  return function htmlResponder(body, status) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (status !== void 0) {
+      res.statusCode = status;
+    }
+    res.setHeader(CONTENT_TYPE_HEADER, "text/html");
+    res.end(body);
+    responseState.sent = true;
   };
-  if (options.basePath && !options.basePath.startsWith("/")) {
-    console.warn("Base path does nothing");
-  }
-  const routes = [];
-  const matcher = createMatcher();
-  let initialized = false;
-  let initializationPromise = null;
-  let _watcher = null;
-  async function initialize() {
-    if (initialized || initializationPromise) {
-      return initializationPromise;
+}
+function createRedirectResponder(res, responseState) {
+  return function redirectResponder(url, status = 302) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
     }
-    initializationPromise = (async () => {
-      try {
-        const discoveredRoutes = await findRoutes(routerOptions.routesDir, {
-          basePath: routerOptions.basePath
-        });
-        for (const route of discoveredRoutes) {
-          addRouteInternal(route);
-        }
-        if (routerOptions.watchMode) {
-          setupWatcher();
-        }
-        initialized = true;
-      } catch (error) {
-        console.error("Failed to initialize router:", error);
-        throw error;
+    res.statusCode = status;
+    res.setHeader("Location", url);
+    res.end();
+    responseState.sent = true;
+  };
+}
+function createStreamResponder(res, responseState) {
+  return function streamResponder(readable, options = {}) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    if (options.status !== void 0) {
+      res.statusCode = options.status;
+    }
+    if (options.contentType) {
+      res.setHeader(CONTENT_TYPE_HEADER, options.contentType);
+    }
+    if (options.headers) {
+      for (const [name, value] of Object.entries(options.headers)) {
+        res.setHeader(name, value);
       }
-    })();
-    return initializationPromise;
-  }
-  function addRouteInternal(route) {
-    routes.push(route);
-    Object.entries(route).forEach(([method, methodOptions]) => {
-      if (method === "path" || !methodOptions) return;
-      matcher.add(route.path, method, methodOptions);
+    }
+    readable.pipe(res);
+    readable.on("end", () => {
+      responseState.sent = true;
     });
-  }
-  function setupWatcher() {
-    _watcher = watchRoutes(routerOptions.routesDir, {
-      ignore: ["node_modules", ".git"],
-      onRouteAdded: (addedRoutes) => {
-        console.log(
-          `${addedRoutes.length} route(s) added:`,
-          addedRoutes.map((r) => r.path)
-        );
-        addedRoutes.forEach((route) => addRouteInternal(route));
-      },
-      onRouteChanged: (changedRoutes) => {
-        console.log(
-          `${changedRoutes.length} route(s) changed:`,
-          changedRoutes.map((r) => r.path)
-        );
-        changedRoutes.forEach((route) => {
-          const index = routes.findIndex((r) => r.path === route.path);
-          if (index >= 0) {
-            routes.splice(index, 1);
-          }
-          addRouteInternal(route);
-        });
-      },
-      onRouteRemoved: (filePath, removedRoutes) => {
-        console.log("-----------------------Routes before removal:", routes);
-        console.log(
-          `File removed: ${filePath} with ${removedRoutes.length} route(s):`,
-          removedRoutes.map((r) => r.path)
-        );
-        removedRoutes.forEach((route) => {
-          const index = routes.findIndex((r) => r.path === route.path);
-          if (index >= 0) {
-            routes.splice(index, 1);
-          }
-        });
-        console.log("-----------------------Routes after removal:", routes);
-      },
-      onError: (error) => {
-        console.error("Route watcher error:", error);
+    readable.on("error", (err) => {
+      console.error("Stream error:", err);
+      if (!responseState.sent) {
+        res.statusCode = 500;
+        res.end("Stream error");
+        responseState.sent = true;
       }
     });
+  };
+}
+async function parseBodyIfNeeded(req, ctx) {
+  if (shouldSkipParsing(req.method)) {
+    return;
   }
-  initialize().catch((error) => {
-    console.error("Failed to initialize router on creation:", error);
-  });
-  return {
-    /**
-     * Handle an incoming request
-     */
-    async handleRequest(ctx) {
-      if (!initialized) {
-        await initialize();
-      }
-      const { method, path: path5 } = ctx.request;
-      const match = matcher.match(path5, method);
-      if (!match) {
-        ctx.response.status(404).json({ error: "Not Found" });
-        return;
+  const contentType = req.headers["content-type"] || "";
+  const contentLength = parseInt(req.headers["content-length"] || "0", 10);
+  if (contentLength === 0 || contentLength > 1048576) {
+    return;
+  }
+  try {
+    await parseBodyByContentType(req, ctx, contentType);
+  } catch (error) {
+    setBodyError(ctx, "body_read_error", "Error reading request body", error);
+  }
+}
+function shouldSkipParsing(method) {
+  const skipMethods = ["GET", "HEAD", "OPTIONS"];
+  return skipMethods.includes(method || "GET");
+}
+async function parseBodyByContentType(req, ctx, contentType) {
+  if (contentType.includes("application/json")) {
+    await parseJsonBody(req, ctx);
+  } else if (contentType.includes("application/x-www-form-urlencoded")) {
+    await parseFormUrlEncodedBody(req, ctx);
+  } else if (contentType.includes("text/")) {
+    await parseTextBody(req, ctx);
+  }
+}
+async function parseJsonBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (!body) {
+    console.warn("Empty body, skipping JSON parsing");
+    return;
+  }
+  if (body.trim() === "null") {
+    console.warn('Body is the string "null"');
+    ctx.request.body = null;
+    return;
+  }
+  try {
+    const json = JSON.parse(body);
+    ctx.request.body = json;
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "json_parse_error", "Invalid JSON in request body", error);
+  }
+}
+async function parseFormUrlEncodedBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (!body) return;
+  try {
+    ctx.request.body = parseUrlEncodedData(body);
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "form_parse_error", "Invalid form data in request body", error);
+  }
+}
+function parseUrlEncodedData(body) {
+  const params = new URLSearchParams(body);
+  const formData = {};
+  params.forEach((value, key) => {
+    if (formData[key] !== void 0) {
+      if (Array.isArray(formData[key])) {
+        formData[key].push(value);
+      } else {
+        formData[key] = [formData[key], value];
       }
-      if (match.methodNotAllowed) {
-        ctx.response.status(405).json({
-          error: "Method Not Allowed",
-          allowed: match.allowedMethods
-        });
-        if (match.allowedMethods && match.allowedMethods.length > 0) {
-          ctx.response.header("Allow", match.allowedMethods.join(", "));
+    } else {
+      formData[key] = value;
+    }
+  });
+  return formData;
+}
+async function parseTextBody(req, ctx) {
+  const body = await readRequestBody(req);
+  if (body) {
+    ctx.request.body = body;
+  }
+}
+function setBodyError(ctx, type, message, error) {
+  ctx.state._bodyError = { type, message, error };
+}
+async function readRequestBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      resolve2(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/server/request-handler.ts
+function createRequestHandler(serverInstance) {
+  return async (req, res) => {
+    try {
+      const context = await createContext(req, res, {
+        parseBody: true
+        // Enable automatic body parsing
+      });
+      const handler = compose(serverInstance.middleware);
+      await runWithContext(context, async () => {
+        try {
+          await handler(context, async () => {
+            if (!context.response.sent) {
+              await serverInstance.router.handleRequest(context);
+              if (!context.response.sent) {
+                context.response.status(404).json({
+                  error: "Not Found",
+                  message: `Route not found: ${context.request.method} ${context.request.path}`
+                });
+              }
+            }
+          });
+        } catch (error) {
+          console.error("Error processing request:", error);
+          if (!context.response.sent) {
+            context.response.json(
+              {
+                error: "Internal Server Error",
+                message: process.env.NODE_ENV === "development" ? error || "Unknown error" : "An error occurred processing your request"
+              },
+              500
+            );
+          }
         }
-        return;
-      }
-      ctx.request.params = match.params;
-      try {
-        await executeHandler(ctx, match.route, match.params);
-      } catch (error) {
-        handleRouteError(ctx, error, {
-          detailed: process.env.NODE_ENV !== "production",
-          log: true
-        });
-      }
-    },
-    /**
-     * Get all registered routes
-     */
-    getRoutes() {
-      return [...routes];
-    },
-    /**
-     * Add a route programmatically
-     */
-    addRoute(route) {
-      addRouteInternal(route);
+      });
+    } catch (error) {
+      console.error("Error creating context:", error);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "Internal Server Error",
+          message: "Failed to process request"
+        })
+      );
     }
   };
 }
 
-// src/config.ts
-var config = {};
-function setRuntimeConfig(newConfig) {
-  config = { ...config, ...newConfig };
-}
-function getRoutesDir() {
-  if (!config.routesDir) {
-    throw new Error("Routes directory not configured. Make sure server is properly initialized.");
+// src/server/start.ts
+async function prepareCertificates(http2Options) {
+  if (!http2Options.enabled) {
+    return {};
   }
-  return config.routesDir;
+  const { keyFile, certFile } = http2Options;
+  const isDevMode = process.env.NODE_ENV === "development";
+  const certificatesMissing = !keyFile || !certFile;
+  if (certificatesMissing && isDevMode) {
+    const devCerts = await generateDevCertificates();
+    return devCerts;
+  }
+  if (certificatesMissing) {
+    throw new Error(
+      "HTTP/2 requires SSL certificates. Provide keyFile and certFile in http2 options. In development, set NODE_ENV=development to generate them automatically."
+    );
+  }
+  return { keyFile, certFile };
 }
-
-// src/router/create.ts
-function getCallerFilePath() {
-  const originalPrepareStackTrace = Error.prepareStackTrace;
+function createServerInstance(isHttp2, certOptions) {
+  if (!isHttp2) {
+    return http.createServer();
+  }
+  const http2ServerOptions = {
+    allowHTTP1: true
+    // Allow fallback to HTTP/1.1
+  };
   try {
-    Error.prepareStackTrace = (_, stack2) => stack2;
-    const stack = new Error().stack;
-    const callerFrame = stack[2];
-    if (!callerFrame || typeof callerFrame.getFileName !== "function") {
-      throw new Error("Unable to determine caller file frame");
+    if (certOptions.keyFile) {
+      http2ServerOptions.key = fs2.readFileSync(certOptions.keyFile);
     }
-    const fileName = callerFrame.getFileName();
-    if (!fileName) {
-      throw new Error("Unable to determine caller file name");
+    if (certOptions.certFile) {
+      http2ServerOptions.cert = fs2.readFileSync(certOptions.certFile);
     }
-    return fileName;
-  } finally {
-    Error.prepareStackTrace = originalPrepareStackTrace;
+  } catch (err) {
+    throw new Error(
+      `Failed to read certificate files: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
+  return http2.createSecureServer(http2ServerOptions);
 }
-function getRoutePath() {
-  const callerPath = getCallerFilePath();
-  const routesDir = getRoutesDir();
-  const parsedRoute = parseRoutePath(callerPath, routesDir);
-  return parsedRoute.routePath;
+function listenOnPort(server, port, host, isHttp2) {
+  return new Promise((resolve2, reject) => {
+    server.listen(port, host, () => {
+      const protocol = isHttp2 ? "https" : "http";
+      const url = `${protocol}://${host}:${port}`;
+      console.log(`
+\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}
+
+    \u26A1 BlaizeJS DEVELOPMENT SERVER HOT AND READY \u26A1
+    
+    \u{1F680} Server: ${url}
+    \u{1F525} Hot Reload: Enabled
+    \u{1F6E0}\uFE0F  Mode: Development
+    
+    Time to build something amazing! \u{1F680}
+
+\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}
+`);
+      resolve2();
+    });
+    server.on("error", (err) => {
+      console.error("Server error:", err);
+      reject(err);
+    });
+  });
 }
-var createGetRoute = (config2) => {
-  validateMethodConfig("GET", config2);
-  const path5 = getRoutePath();
-  return {
-    GET: config2,
-    path: path5
-  };
-};
-var createPostRoute = (config2) => {
-  validateMethodConfig("POST", config2);
-  const path5 = getRoutePath();
-  return {
-    POST: config2,
-    path: path5
-  };
-};
-var createPutRoute = (config2) => {
-  validateMethodConfig("PUT", config2);
-  const path5 = getRoutePath();
-  return {
-    PUT: config2,
-    path: path5
-  };
-};
-var createDeleteRoute = (config2) => {
-  validateMethodConfig("DELETE", config2);
-  const path5 = getRoutePath();
-  return {
-    DELETE: config2,
-    path: path5
-  };
-};
-var createPatchRoute = (config2) => {
-  validateMethodConfig("PATCH", config2);
-  const path5 = getRoutePath();
-  return {
-    PATCH: config2,
-    path: path5
-  };
-};
-var createHeadRoute = (config2) => {
-  validateMethodConfig("HEAD", config2);
-  const path5 = getRoutePath();
-  return {
-    HEAD: config2,
-    path: path5
-  };
-};
-var createOptionsRoute = (config2) => {
-  validateMethodConfig("OPTIONS", config2);
-  const path5 = getRoutePath();
-  return {
-    OPTIONS: config2,
-    path: path5
-  };
-};
-function validateMethodConfig(method, config2) {
-  if (!config2.handler || typeof config2.handler !== "function") {
-    throw new Error(`Handler for method ${method} must be a function`);
+async function initializePlugins(serverInstance) {
+  for (const plugin of serverInstance.plugins) {
+    if (typeof plugin.initialize === "function") {
+      await plugin.initialize(serverInstance);
+    }
   }
-  if (config2.middleware && !Array.isArray(config2.middleware)) {
-    throw new Error(`Middleware for method ${method} must be an array`);
+}
+async function startServer(serverInstance, serverOptions) {
+  if (serverInstance.server) {
+    return;
   }
-  if (config2.schema) {
-    validateSchema(method, config2.schema);
+  try {
+    const port = serverOptions.port;
+    const host = serverOptions.host;
+    await initializePlugins(serverInstance);
+    const http2Options = serverOptions.http2 || { enabled: true };
+    const isHttp2 = !!http2Options.enabled;
+    const certOptions = await prepareCertificates(http2Options);
+    if (serverOptions.http2 && certOptions.keyFile && certOptions.certFile) {
+      serverOptions.http2.keyFile = certOptions.keyFile;
+      serverOptions.http2.certFile = certOptions.certFile;
+    }
+    const server = createServerInstance(isHttp2, certOptions);
+    serverInstance.server = server;
+    serverInstance.port = port;
+    serverInstance.host = host;
+    const requestHandler = createRequestHandler(serverInstance);
+    server.on("request", requestHandler);
+    await listenOnPort(server, port, host, isHttp2);
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    throw error;
   }
-  switch (method) {
-    case "GET":
-    case "HEAD":
-    case "DELETE":
-      if (config2.schema?.body) {
-        console.warn(`Warning: ${method} requests typically don't have request bodies`);
-      }
-      break;
+}
+
+// src/server/stop.ts
+async function stopServer(serverInstance, options = {}) {
+  const server = serverInstance.server;
+  const events = serverInstance.events;
+  if (!server) {
+    return;
+  }
+  const timeout = options.timeout || 3e4;
+  try {
+    if (options.onStopping) {
+      await options.onStopping();
+    }
+    events.emit("stopping");
+    await serverInstance.pluginManager.onServerStop(serverInstance, server);
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error("Server shutdown timed out waiting for requests to complete"));
+      }, timeout);
+    });
+    const closePromise = new Promise((resolve2, reject) => {
+      server.close((err) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve2();
+      });
+    });
+    await Promise.race([closePromise, timeoutPromise]);
+    await serverInstance.pluginManager.terminatePlugins(serverInstance);
+    if (options.onStopped) {
+      await options.onStopped();
+    }
+    events.emit("stopped");
+    serverInstance.server = null;
+  } catch (error) {
+    events.emit("error", error);
+    throw error;
   }
 }
-function validateSchema(method, schema) {
-  const { params, query, body, response } = schema;
-  if (params && (!params._def || typeof params.parse !== "function")) {
-    throw new Error(`Params schema for ${method} must be a valid Zod schema`);
+function registerSignalHandlers(stopFn) {
+  const sigintHandler = () => stopFn().catch(console.error);
+  const sigtermHandler = () => stopFn().catch(console.error);
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  return {
+    unregister: () => {
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+    }
+  };
+}
+
+// src/server/validation.ts
+import { z } from "zod";
+var middlewareSchema = z.custom(
+  (data) => data !== null && typeof data === "object" && "execute" in data && typeof data.execute === "function",
+  {
+    message: "Expected middleware to have an execute function"
   }
-  if (query && (!query._def || typeof query.parse !== "function")) {
-    throw new Error(`Query schema for ${method} must be a valid Zod schema`);
+);
+var pluginSchema = z.custom(
+  (data) => data !== null && typeof data === "object" && "register" in data && typeof data.register === "function",
+  {
+    message: "Expected a valid plugin object with a register method"
   }
-  if (body && (!body._def || typeof body.parse !== "function")) {
-    throw new Error(`Body schema for ${method} must be a valid Zod schema`);
+);
+var http2Schema = z.object({
+  enabled: z.boolean().optional().default(true),
+  keyFile: z.string().optional(),
+  certFile: z.string().optional()
+}).refine(
+  (data) => {
+    if (data.enabled && process.env.NODE_ENV === "production") {
+      return data.keyFile && data.certFile;
+    }
+    return true;
+  },
+  {
+    message: "When HTTP/2 is enabled (outside of development mode), both keyFile and certFile must be provided"
   }
-  if (response && (!response._def || typeof response.parse !== "function")) {
-    throw new Error(`Response schema for ${method} must be a valid Zod schema`);
+);
+var serverOptionsSchema = z.object({
+  port: z.number().int().positive().optional().default(3e3),
+  host: z.string().optional().default("localhost"),
+  routesDir: z.string().optional().default("./routes"),
+  http2: http2Schema.optional().default({
+    enabled: true
+  }),
+  middleware: z.array(middlewareSchema).optional().default([]),
+  plugins: z.array(pluginSchema).optional().default([])
+});
+function validateServerOptions(options) {
+  try {
+    return serverOptionsSchema.parse(options);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const formattedError = error.format();
+      throw new Error(`Invalid server options: ${JSON.stringify(formattedError, null, 2)}`);
+    }
+    throw new Error(`Invalid server options: ${String(error)}`);
   }
 }
 
-// src/server/create.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import EventEmitter from "node:events";
-
-// src/server/start.ts
-import * as fs3 from "node:fs";
-import * as http from "node:http";
-import * as http2 from "node:http2";
-
-// src/server/dev-certificate.ts
-import * as fs2 from "node:fs";
-import * as path4 from "node:path";
-import * as selfsigned from "selfsigned";
-async function generateDevCertificates() {
-  const certDir = path4.join(process.cwd(), ".blaizejs", "certs");
-  const keyPath = path4.join(certDir, "dev.key");
-  const certPath = path4.join(certDir, "dev.cert");
-  if (fs2.existsSync(keyPath) && fs2.existsSync(certPath)) {
-    return {
-      keyFile: keyPath,
-      certFile: certPath
-    };
-  }
-  if (!fs2.existsSync(certDir)) {
-    fs2.mkdirSync(certDir, { recursive: true });
+// src/plugins/lifecycle.ts
+function createPluginLifecycleManager(options = {}) {
+  const { continueOnError = true, debug = false, onError } = options;
+  function log(message, ...args) {
+    if (debug) {
+      console.log(`[PluginLifecycle] ${message}`, ...args);
+    }
+  }
+  function handleError(plugin, phase, error) {
+    const errorMessage = `Plugin ${plugin.name} failed during ${phase}: ${error.message}`;
+    if (onError) {
+      onError(plugin, phase, error);
+    } else {
+      console.error(errorMessage, error);
+    }
+    if (!continueOnError) {
+      throw new Error(errorMessage);
+    }
   }
-  const attrs = [{ name: "commonName", value: "localhost" }];
-  const options = {
-    days: 365,
-    algorithm: "sha256",
-    keySize: 2048,
-    extensions: [
-      { name: "basicConstraints", cA: true },
-      {
-        name: "keyUsage",
-        keyCertSign: true,
-        digitalSignature: true,
-        nonRepudiation: true,
-        keyEncipherment: true,
-        dataEncipherment: true
-      },
-      {
-        name: "extKeyUsage",
-        serverAuth: true,
-        clientAuth: true
-      },
-      {
-        name: "subjectAltName",
-        altNames: [
-          { type: 2, value: "localhost" },
-          { type: 7, ip: "127.0.0.1" }
-        ]
-      }
-    ]
-  };
-  const pems = selfsigned.generate(attrs, options);
-  fs2.writeFileSync(keyPath, Buffer.from(pems.private, "utf-8"));
-  fs2.writeFileSync(certPath, Buffer.from(pems.cert, "utf-8"));
-  console.log(`
-\u{1F512} Generated self-signed certificates for development at ${certDir}
-`);
   return {
-    keyFile: keyPath,
-    certFile: certPath
+    /**
+     * Initialize all plugins
+     */
+    async initializePlugins(server) {
+      log("Initializing plugins...");
+      for (const plugin of server.plugins) {
+        if (plugin.initialize) {
+          try {
+            log(`Initializing plugin: ${plugin.name}`);
+            await plugin.initialize(server);
+          } catch (error) {
+            handleError(plugin, "initialize", error);
+          }
+        }
+      }
+      log(`Initialized ${server.plugins.length} plugins`);
+    },
+    /**
+     * Terminate all plugins in reverse order
+     */
+    async terminatePlugins(server) {
+      log("Terminating plugins...");
+      const pluginsToTerminate = [...server.plugins].reverse();
+      for (const plugin of pluginsToTerminate) {
+        if (plugin.terminate) {
+          try {
+            log(`Terminating plugin: ${plugin.name}`);
+            await plugin.terminate(server);
+          } catch (error) {
+            handleError(plugin, "terminate", error);
+          }
+        }
+      }
+      log(`Terminated ${pluginsToTerminate.length} plugins`);
+    },
+    /**
+     * Notify plugins that the server has started
+     */
+    async onServerStart(server, httpServer) {
+      log("Notifying plugins of server start...");
+      for (const plugin of server.plugins) {
+        if (plugin.onServerStart) {
+          try {
+            log(`Notifying plugin of server start: ${plugin.name}`);
+            await plugin.onServerStart(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStart", error);
+          }
+        }
+      }
+    },
+    /**
+     * Notify plugins that the server is stopping
+     */
+    async onServerStop(server, httpServer) {
+      log("Notifying plugins of server stop...");
+      const pluginsToNotify = [...server.plugins].reverse();
+      for (const plugin of pluginsToNotify) {
+        if (plugin.onServerStop) {
+          try {
+            log(`Notifying plugin of server stop: ${plugin.name}`);
+            await plugin.onServerStop(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStop", error);
+          }
+        }
+      }
+    }
   };
 }
 
-// src/context/errors.ts
-var ResponseSentError = class extends Error {
-  constructor(message = "\u274C Response has already been sent") {
-    super(message);
-    this.name = "ResponseSentError";
+// src/plugins/errors.ts
+var PluginValidationError = class extends Error {
+  constructor(pluginName, message) {
+    super(`Plugin validation error${pluginName ? ` for "${pluginName}"` : ""}: ${message}`);
+    this.pluginName = pluginName;
+    this.name = "PluginValidationError";
   }
 };
-var ResponseSentHeaderError = class extends ResponseSentError {
-  constructor(message = "Cannot set header after response has been sent") {
-    super(message);
+
+// src/plugins/validation.ts
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "core",
+  "server",
+  "router",
+  "middleware",
+  "context",
+  "blaize",
+  "blaizejs"
+]);
+var VALID_NAME_PATTERN = /^[a-z]([a-z0-9-]*[a-z0-9])?$/;
+var VALID_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9-.]+)?(?:\+[a-zA-Z0-9-.]+)?$/;
+function validatePlugin(plugin, options = {}) {
+  const { requireVersion = true, validateNameFormat = true, checkReservedNames = true } = options;
+  if (!plugin || typeof plugin !== "object") {
+    throw new PluginValidationError("", "Plugin must be an object");
+  }
+  const p = plugin;
+  if (!p.name || typeof p.name !== "string") {
+    throw new PluginValidationError("", "Plugin must have a name (string)");
+  }
+  if (validateNameFormat && !VALID_NAME_PATTERN.test(p.name)) {
+    throw new PluginValidationError(
+      p.name,
+      "Plugin name must be lowercase letters, numbers, and hyphens only"
+    );
   }
-};
-var ResponseSentContentError = class extends ResponseSentError {
-  constructor(message = "Cannot set content type after response has been sent") {
-    super(message);
+  if (checkReservedNames && RESERVED_NAMES.has(p.name.toLowerCase())) {
+    throw new PluginValidationError(p.name, `Plugin name "${p.name}" is reserved`);
   }
-};
-var ParseUrlError = class extends ResponseSentError {
-  constructor(message = "Invalide URL") {
-    super(message);
+  if (requireVersion) {
+    if (!p.version || typeof p.version !== "string") {
+      throw new PluginValidationError(p.name, "Plugin must have a version (string)");
+    }
+    if (!VALID_VERSION_PATTERN.test(p.version)) {
+      throw new PluginValidationError(
+        p.name,
+        'Plugin version must follow semantic versioning (e.g., "1.0.0")'
+      );
+    }
   }
-};
+  if (!p.register || typeof p.register !== "function") {
+    throw new PluginValidationError(p.name, "Plugin must have a register method (function)");
+  }
+  const lifecycleMethods = ["initialize", "terminate", "onServerStart", "onServerStop"];
+  for (const method of lifecycleMethods) {
+    if (p[method] && typeof p[method] !== "function") {
+      throw new PluginValidationError(p.name, `Plugin ${method} must be a function if provided`);
+    }
+  }
+}
 
-// src/context/store.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var contextStorage = new AsyncLocalStorage();
-function runWithContext(context, callback) {
-  return contextStorage.run(context, callback);
+// src/router/discovery/finder.ts
+import * as fs3 from "node:fs/promises";
+import * as path3 from "node:path";
+async function findRouteFiles(routesDir, options = {}) {
+  const absoluteDir = path3.isAbsolute(routesDir) ? routesDir : path3.resolve(process.cwd(), routesDir);
+  console.log("Creating router with routes directory:", absoluteDir);
+  try {
+    const stats = await fs3.stat(absoluteDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Route directory is not a directory: ${absoluteDir}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Route directory not found: ${absoluteDir}`);
+    }
+    throw error;
+  }
+  const routeFiles = [];
+  const ignore = options.ignore || ["node_modules", ".git"];
+  async function scanDirectory(dir) {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory() && ignore.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await scanDirectory(fullPath);
+      } else if (isRouteFile(entry.name)) {
+        routeFiles.push(fullPath);
+      }
+    }
+  }
+  await scanDirectory(absoluteDir);
+  return routeFiles;
+}
+function isRouteFile(filename) {
+  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js"));
 }
 
-// src/context/create.ts
-var CONTENT_TYPE_HEADER = "Content-Type";
-function parseRequestUrl(req) {
-  const originalUrl = req.url || "/";
-  const host = req.headers.host || "localhost";
-  const protocol = req.socket && req.socket.encrypted ? "https" : "http";
-  const fullUrl = `${protocol}://${host}${originalUrl.startsWith("/") ? "" : "/"}${originalUrl}`;
+// src/router/discovery/loader.ts
+async function dynamicImport(filePath) {
+  return import(filePath);
+}
+async function loadRouteModule(filePath, basePath) {
   try {
-    const url = new URL(fullUrl);
-    const path5 = url.pathname;
-    const query = {};
-    url.searchParams.forEach((value, key) => {
-      if (query[key] !== void 0) {
-        if (Array.isArray(query[key])) {
-          query[key].push(value);
-        } else {
-          query[key] = [query[key], value];
-        }
-      } else {
-        query[key] = value;
+    const parsedRoute = parseRoutePath(filePath, basePath);
+    console.log("parsedRoute:", parsedRoute);
+    const module = await dynamicImport(filePath);
+    console.log("Module exports:", Object.keys(module));
+    const routes = [];
+    if (module.default && typeof module.default === "object") {
+      console.log("Found default export:", module.default);
+      const route = {
+        ...module.default,
+        path: parsedRoute.routePath
+      };
+      routes.push(route);
+    }
+    Object.entries(module).forEach(([exportName, exportValue]) => {
+      if (exportName === "default" || !exportValue || typeof exportValue !== "object") {
+        return;
+      }
+      const potentialRoute = exportValue;
+      if (isValidRoute(potentialRoute)) {
+        console.log(`Found named route export: ${exportName}`, potentialRoute);
+        const route = {
+          ...potentialRoute,
+          // Use the route's own path if it has one, otherwise derive from file
+          path: parsedRoute.routePath
+        };
+        routes.push(route);
       }
     });
-    return { path: path5, url, query };
+    if (routes.length === 0) {
+      console.warn(`Route file ${filePath} does not export any valid route definitions`);
+      return [];
+    }
+    console.log(`Loaded ${routes.length} route(s) from ${filePath}`);
+    return routes;
   } catch (error) {
-    console.warn(`Invalid URL: ${fullUrl}`, error);
-    throw new ParseUrlError(`Invalid URL: ${fullUrl}`);
+    console.error(`Failed to load route module ${filePath}:`, error);
+    return [];
   }
 }
-function isHttp2Request(req) {
-  return "stream" in req || "httpVersionMajor" in req && req.httpVersionMajor === 2;
+function isValidRoute(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+  const hasHttpMethod = httpMethods.some(
+    (method) => obj[method] && typeof obj[method] === "object" && obj[method].handler
+  );
+  return hasHttpMethod;
 }
-function getProtocol(req) {
-  const encrypted = req.socket && req.socket.encrypted;
-  const forwardedProto = req.headers["x-forwarded-proto"];
-  if (forwardedProto) {
-    if (Array.isArray(forwardedProto)) {
-      return forwardedProto[0]?.split(",")[0]?.trim() || "http";
-    } else {
-      return forwardedProto.split(",")[0]?.trim() || "http";
+
+// src/router/discovery/index.ts
+async function findRoutes(routesDir, options = {}) {
+  const routeFiles = await findRouteFiles(routesDir, {
+    ignore: options.ignore
+  });
+  const routes = [];
+  for (const filePath of routeFiles) {
+    const moduleRoutes = await loadRouteModule(filePath, routesDir);
+    if (moduleRoutes.length > 0) {
+      routes.push(...moduleRoutes);
     }
   }
-  return encrypted ? "https" : "http";
+  return routes;
 }
-async function createContext(req, res, options = {}) {
-  const { path: path5, url, query } = parseRequestUrl(req);
-  const method = req.method || "GET";
-  const isHttp2 = isHttp2Request(req);
-  const protocol = getProtocol(req);
-  const params = {};
-  const state = { ...options.initialState || {} };
-  const responseState = { sent: false };
-  const ctx = {
-    request: createRequestObject(req, {
-      path: path5,
-      url,
-      query,
-      params,
-      method,
-      isHttp2,
-      protocol
-    }),
-    response: {},
-    state
-  };
-  ctx.response = createResponseObject(res, responseState, ctx);
-  if (options.parseBody) {
-    await parseBodyIfNeeded(req, ctx);
+
+// src/router/discovery/watchers.ts
+import * as path4 from "node:path";
+import { watch } from "chokidar";
+function watchRoutes(routesDir, options = {}) {
+  const routesByPath = /* @__PURE__ */ new Map();
+  async function loadInitialRoutes() {
+    try {
+      const files = await findRouteFiles(routesDir, {
+        ignore: options.ignore
+      });
+      for (const filePath of files) {
+        await loadAndNotify(filePath);
+      }
+    } catch (error) {
+      handleError(error);
+    }
   }
-  return ctx;
-}
-function createRequestObject(req, info) {
-  return {
-    raw: req,
-    ...info,
-    header: createRequestHeaderGetter(req),
-    headers: createRequestHeadersGetter(req),
-    body: void 0
-  };
-}
-function createRequestHeaderGetter(req) {
-  return (name) => {
-    const value = req.headers[name.toLowerCase()];
-    if (Array.isArray(value)) {
-      return value.join(", ");
+  async function loadAndNotify(filePath) {
+    try {
+      const routes = await loadRouteModule(filePath, routesDir);
+      if (!routes || routes.length === 0) {
+        return;
+      }
+      const existingRoutes = routesByPath.get(filePath);
+      if (existingRoutes) {
+        routesByPath.set(filePath, routes);
+        if (options.onRouteChanged) {
+          options.onRouteChanged(routes);
+        }
+      } else {
+        routesByPath.set(filePath, routes);
+        if (options.onRouteAdded) {
+          options.onRouteAdded(routes);
+        }
+      }
+    } catch (error) {
+      handleError(error);
     }
-    return value || void 0;
-  };
-}
-function createRequestHeadersGetter(req) {
-  const headerGetter = createRequestHeaderGetter(req);
-  return (names) => {
-    if (names && Array.isArray(names) && names.length > 0) {
-      return names.reduce((acc, name) => {
-        acc[name] = headerGetter(name);
-        return acc;
-      }, {});
+  }
+  function handleRemoved(filePath) {
+    const normalizedPath = path4.normalize(filePath);
+    const routes = routesByPath.get(normalizedPath);
+    if (routes && routes.length > 0 && options.onRouteRemoved) {
+      options.onRouteRemoved(normalizedPath, routes);
+    }
+    routesByPath.delete(normalizedPath);
+  }
+  function handleError(error) {
+    if (options.onError && error instanceof Error) {
+      options.onError(error);
     } else {
-      return Object.entries(req.headers).reduce(
-        (acc, [key, value]) => {
-          acc[key] = Array.isArray(value) ? value.join(", ") : value || void 0;
-          return acc;
-        },
-        {}
-      );
+      console.error("Route watcher error:", error);
     }
-  };
-}
-function createResponseObject(res, responseState, ctx) {
+  }
+  const watcher = watch(routesDir, {
+    ignored: [
+      /(^|[/\\])\../,
+      // Ignore dot files
+      /node_modules/,
+      ...options.ignore || []
+    ],
+    persistent: true,
+    ignoreInitial: false,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+  watcher.on("add", loadAndNotify).on("change", loadAndNotify).on("unlink", handleRemoved).on("error", handleError);
+  loadInitialRoutes().catch(handleError);
   return {
-    raw: res,
-    get sent() {
-      return responseState.sent;
+    /**
+     * Close the watcher
+     */
+    close: () => watcher.close(),
+    /**
+     * Get all currently loaded routes (flattened)
+     */
+    getRoutes: () => {
+      const allRoutes = [];
+      for (const routes of routesByPath.values()) {
+        allRoutes.push(...routes);
+      }
+      return allRoutes;
     },
-    status: createStatusSetter(res, responseState, ctx),
-    header: createHeaderSetter(res, responseState, ctx),
-    headers: createHeadersSetter(res, responseState, ctx),
-    type: createContentTypeSetter(res, responseState, ctx),
-    json: createJsonResponder(res, responseState),
-    text: createTextResponder(res, responseState),
-    html: createHtmlResponder(res, responseState),
-    redirect: createRedirectResponder(res, responseState),
-    stream: createStreamResponder(res, responseState)
-  };
-}
-function createStatusSetter(res, responseState, ctx) {
-  return function statusSetter(code) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    res.statusCode = code;
-    return ctx.response;
-  };
-}
-function createHeaderSetter(res, responseState, ctx) {
-  return function headerSetter(name, value) {
-    if (responseState.sent) {
-      throw new ResponseSentHeaderError();
-    }
-    res.setHeader(name, value);
-    return ctx.response;
-  };
-}
-function createHeadersSetter(res, responseState, ctx) {
-  return function headersSetter(headers) {
-    if (responseState.sent) {
-      throw new ResponseSentHeaderError();
-    }
-    for (const [name, value] of Object.entries(headers)) {
-      res.setHeader(name, value);
-    }
-    return ctx.response;
-  };
-}
-function createContentTypeSetter(res, responseState, ctx) {
-  return function typeSetter(type) {
-    if (responseState.sent) {
-      throw new ResponseSentContentError();
-    }
-    res.setHeader(CONTENT_TYPE_HEADER, type);
-    return ctx.response;
+    /**
+     * Get routes organized by file path
+     */
+    getRoutesByFile: () => new Map(routesByPath)
   };
 }
-function createJsonResponder(res, responseState) {
-  return function jsonResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    if (status !== void 0) {
-      res.statusCode = status;
-    }
-    res.setHeader(CONTENT_TYPE_HEADER, "application/json");
-    res.end(JSON.stringify(body));
-    responseState.sent = true;
+
+// src/router/handlers/error.ts
+function handleRouteError(ctx, error, options = {}) {
+  if (options.log) {
+    console.error("Route error:", error);
+  }
+  const status = getErrorStatus(error);
+  const response = {
+    error: getErrorType(error),
+    message: getErrorMessage(error)
   };
-}
-function createTextResponder(res, responseState) {
-  return function textResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+  if (options.detailed) {
+    if (error instanceof Error) {
+      response.stack = error.stack;
     }
-    if (status !== void 0) {
-      res.statusCode = status;
+    if (error && typeof error === "object" && "details" in error && error.details) {
+      response.details = error.details;
     }
-    res.setHeader(CONTENT_TYPE_HEADER, "text/plain");
-    res.end(body);
-    responseState.sent = true;
-  };
+  }
+  ctx.response.status(status).json(response);
 }
-function createHtmlResponder(res, responseState) {
-  return function htmlResponder(body, status) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+function getErrorStatus(error) {
+  if (error && typeof error === "object") {
+    if ("status" in error && typeof error.status === "number") {
+      return error.status;
     }
-    if (status !== void 0) {
-      res.statusCode = status;
+    if ("statusCode" in error && typeof error.statusCode === "number") {
+      return error.statusCode;
     }
-    res.setHeader(CONTENT_TYPE_HEADER, "text/html");
-    res.end(body);
-    responseState.sent = true;
-  };
-}
-function createRedirectResponder(res, responseState) {
-  return function redirectResponder(url, status = 302) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
+    if ("code" in error && typeof error.code === "string") {
+      return getStatusFromCode(error.code);
     }
-    res.statusCode = status;
-    res.setHeader("Location", url);
-    res.end();
-    responseState.sent = true;
-  };
+  }
+  return 500;
 }
-function createStreamResponder(res, responseState) {
-  return function streamResponder(readable, options = {}) {
-    if (responseState.sent) {
-      throw new ResponseSentError();
-    }
-    if (options.status !== void 0) {
-      res.statusCode = options.status;
+function getStatusFromCode(code) {
+  switch (code) {
+    case "NOT_FOUND":
+      return 404;
+    case "UNAUTHORIZED":
+      return 401;
+    case "FORBIDDEN":
+      return 403;
+    case "BAD_REQUEST":
+      return 400;
+    case "CONFLICT":
+      return 409;
+    default:
+      return 500;
+  }
+}
+function getErrorType(error) {
+  if (error && typeof error === "object") {
+    if ("type" in error && typeof error.type === "string") {
+      return error.type;
     }
-    if (options.contentType) {
-      res.setHeader(CONTENT_TYPE_HEADER, options.contentType);
+    if ("name" in error && typeof error.name === "string") {
+      return error.name;
     }
-    if (options.headers) {
-      for (const [name, value] of Object.entries(options.headers)) {
-        res.setHeader(name, value);
-      }
+    if (error instanceof Error) {
+      return error.constructor.name;
     }
-    readable.pipe(res);
-    readable.on("end", () => {
-      responseState.sent = true;
-    });
-    readable.on("error", (err) => {
-      console.error("Stream error:", err);
-      if (!responseState.sent) {
-        res.statusCode = 500;
-        res.end("Stream error");
-        responseState.sent = true;
-      }
-    });
-  };
-}
-async function parseBodyIfNeeded(req, ctx) {
-  if (shouldSkipParsing(req.method)) {
-    return;
   }
-  const contentType = req.headers["content-type"] || "";
-  const contentLength = parseInt(req.headers["content-length"] || "0", 10);
-  if (contentLength === 0 || contentLength > 1048576) {
-    return;
+  return "Error";
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  try {
-    await parseBodyByContentType(req, ctx, contentType);
-  } catch (error) {
-    setBodyError(ctx, "body_read_error", "Error reading request body", error);
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
   }
+  return String(error);
 }
-function shouldSkipParsing(method) {
-  const skipMethods = ["GET", "HEAD", "OPTIONS"];
-  return skipMethods.includes(method || "GET");
-}
-async function parseBodyByContentType(req, ctx, contentType) {
-  if (contentType.includes("application/json")) {
-    await parseJsonBody(req, ctx);
-  } else if (contentType.includes("application/x-www-form-urlencoded")) {
-    await parseFormUrlEncodedBody(req, ctx);
-  } else if (contentType.includes("text/")) {
-    await parseTextBody(req, ctx);
+
+// src/router/validation/body.ts
+import { z as z2 } from "zod";
+function validateBody(body, schema) {
+  if (schema instanceof z2.ZodObject) {
+    return schema.strict().parse(body);
   }
+  return schema.parse(body);
 }
-async function parseJsonBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (!body) {
-    console.warn("Empty body, skipping JSON parsing");
-    return;
-  }
-  if (body.trim() === "null") {
-    console.warn('Body is the string "null"');
-    ctx.request.body = null;
-    return;
+
+// src/router/validation/params.ts
+import { z as z3 } from "zod";
+function validateParams(params, schema) {
+  if (schema instanceof z3.ZodObject) {
+    return schema.strict().parse(params);
   }
-  try {
-    const json = JSON.parse(body);
-    ctx.request.body = json;
-  } catch (error) {
-    ctx.request.body = null;
-    setBodyError(ctx, "json_parse_error", "Invalid JSON in request body", error);
+  return schema.parse(params);
+}
+
+// src/router/validation/query.ts
+import { z as z4 } from "zod";
+function validateQuery(query, schema) {
+  if (schema instanceof z4.ZodObject) {
+    return schema.strict().parse(query);
   }
+  return schema.parse(query);
 }
-async function parseFormUrlEncodedBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (!body) return;
-  try {
-    ctx.request.body = parseUrlEncodedData(body);
-  } catch (error) {
-    ctx.request.body = null;
-    setBodyError(ctx, "form_parse_error", "Invalid form data in request body", error);
+
+// src/router/validation/response.ts
+import { z as z5 } from "zod";
+function validateResponse(response, schema) {
+  if (schema instanceof z5.ZodObject) {
+    return schema.strict().parse(response);
   }
+  return schema.parse(response);
 }
-function parseUrlEncodedData(body) {
-  const params = new URLSearchParams(body);
-  const formData = {};
-  params.forEach((value, key) => {
-    if (formData[key] !== void 0) {
-      if (Array.isArray(formData[key])) {
-        formData[key].push(value);
-      } else {
-        formData[key] = [formData[key], value];
+
+// src/router/validation/schema.ts
+function createRequestValidator(schema, debug = false) {
+  const middlewareFn = async (ctx, next) => {
+    const errors = {};
+    if (schema.params && ctx.request.params) {
+      try {
+        ctx.request.params = validateParams(ctx.request.params, schema.params);
+      } catch (error) {
+        errors.params = formatValidationError(error);
+      }
+    }
+    if (schema.query && ctx.request.query) {
+      try {
+        ctx.request.query = validateQuery(ctx.request.query, schema.query);
+      } catch (error) {
+        errors.query = formatValidationError(error);
+      }
+    }
+    if (schema.body) {
+      try {
+        ctx.request.body = validateBody(ctx.request.body, schema.body);
+      } catch (error) {
+        errors.body = formatValidationError(error);
+      }
+    }
+    if (Object.keys(errors).length > 0) {
+      ctx.response.status(400).json({
+        error: "Validation Error",
+        details: errors
+      });
+      return;
+    }
+    await next();
+  };
+  return {
+    name: "RequestValidator",
+    execute: middlewareFn,
+    debug
+  };
+}
+function createResponseValidator(responseSchema, debug = false) {
+  const middlewareFn = async (ctx, next) => {
+    const originalJson = ctx.response.json;
+    ctx.response.json = (body, status) => {
+      try {
+        const validatedBody = validateResponse(body, responseSchema);
+        ctx.response.json = originalJson;
+        return originalJson.call(ctx.response, validatedBody, status);
+      } catch (error) {
+        ctx.response.json = originalJson;
+        console.error("Response validation error:", error);
+        ctx.response.status(500).json({
+          error: "Internal Server Error",
+          message: "Response validation failed"
+        });
+        return ctx.response;
       }
-    } else {
-      formData[key] = value;
-    }
-  });
-  return formData;
+    };
+    await next();
+  };
+  return {
+    name: "ResponseValidator",
+    execute: middlewareFn,
+    debug
+  };
 }
-async function parseTextBody(req, ctx) {
-  const body = await readRequestBody(req);
-  if (body) {
-    ctx.request.body = body;
+function formatValidationError(error) {
+  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
+    return error.format();
   }
-}
-function setBodyError(ctx, type, message, error) {
-  ctx.state._bodyError = { type, message, error };
-}
-async function readRequestBody(req) {
-  return new Promise((resolve2, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    });
-    req.on("end", () => {
-      resolve2(Buffer.concat(chunks).toString("utf8"));
-    });
-    req.on("error", (err) => {
-      reject(err);
-    });
-  });
+  return error instanceof Error ? error.message : String(error);
 }
 
-// src/server/request-handler.ts
-function createRequestHandler(serverInstance) {
-  return async (req, res) => {
-    try {
-      const context = await createContext(req, res, {
-        parseBody: true
-        // Enable automatic body parsing
-      });
-      const handler = compose(serverInstance.middleware);
-      await runWithContext(context, async () => {
-        try {
-          await handler(context, async () => {
-            if (!context.response.sent) {
-              await serverInstance.router.handleRequest(context);
-              if (!context.response.sent) {
-                context.response.status(404).json({
-                  error: "Not Found",
-                  message: `Route not found: ${context.request.method} ${context.request.path}`
-                });
-              }
-            }
-          });
-        } catch (error) {
-          console.error("Error processing request:", error);
-          if (!context.response.sent) {
-            context.response.json(
-              {
-                error: "Internal Server Error",
-                message: process.env.NODE_ENV === "development" ? error || "Unknown error" : "An error occurred processing your request"
-              },
-              500
-            );
-          }
-        }
-      });
-    } catch (error) {
-      console.error("Error creating context:", error);
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          error: "Internal Server Error",
-          message: "Failed to process request"
-        })
-      );
+// src/router/handlers/executor.ts
+async function executeHandler(ctx, routeOptions, params) {
+  const middleware = [...routeOptions.middleware || []];
+  if (routeOptions.schema) {
+    if (routeOptions.schema.params || routeOptions.schema.query || routeOptions.schema.body) {
+      middleware.unshift(createRequestValidator(routeOptions.schema));
     }
-  };
+    if (routeOptions.schema.response) {
+      middleware.push(createResponseValidator(routeOptions.schema.response));
+    }
+  }
+  const handler = compose([...middleware]);
+  await handler(ctx, async () => {
+    const result = await routeOptions.handler(ctx, params);
+    if (!ctx.response.sent && result !== void 0) {
+      ctx.response.json(result);
+    }
+  });
 }
 
-// src/server/start.ts
-async function prepareCertificates(http2Options) {
-  if (!http2Options.enabled) {
+// src/router/matching/params.ts
+function extractParams(path5, pattern, paramNames) {
+  const match = pattern.exec(path5);
+  if (!match) {
     return {};
   }
-  const { keyFile, certFile } = http2Options;
-  const isDevMode = process.env.NODE_ENV === "development";
-  const certificatesMissing = !keyFile || !certFile;
-  if (certificatesMissing && isDevMode) {
-    const devCerts = await generateDevCertificates();
-    return devCerts;
-  }
-  if (certificatesMissing) {
-    throw new Error(
-      "HTTP/2 requires SSL certificates. Provide keyFile and certFile in http2 options. In development, set NODE_ENV=development to generate them automatically."
-    );
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    params[paramNames[i]] = match[i + 1] || "";
   }
-  return { keyFile, certFile };
+  return params;
 }
-function createServerInstance(isHttp2, certOptions) {
-  if (!isHttp2) {
-    return http.createServer();
+function compilePathPattern(path5) {
+  const paramNames = [];
+  if (path5 === "/") {
+    return {
+      pattern: /^\/$/,
+      paramNames: []
+    };
   }
-  const http2ServerOptions = {
-    allowHTTP1: true
-    // Allow fallback to HTTP/1.1
+  let patternString = path5.replace(/([.+*?^$(){}|\\])/g, "\\$1");
+  patternString = patternString.replace(/\/:([^/]+)/g, (_, paramName) => {
+    paramNames.push(paramName);
+    return "/([^/]+)";
+  }).replace(/\/\[([^\]]+)\]/g, (_, paramName) => {
+    paramNames.push(paramName);
+    return "/([^/]+)";
+  });
+  patternString = `${patternString}(?:/)?`;
+  const pattern = new RegExp(`^${patternString}$`);
+  return {
+    pattern,
+    paramNames
   };
-  try {
-    if (certOptions.keyFile) {
-      http2ServerOptions.key = fs3.readFileSync(certOptions.keyFile);
-    }
-    if (certOptions.certFile) {
-      http2ServerOptions.cert = fs3.readFileSync(certOptions.certFile);
-    }
-  } catch (err) {
-    throw new Error(
-      `Failed to read certificate files: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return http2.createSecureServer(http2ServerOptions);
 }
-function listenOnPort(server, port, host, isHttp2) {
-  return new Promise((resolve2, reject) => {
-    server.listen(port, host, () => {
-      const protocol = isHttp2 ? "https" : "http";
-      const url = `${protocol}://${host}:${port}`;
-      console.log(`
-\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}
-
-    \u26A1 BlaizeJS DEVELOPMENT SERVER HOT AND READY \u26A1
-    
-    \u{1F680} Server: ${url}
-    \u{1F525} Hot Reload: Enabled
-    \u{1F6E0}\uFE0F  Mode: Development
-    
-    Time to build something amazing! \u{1F680}
 
-\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}\u{1F525}
-`);
-      resolve2();
-    });
-    server.on("error", (err) => {
-      console.error("Server error:", err);
-      reject(err);
-    });
-  });
-}
-async function initializePlugins(serverInstance) {
-  for (const plugin of serverInstance.plugins) {
-    if (typeof plugin.initialize === "function") {
-      await plugin.initialize(serverInstance);
+// src/router/matching/matcher.ts
+function createMatcher() {
+  const routes = [];
+  return {
+    /**
+     * Add a route to the matcher
+     */
+    add(path5, method, routeOptions) {
+      const { pattern, paramNames } = compilePathPattern(path5);
+      const newRoute = {
+        path: path5,
+        method,
+        pattern,
+        paramNames,
+        routeOptions
+      };
+      const insertIndex = routes.findIndex((route) => paramNames.length < route.paramNames.length);
+      if (insertIndex === -1) {
+        routes.push(newRoute);
+      } else {
+        routes.splice(insertIndex, 0, newRoute);
+      }
+    },
+    /**
+     * Match a URL path to a route
+     */
+    match(path5, method) {
+      const pathname = path5.split("?")[0];
+      if (!pathname) return null;
+      for (const route of routes) {
+        if (route.method !== method) continue;
+        const match = route.pattern.exec(pathname);
+        if (match) {
+          const params = extractParams(path5, route.pattern, route.paramNames);
+          return {
+            route: route.routeOptions,
+            params
+          };
+        }
+      }
+      const matchingPath = routes.find(
+        (route) => route.method !== method && route.pattern.test(path5)
+      );
+      if (matchingPath) {
+        return {
+          route: null,
+          params: {},
+          methodNotAllowed: true,
+          allowedMethods: routes.filter((route) => route.pattern.test(path5)).map((route) => route.method)
+        };
+      }
+      return null;
+    },
+    /**
+     * Get all registered routes
+     */
+    getRoutes() {
+      return routes.map((route) => ({
+        path: route.path,
+        method: route.method
+      }));
+    },
+    /**
+     * Find routes matching a specific path
+     */
+    findRoutes(path5) {
+      return routes.filter((route) => route.pattern.test(path5)).map((route) => ({
+        path: route.path,
+        method: route.method,
+        params: extractParams(path5, route.pattern, route.paramNames)
+      }));
     }
-  }
+  };
 }
-async function startServer(serverInstance, serverOptions) {
-  if (serverInstance.server) {
-    return;
+
+// src/router/router.ts
+var DEFAULT_ROUTER_OPTIONS = {
+  routesDir: "./routes",
+  basePath: "/",
+  watchMode: process.env.NODE_ENV === "development"
+};
+function createRouter(options) {
+  const routerOptions = {
+    ...DEFAULT_ROUTER_OPTIONS,
+    ...options
+  };
+  if (options.basePath && !options.basePath.startsWith("/")) {
+    console.warn("Base path does nothing");
   }
-  try {
-    const port = serverOptions.port;
-    const host = serverOptions.host;
-    await initializePlugins(serverInstance);
-    const http2Options = serverOptions.http2 || { enabled: true };
-    const isHttp2 = !!http2Options.enabled;
-    const certOptions = await prepareCertificates(http2Options);
-    if (serverOptions.http2 && certOptions.keyFile && certOptions.certFile) {
-      serverOptions.http2.keyFile = certOptions.keyFile;
-      serverOptions.http2.certFile = certOptions.certFile;
+  const routes = [];
+  const matcher = createMatcher();
+  let initialized = false;
+  let initializationPromise = null;
+  let _watchers = null;
+  const routeSources = /* @__PURE__ */ new Map();
+  const routeDirectories = /* @__PURE__ */ new Set([routerOptions.routesDir]);
+  function addRouteWithSource(route, source) {
+    const existingSources = routeSources.get(route.path) || [];
+    if (existingSources.includes(source)) {
+      console.warn(`Skipping duplicate route: ${route.path} from ${source}`);
+      return;
     }
-    const server = createServerInstance(isHttp2, certOptions);
-    serverInstance.server = server;
-    serverInstance.port = port;
-    serverInstance.host = host;
-    const requestHandler = createRequestHandler(serverInstance);
-    server.on("request", requestHandler);
-    await listenOnPort(server, port, host, isHttp2);
-  } catch (error) {
-    console.error("Failed to start server:", error);
-    throw error;
+    if (existingSources.length > 0) {
+      const conflictError = new Error(
+        `Route conflict for path "${route.path}": already defined in ${existingSources.join(", ")}, now being added from ${source}`
+      );
+      console.error(conflictError.message);
+      throw conflictError;
+    }
+    routeSources.set(route.path, [...existingSources, source]);
+    addRouteInternal(route);
   }
-}
-
-// src/server/stop.ts
-async function stopServer(serverInstance, options = {}) {
-  const server = serverInstance.server;
-  const events = serverInstance.events;
-  if (!server) {
-    return;
+  async function loadRoutesFromDirectory(directory, source, prefix) {
+    try {
+      const discoveredRoutes = await findRoutes(directory, {
+        basePath: routerOptions.basePath
+      });
+      for (const route of discoveredRoutes) {
+        const finalRoute = prefix ? {
+          ...route,
+          path: `${prefix}${route.path}`
+        } : route;
+        addRouteWithSource(finalRoute, source);
+      }
+      console.log(
+        `Loaded ${discoveredRoutes.length} routes from ${source}${prefix ? ` with prefix ${prefix}` : ""}`
+      );
+    } catch (error) {
+      console.error(`Failed to load routes from ${source}:`, error);
+      throw error;
+    }
   }
-  const timeout = options.timeout || 3e4;
-  const plugins = serverInstance.plugins;
-  try {
-    if (options.onStopping) {
-      await options.onStopping();
+  async function initialize() {
+    if (initialized || initializationPromise) {
+      return initializationPromise;
     }
-    events.emit("stopping");
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error("Server shutdown timed out waiting for requests to complete"));
-      }, timeout);
-    });
-    const closePromise = new Promise((resolve2, reject) => {
-      server.close((err) => {
-        if (err) {
-          return reject(err);
+    initializationPromise = (async () => {
+      try {
+        for (const directory of routeDirectories) {
+          await loadRoutesFromDirectory(directory, directory);
         }
-        resolve2();
-      });
-    });
-    await Promise.race([closePromise, timeoutPromise]);
-    if (plugins?.length) {
-      for (const plugin of [...plugins].reverse()) {
-        if (plugin.terminate) {
-          await plugin.terminate();
+        if (routerOptions.watchMode) {
+          setupWatcherForAllDirectories();
         }
+        initialized = true;
+      } catch (error) {
+        console.error("Failed to initialize router:", error);
+        throw error;
       }
-    }
-    if (options.onStopped) {
-      await options.onStopped();
-    }
-    events.emit("stopped");
-    serverInstance.server = null;
-  } catch (error) {
-    events.emit("error", error);
-    throw error;
+    })();
+    return initializationPromise;
   }
-}
-function registerSignalHandlers(stopFn) {
-  const sigintHandler = () => stopFn().catch(console.error);
-  const sigtermHandler = () => stopFn().catch(console.error);
-  process.on("SIGINT", sigintHandler);
-  process.on("SIGTERM", sigtermHandler);
-  return {
-    unregister: () => {
-      process.removeListener("SIGINT", sigintHandler);
-      process.removeListener("SIGTERM", sigtermHandler);
-    }
-  };
-}
-
-// src/server/validation.ts
-import { z as z5 } from "zod";
-var middlewareSchema = z5.custom(
-  (data) => data !== null && typeof data === "object" && "execute" in data && typeof data.execute === "function",
-  {
-    message: "Expected middleware to have an execute function"
+  function addRouteInternal(route) {
+    routes.push(route);
+    Object.entries(route).forEach(([method, methodOptions]) => {
+      if (method === "path" || !methodOptions) return;
+      matcher.add(route.path, method, methodOptions);
+    });
   }
-);
-var pluginSchema = z5.custom(
-  (data) => data !== null && typeof data === "object" && "register" in data && typeof data.register === "function",
-  {
-    message: "Expected a valid plugin object with a register method"
+  function createWatcherCallbacks(directory, source, prefix) {
+    return {
+      onRouteAdded: (addedRoutes) => {
+        console.log(
+          `${addedRoutes.length} route(s) added from ${directory}:`,
+          addedRoutes.map((r) => r.path)
+        );
+        addedRoutes.forEach((route) => {
+          const finalRoute = prefix ? { ...route, path: `${prefix}${route.path}` } : route;
+          addRouteWithSource(finalRoute, source);
+        });
+      },
+      onRouteChanged: (changedRoutes) => {
+        console.log(
+          `${changedRoutes.length} route(s) changed in ${directory}:`,
+          changedRoutes.map((r) => r.path)
+        );
+        changedRoutes.forEach((route) => {
+          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
+          const index = routes.findIndex((r) => r.path === finalPath);
+          if (index >= 0) {
+            routes.splice(index, 1);
+            const sources = routeSources.get(finalPath) || [];
+            const filteredSources = sources.filter((s) => s !== source);
+            if (filteredSources.length > 0) {
+              routeSources.set(finalPath, filteredSources);
+            } else {
+              routeSources.delete(finalPath);
+            }
+          }
+          const finalRoute = prefix ? { ...route, path: finalPath } : route;
+          addRouteWithSource(finalRoute, source);
+        });
+      },
+      onRouteRemoved: (filePath, removedRoutes) => {
+        console.log(
+          `File removed from ${directory}: ${filePath} with ${removedRoutes.length} route(s):`,
+          removedRoutes.map((r) => r.path)
+        );
+        removedRoutes.forEach((route) => {
+          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
+          const index = routes.findIndex((r) => r.path === finalPath);
+          if (index >= 0) {
+            routes.splice(index, 1);
+          }
+          const sources = routeSources.get(finalPath) || [];
+          const filteredSources = sources.filter((s) => s !== source);
+          if (filteredSources.length > 0) {
+            routeSources.set(finalPath, filteredSources);
+          } else {
+            routeSources.delete(finalPath);
+          }
+        });
+      },
+      onError: (error) => {
+        console.error(`Route watcher error for ${directory}:`, error);
+      }
+    };
   }
-);
-var http2Schema = z5.object({
-  enabled: z5.boolean().optional().default(true),
-  keyFile: z5.string().optional(),
-  certFile: z5.string().optional()
-}).refine(
-  (data) => {
-    if (data.enabled && process.env.NODE_ENV === "production") {
-      return data.keyFile && data.certFile;
+  function setupWatcherForDirectory(directory, source, prefix) {
+    const callbacks = createWatcherCallbacks(directory, source, prefix);
+    const watcher = watchRoutes(directory, {
+      ignore: ["node_modules", ".git"],
+      ...callbacks
+    });
+    if (!_watchers) {
+      _watchers = /* @__PURE__ */ new Map();
     }
-    return true;
-  },
-  {
-    message: "When HTTP/2 is enabled (outside of development mode), both keyFile and certFile must be provided"
+    _watchers.set(directory, watcher);
+    return watcher;
   }
-);
-var serverOptionsSchema = z5.object({
-  port: z5.number().int().positive().optional().default(3e3),
-  host: z5.string().optional().default("localhost"),
-  routesDir: z5.string().optional().default("./routes"),
-  http2: http2Schema.optional().default({
-    enabled: true
-  }),
-  middleware: z5.array(middlewareSchema).optional().default([]),
-  plugins: z5.array(pluginSchema).optional().default([])
-});
-function validateServerOptions(options) {
-  try {
-    return serverOptionsSchema.parse(options);
-  } catch (error) {
-    if (error instanceof z5.ZodError) {
-      const formattedError = error.format();
-      throw new Error(`Invalid server options: ${JSON.stringify(formattedError, null, 2)}`);
+  function setupWatcherForAllDirectories() {
+    for (const directory of routeDirectories) {
+      setupWatcherForDirectory(directory, directory);
     }
-    throw new Error(`Invalid server options: ${String(error)}`);
   }
+  initialize().catch((error) => {
+    console.error("Failed to initialize router on creation:", error);
+  });
+  return {
+    /**
+     * Handle an incoming request
+     */
+    async handleRequest(ctx) {
+      if (!initialized) {
+        await initialize();
+      }
+      const { method, path: path5 } = ctx.request;
+      const match = matcher.match(path5, method);
+      if (!match) {
+        ctx.response.status(404).json({ error: "Not Found" });
+        return;
+      }
+      if (match.methodNotAllowed) {
+        ctx.response.status(405).json({
+          error: "Method Not Allowed",
+          allowed: match.allowedMethods
+        });
+        if (match.allowedMethods && match.allowedMethods.length > 0) {
+          ctx.response.header("Allow", match.allowedMethods.join(", "));
+        }
+        return;
+      }
+      ctx.request.params = match.params;
+      try {
+        await executeHandler(ctx, match.route, match.params);
+      } catch (error) {
+        handleRouteError(ctx, error, {
+          detailed: process.env.NODE_ENV !== "production",
+          log: true
+        });
+      }
+    },
+    /**
+     * Get all registered routes
+     */
+    getRoutes() {
+      return [...routes];
+    },
+    /**
+     * Add a route programmatically
+     */
+    addRoute(route) {
+      addRouteInternal(route);
+    },
+    /**
+     * Add a route directory (for plugins)
+     */
+    async addRouteDirectory(directory, options2 = {}) {
+      if (routeDirectories.has(directory)) {
+        console.warn(`Route directory ${directory} already registered`);
+        return;
+      }
+      routeDirectories.add(directory);
+      if (initialized) {
+        await loadRoutesFromDirectory(directory, directory, options2.prefix);
+        if (routerOptions.watchMode) {
+          setupWatcherForDirectory(directory, directory, options2.prefix);
+        }
+      }
+    },
+    /**
+     * Get route conflicts
+     */
+    getRouteConflicts() {
+      const conflicts = [];
+      for (const [path5, sources] of routeSources.entries()) {
+        if (sources.length > 1) {
+          conflicts.push({ path: path5, sources });
+        }
+      }
+      return conflicts;
+    }
+  };
 }
 
 // src/server/create.ts
@@ -1639,7 +1913,9 @@ function createServerOptions(options = {}) {
 function createListenMethod(serverInstance, validatedOptions, initialMiddleware, initialPlugins) {
   return async () => {
     await initializeComponents(serverInstance, initialMiddleware, initialPlugins);
+    await serverInstance.pluginManager.initializePlugins(serverInstance);
     await startServer(serverInstance, validatedOptions);
+    await serverInstance.pluginManager.onServerStart(serverInstance, serverInstance.server);
     setupServerLifecycle(serverInstance);
     return serverInstance;
   };
@@ -1685,13 +1961,6 @@ function createRegisterMethod(serverInstance) {
     return serverInstance;
   };
 }
-function validatePlugin(plugin) {
-  if (!plugin || typeof plugin !== "object" || !("register" in plugin) || typeof plugin.register !== "function") {
-    throw new Error(
-      "Invalid plugin. Must be a valid BlaizeJS plugin object with a register method."
-    );
-  }
-}
 function create3(options = {}) {
   const mergedOptions = createServerOptions(options);
   let validatedOptions;
@@ -1711,6 +1980,10 @@ function create3(options = {}) {
     routesDir: validatedOptions.routesDir,
     watchMode: process.env.NODE_ENV === "development"
   });
+  const pluginManager = createPluginLifecycleManager({
+    debug: process.env.NODE_ENV === "development",
+    continueOnError: true
+  });
   const events = new EventEmitter();
   const serverInstance = {
     server: null,
@@ -1727,7 +2000,8 @@ function create3(options = {}) {
     listen: async () => serverInstance,
     close: async () => {
     },
-    router
+    router,
+    pluginManager
   };
   serverInstance.listen = createListenMethod(
     serverInstance,