blaizejs 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1844 @@
+/**
+ * blaizejs v0.1.0
+ * A blazing-fast, type-safe Node.js framework with file-based routing, powerful middleware, and end-to-end type safety
+ * 
+ * Copyright (c) 2025 BlaizeJS Contributors
+ * @license MIT
+ */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Blaize: () => Blaize,
+  MiddlewareAPI: () => MiddlewareAPI,
+  PluginsAPI: () => PluginsAPI,
+  RouterAPI: () => RouterAPI,
+  ServerAPI: () => ServerAPI,
+  VERSION: () => VERSION,
+  compose: () => compose,
+  createDeleteRoute: () => createDeleteRoute,
+  createGetRoute: () => createGetRoute,
+  createHeadRoute: () => createHeadRoute,
+  createMiddleware: () => create,
+  createOptionsRoute: () => createOptionsRoute,
+  createPatchRoute: () => createPatchRoute,
+  createPlugin: () => create2,
+  createPostRoute: () => createPostRoute,
+  createPutRoute: () => createPutRoute,
+  createServer: () => create3,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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) {
+    return Promise.resolve(next());
+  }
+  if (middleware.skip && middleware.skip(ctx)) {
+    return Promise.resolve(next());
+  }
+  try {
+    const result = middleware.execute(ctx, next);
+    if (result instanceof Promise) {
+      return result;
+    } else {
+      return Promise.resolve(result);
+    }
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+// src/middleware/compose.ts
+function compose(middlewareStack) {
+  if (middlewareStack.length === 0) {
+    return async (_, next) => {
+      await Promise.resolve(next());
+    };
+  }
+  return async function(ctx, finalHandler) {
+    const called = /* @__PURE__ */ new Set();
+    const dispatch = async (i) => {
+      if (i >= middlewareStack.length) {
+        return Promise.resolve(finalHandler());
+      }
+      const middleware = middlewareStack[i];
+      const nextDispatch = () => {
+        if (called.has(i)) {
+          throw new Error("next() called multiple times");
+        }
+        called.add(i);
+        return dispatch(i + 1);
+      };
+      return execute(middleware, ctx, nextDispatch);
+    };
+    return dispatch(0);
+  };
+}
+
+// src/plugins/create.ts
+function create2(name, version, setup, _defaultOptions = {}) {
+  throw new Error("Plugin system not yet available");
+}
+
+// src/router/discovery/finder.ts
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+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);
+      }
+    }
+  }
+  await scanDirectory(absoluteDir);
+  return routeFiles;
+}
+function isRouteFile(filename) {
+  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js")) && filename !== "index.ts" && filename !== "index.js";
+}
+
+// src/router/discovery/parser.ts
+var path2 = __toESM(require("path"), 1);
+function parseRoutePath(filePath, basePath) {
+  const forwardSlashFilePath = filePath.replace(/\\/g, "/");
+  const forwardSlashBasePath = basePath.replace(/\\/g, "/");
+  const normalizedBasePath = forwardSlashBasePath.endsWith("/") ? forwardSlashBasePath : `${forwardSlashBasePath}/`;
+  let relativePath = forwardSlashFilePath;
+  if (forwardSlashFilePath.startsWith(normalizedBasePath)) {
+    relativePath = forwardSlashFilePath.substring(normalizedBasePath.length);
+  } else if (forwardSlashFilePath.startsWith(forwardSlashBasePath)) {
+    relativePath = forwardSlashFilePath.substring(forwardSlashBasePath.length);
+    if (relativePath.startsWith("/")) {
+      relativePath = relativePath.substring(1);
+    }
+  } else {
+    relativePath = path2.relative(forwardSlashBasePath, forwardSlashFilePath).replace(/\\/g, "/");
+  }
+  relativePath = relativePath.replace(/\.[^.]+$/, "");
+  const segments = relativePath.split("/").filter(Boolean);
+  const params = [];
+  const routeSegments = segments.map((segment) => {
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      params.push(paramName);
+      return `:${paramName}`;
+    }
+    return segment;
+  });
+  let routePath = routeSegments.length > 0 ? `/${routeSegments.join("/")}` : "/";
+  if (routePath.endsWith("/index")) {
+    routePath = routePath.slice(0, -6) || "/";
+  }
+  return {
+    filePath,
+    routePath,
+    params
+  };
+}
+
+// src/router/discovery/loader.ts
+async function dynamicImport(filePath) {
+  return import(filePath);
+}
+async function loadRouteModule(filePath, basePath) {
+  try {
+    const parsedRoute = parseRoutePath(filePath, basePath);
+    console.log("parsedRoute:", parsedRoute);
+    const module2 = await dynamicImport(filePath);
+    console.log("Module exports:", Object.keys(module2));
+    const routes = [];
+    if (module2.default && typeof module2.default === "object") {
+      console.log("Found default export:", module2.default);
+      const route = {
+        ...module2.default,
+        path: parsedRoute.routePath
+      };
+      routes.push(route);
+    }
+    Object.entries(module2).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 [];
+    }
+    console.log(`Loaded ${routes.length} route(s) from ${filePath}`);
+    return routes;
+  } catch (error) {
+    console.error(`Failed to load route module ${filePath}:`, error);
+    return [];
+  }
+}
+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;
+}
+
+// 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 routes;
+}
+
+// src/router/discovery/watchers.ts
+var path3 = __toESM(require("path"), 1);
+var import_chokidar = require("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);
+    }
+  }
+  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);
+    }
+  }
+  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);
+  }
+  function handleError(error) {
+    if (options.onError && error instanceof Error) {
+      options.onError(error);
+    } else {
+      console.error("Route watcher error:", error);
+    }
+  }
+  const watcher = (0, import_chokidar.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);
+    }
+  }
+  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;
+  }
+}
+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;
+    }
+  }
+  return "Error";
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+  }
+  return String(error);
+}
+
+// src/router/validation/body.ts
+var import_zod = require("zod");
+function validateBody(body, schema) {
+  if (schema instanceof import_zod.z.ZodObject) {
+    return schema.strict().parse(body);
+  }
+  return schema.parse(body);
+}
+
+// src/router/validation/params.ts
+var import_zod2 = require("zod");
+function validateParams(params, schema) {
+  if (schema instanceof import_zod2.z.ZodObject) {
+    return schema.strict().parse(params);
+  }
+  return schema.parse(params);
+}
+
+// src/router/validation/query.ts
+var import_zod3 = require("zod");
+function validateQuery(query, schema) {
+  if (schema instanceof import_zod3.z.ZodObject) {
+    return schema.strict().parse(query);
+  }
+  return schema.parse(query);
+}
+
+// src/router/validation/response.ts
+var import_zod4 = require("zod");
+function validateResponse(response, schema) {
+  if (schema instanceof import_zod4.z.ZodObject) {
+    return schema.strict().parse(response);
+  }
+  return schema.parse(response);
+}
+
+// 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;
+      }
+    };
+    await next();
+  };
+  return {
+    name: "ResponseValidator",
+    execute: middlewareFn,
+    debug
+  };
+}
+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);
+}
+
+// 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/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 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
+  };
+}
+
+// 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)
+      }));
+    }
+  };
+}
+
+// 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");
+  }
+  const routes = [];
+  const matcher = createMatcher();
+  let initialized = false;
+  let initializationPromise = null;
+  let _watcher = null;
+  async function initialize() {
+    if (initialized || initializationPromise) {
+      return initializationPromise;
+    }
+    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;
+      }
+    })();
+    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);
+    });
+  }
+  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);
+      }
+    });
+  }
+  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);
+    }
+  };
+}
+
+// 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/create.ts
+function getCallerFilePath() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  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");
+    }
+    const fileName = callerFrame.getFileName();
+    if (!fileName) {
+      throw new Error("Unable to determine caller file name");
+    }
+    return fileName;
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+}
+function getRoutePath() {
+  const callerPath = getCallerFilePath();
+  const routesDir = getRoutesDir();
+  const parsedRoute = parseRoutePath(callerPath, routesDir);
+  return parsedRoute.routePath;
+}
+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;
+  }
+}
+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`);
+  }
+  if (query && (!query._def || typeof query.parse !== "function")) {
+    throw new Error(`Query schema for ${method} must be a valid Zod schema`);
+  }
+  if (body && (!body._def || typeof body.parse !== "function")) {
+    throw new Error(`Body schema for ${method} must be a valid Zod schema`);
+  }
+  if (response && (!response._def || typeof response.parse !== "function")) {
+    throw new Error(`Response schema for ${method} must be a valid Zod schema`);
+  }
+}
+
+// src/server/create.ts
+var import_node_async_hooks2 = require("async_hooks");
+var import_node_events = __toESM(require("events"), 1);
+
+// src/server/start.ts
+var fs3 = __toESM(require("fs"), 1);
+var http = __toESM(require("http"), 1);
+var http2 = __toESM(require("http2"), 1);
+
+// src/server/dev-certificate.ts
+var fs2 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var selfsigned = __toESM(require("selfsigned"), 1);
+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 });
+  }
+  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
+  };
+}
+
+// src/context/errors.ts
+var ResponseSentError = class extends Error {
+  constructor(message = "\u274C Response has already been sent") {
+    super(message);
+    this.name = "ResponseSentError";
+  }
+};
+var ResponseSentHeaderError = class extends ResponseSentError {
+  constructor(message = "Cannot set header after response has been sent") {
+    super(message);
+  }
+};
+var ResponseSentContentError = class extends ResponseSentError {
+  constructor(message = "Cannot set content type after response has been sent") {
+    super(message);
+  }
+};
+var ParseUrlError = class extends ResponseSentError {
+  constructor(message = "Invalide URL") {
+    super(message);
+  }
+};
+
+// src/context/store.ts
+var import_node_async_hooks = require("async_hooks");
+var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(context, callback) {
+  return contextStorage.run(context, callback);
+}
+
+// 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}`);
+  }
+}
+function isHttp2Request(req) {
+  return "stream" in req || "httpVersionMajor" in req && req.httpVersionMajor === 2;
+}
+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";
+    }
+  }
+  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 {
+    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(", ");
+    }
+    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 {
+    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 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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+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;
+  };
+}
+function createRedirectResponder(res, responseState) {
+  return function redirectResponder(url, status = 302) {
+    if (responseState.sent) {
+      throw new ResponseSentError();
+    }
+    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);
+      }
+    }
+    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;
+  }
+  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];
+      }
+    } 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
+            );
+          }
+        }
+      });
+    } 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/server/start.ts
+async function prepareCertificates(http2Options) {
+  if (!http2Options.enabled) {
+    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."
+    );
+  }
+  return { keyFile, certFile };
+}
+function createServerInstance(isHttp2, certOptions) {
+  if (!isHttp2) {
+    return http.createServer();
+  }
+  const http2ServerOptions = {
+    allowHTTP1: true
+    // Allow fallback to HTTP/1.1
+  };
+  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);
+    }
+  }
+}
+async function startServer(serverInstance, serverOptions) {
+  if (serverInstance.server) {
+    return;
+  }
+  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;
+  }
+}
+
+// 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;
+  const plugins = serverInstance.plugins;
+  try {
+    if (options.onStopping) {
+      await options.onStopping();
+    }
+    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);
+        }
+        resolve2();
+      });
+    });
+    await Promise.race([closePromise, timeoutPromise]);
+    if (plugins?.length) {
+      for (const plugin of [...plugins].reverse()) {
+        if (plugin.terminate) {
+          await plugin.terminate();
+        }
+      }
+    }
+    if (options.onStopped) {
+      await options.onStopped();
+    }
+    events.emit("stopped");
+    serverInstance.server = null;
+  } catch (error) {
+    events.emit("error", error);
+    throw error;
+  }
+}
+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
+var import_zod5 = require("zod");
+var middlewareSchema = import_zod5.z.custom(
+  (data) => data !== null && typeof data === "object" && "execute" in data && typeof data.execute === "function",
+  {
+    message: "Expected middleware to have an execute function"
+  }
+);
+var pluginSchema = import_zod5.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"
+  }
+);
+var http2Schema = import_zod5.z.object({
+  enabled: import_zod5.z.boolean().optional().default(true),
+  keyFile: import_zod5.z.string().optional(),
+  certFile: import_zod5.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"
+  }
+);
+var serverOptionsSchema = import_zod5.z.object({
+  port: import_zod5.z.number().int().positive().optional().default(3e3),
+  host: import_zod5.z.string().optional().default("localhost"),
+  routesDir: import_zod5.z.string().optional().default("./routes"),
+  http2: http2Schema.optional().default({
+    enabled: true
+  }),
+  middleware: import_zod5.z.array(middlewareSchema).optional().default([]),
+  plugins: import_zod5.z.array(pluginSchema).optional().default([])
+});
+function validateServerOptions(options) {
+  try {
+    return serverOptionsSchema.parse(options);
+  } catch (error) {
+    if (error instanceof import_zod5.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
+var DEFAULT_OPTIONS = {
+  port: 3e3,
+  host: "localhost",
+  routesDir: "./routes",
+  http2: {
+    enabled: true
+  },
+  middleware: [],
+  plugins: []
+};
+function createServerOptions(options = {}) {
+  const baseOptions = { ...DEFAULT_OPTIONS };
+  setRuntimeConfig({ routesDir: options.routesDir || baseOptions.routesDir });
+  return {
+    port: options.port ?? baseOptions.port,
+    host: options.host ?? baseOptions.host,
+    routesDir: options.routesDir ?? baseOptions.routesDir,
+    http2: {
+      enabled: options.http2?.enabled ?? baseOptions.http2?.enabled,
+      keyFile: options.http2?.keyFile ?? baseOptions.http2?.keyFile,
+      certFile: options.http2?.certFile ?? baseOptions.http2?.certFile
+    },
+    middleware: [...baseOptions.middleware || [], ...options.middleware || []],
+    plugins: [...baseOptions.plugins || [], ...options.plugins || []]
+  };
+}
+function createListenMethod(serverInstance, validatedOptions, initialMiddleware, initialPlugins) {
+  return async () => {
+    await initializeComponents(serverInstance, initialMiddleware, initialPlugins);
+    await startServer(serverInstance, validatedOptions);
+    setupServerLifecycle(serverInstance);
+    return serverInstance;
+  };
+}
+async function initializeComponents(serverInstance, initialMiddleware, initialPlugins) {
+  for (const mw of initialMiddleware) {
+    serverInstance.use(mw);
+  }
+  for (const p of initialPlugins) {
+    await serverInstance.register(p);
+  }
+}
+function setupServerLifecycle(serverInstance) {
+  const signalHandlers = registerSignalHandlers(() => serverInstance.close());
+  serverInstance._signalHandlers = signalHandlers;
+  serverInstance.events.emit("started");
+}
+function createCloseMethod(serverInstance) {
+  return async (stopOptions) => {
+    if (!serverInstance.server) {
+      return;
+    }
+    const options = { ...stopOptions };
+    if (serverInstance._signalHandlers) {
+      serverInstance._signalHandlers.unregister();
+      delete serverInstance._signalHandlers;
+    }
+    await stopServer(serverInstance, options);
+  };
+}
+function createUseMethod(serverInstance) {
+  return (middleware) => {
+    const middlewareArray = Array.isArray(middleware) ? middleware : [middleware];
+    serverInstance.middleware.push(...middlewareArray);
+    return serverInstance;
+  };
+}
+function createRegisterMethod(serverInstance) {
+  return async (plugin) => {
+    validatePlugin(plugin);
+    serverInstance.plugins.push(plugin);
+    await plugin.register(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;
+  try {
+    validatedOptions = validateServerOptions(mergedOptions);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to create server: ${error.message}`);
+    }
+    throw new Error(`Failed to create server: ${String(error)}`);
+  }
+  const { port, host, middleware, plugins } = validatedOptions;
+  const initialMiddleware = Array.isArray(middleware) ? [...middleware] : [];
+  const initialPlugins = Array.isArray(plugins) ? [...plugins] : [];
+  const contextStorage2 = new import_node_async_hooks2.AsyncLocalStorage();
+  const router = createRouter({
+    routesDir: validatedOptions.routesDir,
+    watchMode: process.env.NODE_ENV === "development"
+  });
+  const events = new import_node_events.default();
+  const serverInstance = {
+    server: null,
+    port,
+    host,
+    context: contextStorage2,
+    events,
+    plugins: [],
+    middleware: [],
+    _signalHandlers: { unregister: () => {
+    } },
+    use: () => serverInstance,
+    register: async () => serverInstance,
+    listen: async () => serverInstance,
+    close: async () => {
+    },
+    router
+  };
+  serverInstance.listen = createListenMethod(
+    serverInstance,
+    validatedOptions,
+    initialMiddleware,
+    initialPlugins
+  );
+  serverInstance.close = createCloseMethod(serverInstance);
+  serverInstance.use = createUseMethod(serverInstance);
+  serverInstance.register = createRegisterMethod(serverInstance);
+  return serverInstance;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var ServerAPI = { createServer: create3 };
+var RouterAPI = {
+  createDeleteRoute,
+  createGetRoute,
+  createHeadRoute,
+  createOptionsRoute,
+  createPatchRoute,
+  createPostRoute,
+  createPutRoute
+};
+var MiddlewareAPI = { createMiddleware: create, compose };
+var PluginsAPI = { createPlugin: create2 };
+var Blaize = {
+  // Core functions
+  createServer: create3,
+  createMiddleware: create,
+  createPlugin: create2,
+  // Namespaces (using the non-conflicting names)
+  Server: ServerAPI,
+  Router: RouterAPI,
+  Middleware: MiddlewareAPI,
+  Plugins: PluginsAPI,
+  // Constants
+  VERSION
+};
+var index_default = Blaize;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Blaize,
+  MiddlewareAPI,
+  PluginsAPI,
+  RouterAPI,
+  ServerAPI,
+  VERSION,
+  compose,
+  createDeleteRoute,
+  createGetRoute,
+  createHeadRoute,
+  createMiddleware,
+  createOptionsRoute,
+  createPatchRoute,
+  createPlugin,
+  createPostRoute,
+  createPutRoute,
+  createServer
+});
+//# sourceMappingURL=index.cjs.map