lacis 0.2.0

package/dist/chunk-NVNSYLVY.js

@@ -0,0 +1,2075 @@
+import path2 from 'path';
+import fs from 'fs/promises';
+import cluster3 from 'cluster';
+import http2, { IncomingMessage, ServerResponse } from 'http';
+import https from 'https';
+import * as os from 'os';
+import os__default from 'os';
+import { EventEmitter } from 'events';
+import { Socket } from 'net';
+
+// src/core/middleware.ts
+var globalMiddlewares = {
+  beforeRequest: [],
+  afterRequest: [],
+  onError: []
+};
+var pathMiddlewares = /* @__PURE__ */ new Map();
+function addMiddleware(middlewareName, callback) {
+  globalMiddlewares[middlewareName].push(callback);
+  return {
+    remove: () => {
+      const index = globalMiddlewares[middlewareName].indexOf(callback);
+      if (index !== -1) {
+        globalMiddlewares[middlewareName].splice(index, 1);
+      }
+    }
+  };
+}
+function addPathMiddleware(path3, type, callback) {
+  const normalizedPath = path3 === "/" ? "/" : path3.replace(/\/+$/, "");
+  if (!pathMiddlewares.has(normalizedPath)) {
+    pathMiddlewares.set(normalizedPath, {
+      beforeRequest: [],
+      afterRequest: [],
+      onError: []
+    });
+  }
+  const middlewares = pathMiddlewares.get(normalizedPath);
+  middlewares[type].push(callback);
+  return {
+    remove: () => {
+      if (pathMiddlewares.has(normalizedPath)) {
+        const middlewares2 = pathMiddlewares.get(normalizedPath);
+        const index = middlewares2[type].indexOf(callback);
+        if (index !== -1) {
+          middlewares2[type].splice(index, 1);
+        }
+      }
+    }
+  };
+}
+function collectMiddleware(url) {
+  const normalizedUrl = url === "/" ? "/" : url.replace(/\/+$/, "");
+  const segments = normalizedUrl.split("/").filter(Boolean);
+  const result = {
+    beforeRequest: [...globalMiddlewares.beforeRequest],
+    afterRequest: [...globalMiddlewares.afterRequest],
+    onError: [...globalMiddlewares.onError]
+  };
+  let currentPath = "";
+  if (pathMiddlewares.has("/")) {
+    const rootMiddleware = pathMiddlewares.get("/");
+    result.beforeRequest.push(...rootMiddleware.beforeRequest);
+    result.afterRequest.push(...rootMiddleware.afterRequest);
+    result.onError.push(...rootMiddleware.onError);
+  }
+  for (const segment of segments) {
+    currentPath += "/" + segment;
+    if (pathMiddlewares.has(currentPath)) {
+      const middleware = pathMiddlewares.get(currentPath);
+      result.beforeRequest.push(...middleware.beforeRequest);
+      result.afterRequest.push(...middleware.afterRequest);
+      result.onError.push(...middleware.onError);
+    }
+  }
+  return result;
+}
+function hasMiddlewares() {
+  if (globalMiddlewares.beforeRequest.length > 0 || globalMiddlewares.afterRequest.length > 0 || globalMiddlewares.onError.length > 0) return true;
+  return pathMiddlewares.size > 0;
+}
+async function runMiddlewares(middlewareName, req, res, context) {
+  const url = req.url?.split("?")[0] || "/";
+  const middleware = collectMiddleware(url);
+  if (middleware[middlewareName].length === 0) {
+    return true;
+  }
+  for (const handler of middleware[middlewareName]) {
+    try {
+      const result = await handler(req, res, context);
+      if (result === false) return false;
+    } catch (error) {
+      if (middlewareName !== "onError") {
+        try {
+          for (const errorHandler of middleware.onError) {
+            await errorHandler(req, res, { error, phase: middlewareName });
+          }
+        } catch (e) {
+          console.error("Error in error handler:", e);
+        }
+      }
+      return false;
+    }
+  }
+  return true;
+}
+async function loadMiddlewares(routesDir) {
+  pathMiddlewares.clear();
+  async function scanDir(dir, prefix = "") {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      const middlewareFile = entries.find(
+        (entry) => entry.name === "+middleware.ts" || entry.name === "+middleware.js"
+      );
+      if (middlewareFile) {
+        const fullPath = path2.join(dir, middlewareFile.name);
+        try {
+          const absolutePath = path2.resolve(fullPath);
+          const middlewareModule = await import(`${absolutePath}?update=${Date.now()}`);
+          if (!pathMiddlewares.has(prefix)) {
+            pathMiddlewares.set(prefix, {
+              beforeRequest: [],
+              afterRequest: [],
+              onError: []
+            });
+          }
+          if (middlewareModule.beforeRequest) {
+            const middlewares = Array.isArray(middlewareModule.beforeRequest) ? middlewareModule.beforeRequest : [middlewareModule.beforeRequest];
+            pathMiddlewares.get(prefix).beforeRequest.push(...middlewares);
+          }
+          if (middlewareModule.afterRequest) {
+            const middlewares = Array.isArray(middlewareModule.afterRequest) ? middlewareModule.afterRequest : [middlewareModule.afterRequest];
+            pathMiddlewares.get(prefix).afterRequest.push(...middlewares);
+          }
+          if (middlewareModule.onError) {
+            const middlewares = Array.isArray(middlewareModule.onError) ? middlewareModule.onError : [middlewareModule.onError];
+            pathMiddlewares.get(prefix).onError.push(...middlewares);
+          }
+        } catch (error) {
+          console.error(`Error loading middleware for ${prefix}:`, error);
+        }
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await scanDir(
+            path2.join(dir, entry.name),
+            `${prefix === "/" ? "" : prefix}/${entry.name}`
+          );
+        }
+      }
+    } catch (error) {
+      console.error(`Error scanning directory ${dir}:`, error);
+    }
+  }
+  await scanDir(routesDir, "/");
+}
+function getPathMiddlewares() {
+  return pathMiddlewares;
+}
+function resetMiddlewares() {
+  globalMiddlewares.beforeRequest = [];
+  globalMiddlewares.afterRequest = [];
+  globalMiddlewares.onError = [];
+  pathMiddlewares.clear();
+}
+function registerMiddlewareConfig(config) {
+  if (!config) return;
+  for (const type of ["beforeRequest", "afterRequest", "onError"]) {
+    const handlers = config[type];
+    if (handlers) {
+      const arr = Array.isArray(handlers) ? handlers : [handlers];
+      for (const h of arr) addMiddleware(type, h);
+    }
+  }
+}
+
+// src/core/cors.ts
+function isOriginAllowed(origin, allowed) {
+  if (!allowed || allowed === "*") return true;
+  if (typeof allowed === "string") return origin === allowed;
+  if (Array.isArray(allowed)) return allowed.includes(origin);
+  if (allowed instanceof RegExp) return allowed.test(origin);
+  if (typeof allowed === "function") return allowed(origin);
+  return false;
+}
+function createCorsMiddleware(config) {
+  const methods = (config.methods ?? ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]).join(", ");
+  const allowedHeaders = (config.allowedHeaders ?? ["Content-Type", "Authorization"]).join(", ");
+  const exposedHeaders = config.exposedHeaders?.join(", ");
+  const maxAge = config.maxAge != null ? String(config.maxAge) : null;
+  const isWildcard = !config.origin || config.origin === "*";
+  return async (req, res) => {
+    const origin = req.getHeader("origin");
+    if (!origin) return;
+    if (!isOriginAllowed(origin, config.origin)) return;
+    const useWildcard = isWildcard && !config.credentials;
+    res.setHeader("Access-Control-Allow-Origin", useWildcard ? "*" : origin);
+    if (!useWildcard) res.setHeader("Vary", "Origin");
+    if (config.credentials) res.setHeader("Access-Control-Allow-Credentials", "true");
+    if (exposedHeaders) res.setHeader("Access-Control-Expose-Headers", exposedHeaders);
+    if (req.method === "OPTIONS") {
+      res.setHeader("Access-Control-Allow-Methods", methods);
+      res.setHeader("Access-Control-Allow-Headers", allowedHeaders);
+      if (maxAge) res.setHeader("Access-Control-Max-Age", maxAge);
+      res.status(204);
+      res.end();
+      return false;
+    }
+  };
+}
+function registerCorsConfig(cors) {
+  if (!cors) return;
+  addMiddleware("beforeRequest", createCorsMiddleware(cors));
+}
+function primaryLog(...args) {
+  if (cluster3.isPrimary) {
+    console.log(...args);
+  }
+}
+
+// src/core/router.ts
+function parsePattern(pattern) {
+  const match = pattern.match(/^\[(\w+)(\??)]/);
+  if (match) return { name: match[1], isParam: true, isOptional: match[2] === "?" };
+  return { name: pattern, isParam: false, isOptional: false };
+}
+var CACHE_MAX = 1e3;
+var CACHE_EVICT = 100;
+var Router = class {
+  rootNode;
+  cachedRoutes;
+  routeCount;
+  lastLoaded;
+  verbose;
+  constructor() {
+    this.rootNode = this.createNode();
+    this.cachedRoutes = /* @__PURE__ */ new Map();
+    this.routeCount = 0;
+    this.lastLoaded = 0;
+    this.verbose = false;
+  }
+  createNode() {
+    return {
+      handlers: /* @__PURE__ */ Object.create(null),
+      staticChildren: /* @__PURE__ */ new Map(),
+      paramChild: null,
+      wildcardHandler: null,
+      isEndpoint: false
+    };
+  }
+  addRoute(method, routePath, handler) {
+    const segments = routePath.split("/").filter(Boolean);
+    let node = this.rootNode;
+    for (const segment of segments) {
+      const parsed = parsePattern(segment);
+      if (parsed.isParam) {
+        if (!node.paramChild) {
+          node.paramChild = { name: parsed.name, node: this.createNode(), isOptional: parsed.isOptional };
+        } else if (node.paramChild.name !== parsed.name) {
+          throw new Error(
+            `Route conflict: param name "[${parsed.name}]" conflicts with existing "[${node.paramChild.name}]" at the same path position. Use the same param name for all methods at this level.`
+          );
+        }
+        node = node.paramChild.node;
+      } else if (segment === "*") {
+        if (!node.wildcardHandler) node.wildcardHandler = /* @__PURE__ */ Object.create(null);
+        node.wildcardHandler[method] = handler;
+        this.cachedRoutes.clear();
+        return this;
+      } else {
+        if (!node.staticChildren.has(segment)) node.staticChildren.set(segment, this.createNode());
+        node = node.staticChildren.get(segment);
+      }
+    }
+    node.isEndpoint = true;
+    if (!node.handlers[method]) this.routeCount++;
+    node.handlers[method] = handler;
+    this.cachedRoutes.clear();
+    return this;
+  }
+  findRoute(method, url) {
+    const normalizedUrl = url === "/" ? "/" : url.replace(/\/+$/, "");
+    const cacheKey = method + ":" + normalizedUrl;
+    const cached = this.cachedRoutes.get(cacheKey);
+    if (cached) return cached;
+    const segments = normalizedUrl === "/" ? [] : normalizedUrl.split("/").filter(Boolean);
+    const params = /* @__PURE__ */ Object.create(null);
+    const result = this.traverse(this.rootNode, segments, method, params, 0) ?? { handler: null, params: /* @__PURE__ */ Object.create(null) };
+    if (this.cachedRoutes.size >= CACHE_MAX) {
+      let evicted = 0;
+      for (const key of this.cachedRoutes.keys()) {
+        this.cachedRoutes.delete(key);
+        if (++evicted >= CACHE_EVICT) break;
+      }
+    }
+    this.cachedRoutes.set(cacheKey, result);
+    return result;
+  }
+  traverse(node, segments, method, params, index) {
+    if (index === segments.length) {
+      if (node.isEndpoint) {
+        const handler = node.handlers[method] ?? (method === "HEAD" ? node.handlers["GET"] : void 0) ?? node.handlers[""];
+        if (handler) return { handler, params: { ...params } };
+        const allowed = Object.keys(node.handlers).filter((m) => m !== "");
+        return { handler: null, params: {}, allowedMethods: allowed };
+      }
+      const oc = node.paramChild;
+      if (oc?.isOptional && oc.node.isEndpoint) {
+        const handler = oc.node.handlers[method] ?? (method === "HEAD" ? oc.node.handlers["GET"] : void 0) ?? oc.node.handlers[""];
+        if (handler) return { handler, params: { ...params } };
+      }
+      return null;
+    }
+    const segment = segments[index];
+    const staticChild = node.staticChildren.get(segment);
+    if (staticChild) {
+      const found = this.traverse(staticChild, segments, method, params, index + 1);
+      if (found) return found;
+    }
+    if (node.paramChild) {
+      const { name, node: child } = node.paramChild;
+      params[name] = segment;
+      const found = this.traverse(child, segments, method, params, index + 1);
+      if (found) return found;
+      delete params[name];
+    }
+    if (node.wildcardHandler) {
+      const handler = node.wildcardHandler[method] ?? node.wildcardHandler[""];
+      const rest = segments.slice(index).join("/");
+      if (handler) return { handler, params: { ...params, "*": rest } };
+      const allowed = Object.keys(node.wildcardHandler).filter((m) => m !== "");
+      if (allowed.length > 0) return { handler: null, params: { ...params, "*": rest }, allowedMethods: allowed };
+    }
+    return null;
+  }
+  async loadRoutes(routesDir) {
+    this.rootNode = this.createNode();
+    this.cachedRoutes.clear();
+    this.routeCount = 0;
+    await loadMiddlewares(routesDir);
+    const self = this;
+    async function scanDir(dir, currentPath = []) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const indexFile = entries.find(
+          (e) => !e.isDirectory() && (e.name === "index.ts" || e.name === "index.js")
+        );
+        if (indexFile) {
+          try {
+            const absolutePath = path2.resolve(path2.join(dir, indexFile.name));
+            const module = await import(`${absolutePath}?update=${Date.now()}`);
+            const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+            const routePath = "/" + currentPath.join("/");
+            let registered = false;
+            for (const method of methods) {
+              if (typeof module[method] === "function") {
+                self.addRoute(method, routePath, module[method]);
+                registered = true;
+              }
+            }
+            if (!registered && typeof module.default === "function") {
+              self.addRoute("GET", routePath, module.default);
+            }
+            if (self.verbose) primaryLog(`Route loaded: ${routePath}`);
+          } catch (error) {
+            console.error(`Error loading index in ${dir}:`, error);
+          }
+        }
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const paramMatch = entry.name.match(/^\[(\w+)(\??)]/);
+            const segmentName = paramMatch ? `[${paramMatch[1]}${paramMatch[2]}]` : entry.name;
+            await scanDir(path2.join(dir, entry.name), [...currentPath, segmentName]);
+          }
+        }
+      } catch (error) {
+        console.error(`Error scanning directory ${dir}:`, error);
+      }
+    }
+    await scanDir(routesDir);
+    this.lastLoaded = Date.now();
+    if (this.verbose) primaryLog(`Loading completed: ${this.routeCount} routes`);
+    return true;
+  }
+  getRoutes() {
+    const result = [];
+    this.collectRoutes(this.rootNode, [], result);
+    return result;
+  }
+  collectRoutes(node, segments, result) {
+    if (node.isEndpoint) {
+      const path3 = segments.length === 0 ? "/" : "/" + segments.join("/");
+      for (const [method, handler] of Object.entries(node.handlers)) {
+        if (method !== "") result.push({ method, path: path3, handler });
+      }
+    }
+    for (const [segment, child] of node.staticChildren) {
+      this.collectRoutes(child, [...segments, segment], result);
+    }
+    if (node.paramChild) {
+      const { name, isOptional, node: child } = node.paramChild;
+      this.collectRoutes(child, [...segments, isOptional ? `:${name}?` : `:${name}`], result);
+    }
+    if (node.wildcardHandler) {
+      const path3 = "/" + [...segments, "*"].join("/");
+      for (const [method, handler] of Object.entries(node.wildcardHandler)) {
+        if (method !== "") result.push({ method, path: path3, handler });
+      }
+    }
+  }
+  getStats() {
+    return {
+      routeCount: this.routeCount,
+      lastLoaded: this.lastLoaded,
+      uptime: Date.now() - this.lastLoaded,
+      cacheSize: this.cachedRoutes.size
+    };
+  }
+  setVerbose(verbose) {
+    this.verbose = verbose;
+    return this;
+  }
+  reset() {
+    this.rootNode = this.createNode();
+    this.cachedRoutes = /* @__PURE__ */ new Map();
+    this.routeCount = 0;
+  }
+};
+var router = new Router();
+function isRouteError(obj) {
+  return obj && typeof obj === "object" && "error" in obj;
+}
+function registerRoutes(routes) {
+  for (const { path: path3, handlers } of routes) {
+    const normalizedPath = path3.replace(
+      /:(\w+\??)/g,
+      (_, name) => name.endsWith("?") ? `[${name.slice(0, -1)}?]` : `[${name}]`
+    );
+    for (const [method, handler] of Object.entries(handlers)) {
+      if (typeof handler === "function") router.addRoute(method, normalizedPath, handler);
+    }
+  }
+}
+async function loadRoutes(routesDir) {
+  return router.loadRoutes(routesDir);
+}
+function findRoute(url, method = "GET") {
+  const result = router.findRoute(method, url);
+  if (!result.handler) {
+    if (result.allowedMethods?.length) {
+      return { error: "Method Not Allowed", status: 405, allowedMethods: result.allowedMethods };
+    }
+    return null;
+  }
+  return { handler: result.handler, params: result.params };
+}
+function getRoutesDir(customDir) {
+  return path2.resolve(process.cwd(), customDir || process.env.ROUTES_DIR || "routes");
+}
+function getRouterStats() {
+  return router.getStats();
+}
+function setVerboseLogging(verbose) {
+  router.setVerbose(verbose);
+}
+function resetRouter() {
+  router.reset();
+}
+function createSSEClient(urlOrReq, options = {}, handlers = {}, req) {
+  let isConnected = false;
+  let retryCount = 0;
+  const eventHandlers = {};
+  const messageHandlers = [];
+  const closeHandlers = [];
+  const errorHandlers = [];
+  let request = null;
+  if (handlers.onMessage) messageHandlers.push(handlers.onMessage);
+  if (handlers.onClose) closeHandlers.push(handlers.onClose);
+  if (handlers.onError) errorHandlers.push(handlers.onError);
+  if (handlers.onEvent) {
+    Object.entries(handlers.onEvent).forEach(([event, handler]) => {
+      if (!eventHandlers[event]) eventHandlers[event] = [];
+      eventHandlers[event].push(handler);
+    });
+  }
+  const reconnectInterval = options.reconnectInterval || 3e3;
+  const maxRetries = options.maxRetries || 3;
+  const disableReconnect = options.disableReconnect || false;
+  const requestBody = options.body;
+  const contentType = options.contentType || (requestBody ? "application/json" : void 0);
+  const method = options.method || (requestBody ? "POST" : "GET");
+  if (typeof urlOrReq !== "string") {
+    const existingReq = urlOrReq;
+    isConnected = true;
+    existingReq.on("data", (chunk) => {
+      handleSSEData(chunk.toString());
+    });
+    existingReq.on("end", () => {
+      isConnected = false;
+    });
+    existingReq.on("error", (error) => {
+      isConnected = false;
+      console.error("SSE Error:", error);
+    });
+    return createClientInterface();
+  }
+  if (typeof urlOrReq === "string") {
+    return new Promise((resolve, reject) => {
+      startListening().then(() => resolve(createClientInterface())).catch(reject);
+    });
+  }
+  function handleSSEData(chunk) {
+    let buffer = chunk;
+    const messages = buffer.split("\n\n");
+    buffer = messages.pop() || "";
+    for (const message of messages) {
+      const lines = message.split("\n");
+      let data = "";
+      let currentEvent = "";
+      for (const line of lines) {
+        if (line.startsWith("event:")) {
+          currentEvent = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          data = line.slice(5).trim();
+        }
+      }
+      if (data) {
+        try {
+          const parsedData = JSON.parse(data);
+          if (currentEvent && eventHandlers[currentEvent]) {
+            eventHandlers[currentEvent].forEach(
+              (handler) => handler(parsedData)
+            );
+          } else {
+            messageHandlers.forEach((handler) => handler(parsedData));
+          }
+        } catch {
+          if (currentEvent && eventHandlers[currentEvent]) {
+            eventHandlers[currentEvent].forEach((handler) => handler(data));
+          } else {
+            messageHandlers.forEach((handler) => handler(data));
+          }
+        }
+      }
+    }
+  }
+  function createClientInterface() {
+    return {
+      // Register handler for all messages
+      onMessage(callback) {
+        messageHandlers.push(callback);
+        return this;
+      },
+      // Register handler for specific named events
+      onEvent(eventName, callback) {
+        if (!eventHandlers[eventName]) {
+          eventHandlers[eventName] = [];
+        }
+        eventHandlers[eventName].push(callback);
+        return this;
+      },
+      // Register handler for connection close
+      onClose(callback) {
+        closeHandlers.push(callback);
+        return this;
+      },
+      // Manually close the connection
+      close() {
+        if (request) {
+          request.destroy();
+          request = null;
+        }
+        isConnected = false;
+        closeHandlers.forEach((handler) => handler());
+      }
+    };
+  }
+  async function startListening() {
+    if (isConnected) return;
+    isConnected = true;
+    try {
+      await connect();
+    } catch (error) {
+      if (!disableReconnect && retryCount < maxRetries) {
+        retryCount++;
+        setTimeout(() => {
+          startListening();
+        }, reconnectInterval);
+      } else {
+        errorHandlers.forEach((handler) => handler(error));
+      }
+    }
+  }
+  async function connect() {
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(urlOrReq);
+      if (options.params) {
+        if (typeof options.params === "object") {
+          Object.entries(options.params).forEach(([key, value]) => {
+            parsedUrl.searchParams.append(key, String(value));
+          });
+        } else if (typeof options.params === "string") {
+          const searchParams = new URLSearchParams(options.params);
+          searchParams.forEach((value, key) => {
+            parsedUrl.searchParams.append(key, value);
+          });
+        }
+      }
+      const requestOptions = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (parsedUrl.protocol === "https:" ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method,
+        // Utiliser la méthode définie plus haut
+        headers: {
+          Accept: "text/event-stream",
+          ...req?.headers || {},
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          ...contentType && { "Content-Type": contentType },
+          ...requestBody && typeof requestBody === "string" && { "Content-Length": Buffer.byteLength(requestBody).toString() },
+          ...requestBody && typeof requestBody !== "string" && { "Content-Length": Buffer.byteLength(JSON.stringify(requestBody)).toString() }
+        }
+      };
+      const client = parsedUrl.protocol === "https:" ? https : http2;
+      request = client.request(requestOptions, (response) => {
+        if (response.statusCode !== 200) {
+          isConnected = false;
+          reject(
+            new Error(`Server responded with status: ${response.statusCode}`)
+          );
+          return;
+        }
+        response.setEncoding("utf8");
+        response.on("data", handleSSEData);
+        response.on("end", () => {
+          isConnected = false;
+          request?.destroy();
+          request = null;
+          closeHandlers.forEach((handler) => handler());
+          resolve(null);
+        });
+        response.on("close", () => {
+          isConnected = false;
+          request?.destroy();
+          request = null;
+          closeHandlers.forEach((handler) => handler());
+          resolve(null);
+        });
+        response.on("error", (error) => {
+          isConnected = false;
+          request?.destroy();
+          request = null;
+          closeHandlers.forEach((handler) => handler());
+          reject(error);
+        });
+      });
+      request.on("error", (error) => {
+        isConnected = false;
+        request?.destroy();
+        request = null;
+        reject(error);
+      });
+      if (requestBody) {
+        if (typeof requestBody === "string") {
+          request.write(requestBody);
+        } else {
+          request.write(JSON.stringify(requestBody));
+        }
+      }
+      request.end();
+    });
+  }
+  return createClientInterface();
+}
+
+// src/sse/server.ts
+function initSSE(res, options) {
+  const cacheControl = options?.headers?.["Cache-Control"] || "no-cache";
+  const connection = options?.headers?.["Connection"] || "keep-alive";
+  const timeout = options?.timeout || 3e5;
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": cacheControl,
+    Connection: connection,
+    ...options?.headers || {}
+  });
+  const timeoutId = setTimeout(() => {
+    res.end();
+  }, timeout);
+  res.on("close", () => {
+    clearTimeout(timeoutId);
+  });
+  return timeoutId;
+}
+function send(res, data) {
+  if (res.writableEnded) return false;
+  return res.write(`data: ${data}
+
+`);
+}
+function sendJson(res, data) {
+  if (res.writableEnded) return false;
+  return res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+function sendEvent(res, event, data) {
+  if (res.writableEnded) return false;
+  res.write(`event: ${event}
+`);
+  return res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+function sseComment(res, comment) {
+  if (res.writableEnded) return false;
+  return res.write(`: ${comment}
+
+`);
+}
+function sseId(res, id) {
+  if (res.writableEnded) return false;
+  return res.write(`id: ${id}
+
+`);
+}
+function sseRetry(res, ms) {
+  if (res.writableEnded) return false;
+  return res.write(`retry: ${ms}
+
+`);
+}
+function sseClose(res, comment = "Connection closed") {
+  res.write(`: ${comment}
+
+`);
+  res.end();
+}
+function sseEventError(res, event, error, code = 500, details) {
+  res.writeHead(code, { "Content-Type": "text/event-stream" });
+  res.write(`event: ${event}
+`);
+  const errorData = {
+    message: error,
+    code,
+    details: details || null
+  };
+  res.write(`data: ${JSON.stringify(errorData)}
+
+`);
+  res.end();
+}
+
+// src/utils/adapter-base.ts
+var MAX_BODY_SIZE = 10485760;
+var RequestCookiesImpl = class {
+  _parsed = null;
+  _raw;
+  constructor(raw) {
+    this._raw = raw;
+  }
+  _parse() {
+    if (this._parsed !== null) return this._parsed;
+    this._parsed = {};
+    if (!this._raw) return this._parsed;
+    for (const part of this._raw.split(";")) {
+      const idx = part.indexOf("=");
+      if (idx === -1) continue;
+      const k = part.slice(0, idx).trim();
+      const v = part.slice(idx + 1).trim();
+      if (k) {
+        const unquoted = v.startsWith('"') && v.endsWith('"') ? v.slice(1, -1) : v;
+        try {
+          this._parsed[k] = decodeURIComponent(unquoted);
+        } catch {
+          this._parsed[k] = unquoted;
+        }
+      }
+    }
+    return this._parsed;
+  }
+  get(name) {
+    return this._parse()[name];
+  }
+  all() {
+    return { ...this._parse() };
+  }
+};
+var ResponseCookiesImpl = class {
+  _pending = [];
+  set(name, value, options = {}) {
+    this._pending.push({ name, value, opts: options });
+    return this;
+  }
+  delete(name, options = {}) {
+    return this.set(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+  }
+  serialize() {
+    return this._pending.map(({ name, value, opts }) => {
+      let str = `${name}=${encodeURIComponent(value)}`;
+      const path3 = opts.path !== void 0 ? opts.path : "/";
+      if (path3) str += `; Path=${path3}`;
+      if (opts.domain) str += `; Domain=${opts.domain}`;
+      if (opts.maxAge != null) str += `; Max-Age=${opts.maxAge}`;
+      if (opts.expires) str += `; Expires=${opts.expires.toUTCString()}`;
+      if (opts.httpOnly) str += "; HttpOnly";
+      if (opts.secure) str += "; Secure";
+      if (opts.sameSite) str += `; SameSite=${opts.sameSite}`;
+      return str;
+    });
+  }
+};
+function parseCookieHeader(headers) {
+  if (typeof headers.get === "function") {
+    return headers.get("cookie") ?? void 0;
+  }
+  const raw = headers["cookie"];
+  if (Array.isArray(raw)) return raw.join("; ");
+  return raw;
+}
+function withRequestMethods(Base) {
+  return class extends Base {
+    _zreqCookies;
+    getHeader(name) {
+      const h = this.headers;
+      if (typeof h.get === "function") {
+        return h.get(name) ?? void 0;
+      }
+      const val = h[name.toLowerCase()];
+      return Array.isArray(val) ? val[0] : val;
+    }
+    get cookies() {
+      if (!this._zreqCookies)
+        this._zreqCookies = new RequestCookiesImpl(parseCookieHeader(this.headers));
+      return this._zreqCookies;
+    }
+    json() {
+      return this.body().then((b) => JSON.parse(b.toString()));
+    }
+    form() {
+      return new Promise((resolve, reject) => {
+        const headers = this.headers;
+        const contentType = typeof headers.get === "function" ? headers.get("content-type") ?? "" : headers["content-type"] ?? "";
+        if (!contentType.startsWith("multipart/form-data")) {
+          reject(new Error("Content-Type is not multipart/form-data"));
+          return;
+        }
+        const boundaryMatch = contentType.match(/boundary=(.+)$/);
+        if (!boundaryMatch) {
+          reject(new Error("Boundary not found"));
+          return;
+        }
+        const boundary = boundaryMatch[1].trim();
+        this.body().then((buffer) => {
+          const result = {};
+          const delimiter = Buffer.from(`--${boundary}`);
+          const parts = [];
+          let offset = 0, idx;
+          while ((idx = buffer.indexOf(delimiter, offset)) !== -1) {
+            parts.push(buffer.subarray(offset, idx));
+            offset = idx + delimiter.length;
+          }
+          parts.push(buffer.subarray(offset));
+          for (let i = 1; i < parts.length - 1; i++) {
+            const content = parts[i].subarray(2);
+            const sepIdx = content.indexOf("\r\n\r\n");
+            if (sepIdx === -1) continue;
+            const hdr = content.subarray(0, sepIdx).toString();
+            const body = content.subarray(sepIdx + 4, content.length - 2);
+            const d = hdr.match(
+              /Content-Disposition: form-data; name="([^"]+)"(?:; filename="([^"]+)")?/i
+            );
+            if (!d) continue;
+            if (d[2]) {
+              const m = hdr.match(/Content-Type:\s*([^\r\n]+)/i);
+              result[d[1]] = {
+                filename: d[2],
+                mimetype: m ? m[1].trim() : "application/octet-stream",
+                data: body,
+                size: body.length
+              };
+            } else {
+              result[d[1]] = body.toString("utf-8");
+            }
+          }
+          resolve(result);
+        }).catch(reject);
+      });
+    }
+    createSSEClient(options, handlers) {
+      return createSSEClient(this, options, handlers);
+    }
+  };
+}
+function nodeBody() {
+  const chunks = [];
+  let size = 0, settled = false;
+  return new Promise((resolve, reject) => {
+    this.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        settled = true;
+        this.destroy();
+        reject(Object.assign(new Error("Payload Too Large"), { code: 413 }));
+        return;
+      }
+      chunks.push(chunk);
+    }).on("end", () => {
+      if (!settled) {
+        settled = true;
+        resolve(Buffer.concat(chunks));
+      }
+    }).on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+  });
+}
+function flushCookies(jar, res) {
+  const serialized = jar.serialize();
+  if (serialized.length > 0 && !res.headersSent)
+    res.setHeader("Set-Cookie", serialized);
+}
+function withResponseMethods(Base) {
+  return class extends Base {
+    _zresCookies;
+    get cookies() {
+      if (!this._zresCookies) this._zresCookies = new ResponseCookiesImpl();
+      return this._zresCookies;
+    }
+    end(data) {
+      if (this._zresCookies) flushCookies(this._zresCookies, this);
+      return super.end(data);
+    }
+    status(code) {
+      this.statusCode = code;
+      return this;
+    }
+    send(data) {
+      if (typeof data === "string") {
+        this.setHeader("Content-Type", "text/plain");
+        this.end(data);
+      } else {
+        this.json(data);
+      }
+      return this;
+    }
+    json(data) {
+      this.setHeader("Content-Type", "application/json");
+      this.end(JSON.stringify(data));
+      return this;
+    }
+    initSSE(options) {
+      return initSSE(this, options);
+    }
+    sseSend(data) {
+      send(this, data);
+    }
+    sseJson(data) {
+      sendJson(this, data);
+    }
+    sseEvent(event, data) {
+      sendEvent(this, event, data);
+    }
+    sseComment(comment) {
+      sseComment(this, comment);
+    }
+    sseId(id) {
+      sseId(this, id);
+    }
+    sseRetry(ms) {
+      sseRetry(this, ms);
+    }
+    sseClose(comment) {
+      sseClose(this, comment);
+    }
+    sseError(event, error, code = 500, details) {
+      sseEventError(this, event, error, code, details);
+    }
+  };
+}
+var _ReqBase = class {
+  params = {};
+  headers = {};
+  body() {
+    return nodeBody.call(this);
+  }
+};
+var _reqProto = withRequestMethods(_ReqBase).prototype;
+var _ResBase = class {
+  statusCode = 200;
+  headersSent = false;
+  setHeader(_n, _v) {
+  }
+  end(_d) {
+  }
+  write(_c) {
+  }
+};
+var _resProto = withResponseMethods(_ResBase).prototype;
+function applyRequestMethods(req) {
+  req.body = nodeBody;
+  req.json = _reqProto.json;
+  req.form = _reqProto.form;
+  req.getHeader = _reqProto.getHeader;
+  req.createSSEClient = _reqProto.createSSEClient;
+  req.cookies = new RequestCookiesImpl(parseCookieHeader(req.headers));
+}
+function applyResponseMethods(res) {
+  const p = _resProto;
+  res.status = p.status;
+  res.send = p.send;
+  res.json = p.json;
+  res.initSSE = p.initSSE;
+  res.sseSend = p.sseSend;
+  res.sseJson = p.sseJson;
+  res.sseEvent = p.sseEvent;
+  res.sseComment = p.sseComment;
+  res.sseId = p.sseId;
+  res.sseRetry = p.sseRetry;
+  res.sseClose = p.sseClose;
+  res.sseError = p.sseError;
+  const cookieJar = new ResponseCookiesImpl();
+  res.cookies = cookieJar;
+  const origEnd = res.end.bind(res);
+  res.end = function(...args) {
+    flushCookies(cookieJar, this);
+    return origEnd(...args);
+  };
+}
+var monitorInstance = null;
+function createMonitor(options = {}) {
+  const emitter = new EventEmitter();
+  const config = {
+    sampleInterval: options.sampleInterval || 5e3,
+    reportInterval: options.reportInterval || 6e4,
+    resetInterval: options.resetInterval || 24 * 60 * 60 * 1e3,
+    enableHistogram: options.enableHistogram !== void 0 ? options.enableHistogram : true,
+    logToConsole: options.logToConsole !== void 0 ? options.logToConsole : true,
+    thresholds: {
+      cpu: options.thresholds?.cpu || 80,
+      memory: options.thresholds?.memory || 80,
+      responseTime: options.thresholds?.responseTime || 1e3,
+      errorRate: options.thresholds?.errorRate || 5
+    }
+  };
+  const now = Date.now();
+  const data = {
+    requestCount: 0,
+    activeRequests: 0,
+    errorCount: 0,
+    responseTimes: [],
+    responseTimesBucket: Array(100).fill(0),
+    statusCodes: {},
+    lastReport: now,
+    lastReset: now
+  };
+  let metrics = getInitialMetrics();
+  let metricsHistory = [];
+  let lastCpuUsage = process.cpuUsage();
+  const alarmStatus = {
+    cpu: false,
+    memory: false,
+    responseTime: false,
+    errorRate: false
+  };
+  function getInitialMetrics() {
+    return {
+      timestamp: Date.now(),
+      uptime: process.uptime(),
+      requestCount: 0,
+      activeRequests: 0,
+      errorCount: 0,
+      responseTimes: {
+        min: 0,
+        max: 0,
+        avg: 0,
+        count: 0,
+        sum: 0
+      },
+      statusCodes: {},
+      memory: process.memoryUsage(),
+      cpu: {
+        usage: 0,
+        system: 0,
+        user: 0
+      },
+      systemLoad: os.loadavg(),
+      systemMemory: {
+        total: os.totalmem(),
+        free: os.freemem(),
+        used: os.totalmem() - os.freemem()
+      }
+    };
+  }
+  function calculateResponseTimeMetrics() {
+    const responseTimes = data.responseTimes;
+    if (responseTimes.length === 0) {
+      return {
+        min: 0,
+        max: 0,
+        avg: 0,
+        count: 0,
+        sum: 0
+      };
+    }
+    let min = Infinity;
+    let max = -Infinity;
+    let sum = 0;
+    for (const time of responseTimes) {
+      min = Math.min(min, time);
+      max = Math.max(max, time);
+      sum += time;
+    }
+    const avg = sum / responseTimes.length;
+    const result = {
+      min,
+      max,
+      avg,
+      count: responseTimes.length,
+      sum
+    };
+    if (config.enableHistogram) {
+      const sorted = [...responseTimes].sort((a, b) => a - b);
+      result.p50 = sorted[Math.floor(sorted.length * 0.5)];
+      result.p90 = sorted[Math.floor(sorted.length * 0.9)];
+      result.p99 = sorted[Math.floor(sorted.length * 0.99)];
+    }
+    return result;
+  }
+  function sampleMetrics() {
+    const now2 = Date.now();
+    const uptime = process.uptime();
+    const memoryUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage(lastCpuUsage);
+    lastCpuUsage = process.cpuUsage();
+    const cpuTotal = cpuUsage.user + cpuUsage.system;
+    const cpuPercentage = cpuTotal / 1e3 / config.sampleInterval * 100;
+    metrics = {
+      timestamp: now2,
+      uptime,
+      requestCount: data.requestCount,
+      activeRequests: data.activeRequests,
+      errorCount: data.errorCount,
+      responseTimes: calculateResponseTimeMetrics(),
+      statusCodes: { ...data.statusCodes },
+      memory: memoryUsage,
+      cpu: {
+        usage: cpuPercentage,
+        system: cpuUsage.system,
+        user: cpuUsage.user
+      },
+      systemLoad: os.loadavg(),
+      systemMemory: {
+        total: os.totalmem(),
+        free: os.freemem(),
+        used: os.totalmem() - os.freemem()
+      }
+    };
+    metricsHistory.push({ ...metrics });
+    if (metricsHistory.length > 100) {
+      metricsHistory.shift();
+    }
+    checkThresholds();
+    if (cluster3.isWorker && process.send) {
+      process.send({ type: "metrics", metrics });
+    }
+  }
+  function reportMetrics() {
+    if (!config.logToConsole) return;
+    if (cluster3.isPrimary === false) return;
+    const memoryMB = {
+      rss: (metrics.memory.rss / 1024 / 1024).toFixed(2),
+      heapTotal: (metrics.memory.heapTotal / 1024 / 1024).toFixed(2),
+      heapUsed: (metrics.memory.heapUsed / 1024 / 1024).toFixed(2)
+    };
+    const elapsedMs = Date.now() - data.lastReport;
+    const requestsPerSecond = (metrics.requestCount / (elapsedMs / 1e3)).toFixed(2);
+    const errorRate = metrics.requestCount ? (metrics.errorCount / metrics.requestCount * 100).toFixed(2) : "0.00";
+    primaryLog("\n\u{1F4CA} Server Performance Metrics \u{1F4CA}");
+    primaryLog(`Uptime: ${formatUptime(metrics.uptime)}`);
+    primaryLog(`Load: ${metrics.systemLoad[0].toFixed(2)}, ${metrics.systemLoad[1].toFixed(2)}, ${metrics.systemLoad[2].toFixed(2)}`);
+    primaryLog(`Requests: ${metrics.requestCount} total, ${requestsPerSecond} req/sec`);
+    primaryLog(`Active Requests: ${metrics.activeRequests}`);
+    primaryLog(`Errors: ${metrics.errorCount} (${errorRate}%)`);
+    if (metrics.responseTimes.count > 0) {
+      primaryLog(`Response Times: avg ${metrics.responseTimes.avg.toFixed(2)}ms, min ${metrics.responseTimes.min}ms, max ${metrics.responseTimes.max}ms`);
+      if (metrics.responseTimes.p50) {
+        primaryLog(`Response Time Percentiles: p50 ${metrics.responseTimes.p50}ms, p90 ${metrics.responseTimes.p90}ms, p99 ${metrics.responseTimes.p99}ms`);
+      }
+    }
+    primaryLog(`Memory: ${memoryMB.rss}MB (RSS), ${memoryMB.heapUsed}MB / ${memoryMB.heapTotal}MB (Heap)`);
+    primaryLog(`CPU Usage: ${metrics.cpu.usage.toFixed(2)}%`);
+    if (Object.keys(metrics.statusCodes).length > 0) {
+      primaryLog("Status Codes:");
+      Object.entries(metrics.statusCodes).sort(([a], [b]) => parseInt(a) - parseInt(b)).forEach(([code, count]) => {
+        primaryLog(`  ${code}: ${count}`);
+      });
+    }
+    primaryLog("");
+    data.lastReport = Date.now();
+  }
+  function resetMetrics() {
+    const now2 = Date.now();
+    data.requestCount = 0;
+    data.activeRequests = 0;
+    data.errorCount = 0;
+    data.responseTimes = [];
+    data.responseTimesBucket = Array(100).fill(0);
+    data.statusCodes = {};
+    data.lastReport = now2;
+    data.lastReset = now2;
+    primaryLog("\u{1F504} Performance metrics have been reset");
+  }
+  function checkThresholds() {
+    const memUsedPercent = metrics.memory.heapUsed / metrics.memory.heapTotal * 100;
+    const errorRate = metrics.requestCount ? metrics.errorCount / metrics.requestCount * 100 : 0;
+    const avgResponseTime = metrics.responseTimes.avg;
+    if (metrics.cpu.usage > config.thresholds.cpu && !alarmStatus.cpu) {
+      alarmStatus.cpu = true;
+      emitter.emit("alarm", "cpu", `High CPU usage: ${metrics.cpu.usage.toFixed(2)}%`);
+    } else if (metrics.cpu.usage <= config.thresholds.cpu && alarmStatus.cpu) {
+      alarmStatus.cpu = false;
+      emitter.emit("alarm-clear", "cpu", `CPU usage returned to normal: ${metrics.cpu.usage.toFixed(2)}%`);
+    }
+    if (memUsedPercent > config.thresholds.memory && !alarmStatus.memory) {
+      alarmStatus.memory = true;
+      emitter.emit("alarm", "memory", `High memory usage: ${memUsedPercent.toFixed(2)}%`);
+    } else if (memUsedPercent <= config.thresholds.memory && alarmStatus.memory) {
+      alarmStatus.memory = false;
+      emitter.emit("alarm-clear", "memory", `Memory usage returned to normal: ${memUsedPercent.toFixed(2)}%`);
+    }
+    if (avgResponseTime > config.thresholds.responseTime && !alarmStatus.responseTime) {
+      alarmStatus.responseTime = true;
+      emitter.emit("alarm", "responseTime", `High response time: ${avgResponseTime.toFixed(2)}ms`);
+    } else if (avgResponseTime <= config.thresholds.responseTime && alarmStatus.responseTime) {
+      alarmStatus.responseTime = false;
+      emitter.emit("alarm-clear", "responseTime", `Response time returned to normal: ${avgResponseTime.toFixed(2)}ms`);
+    }
+    if (errorRate > config.thresholds.errorRate && !alarmStatus.errorRate) {
+      alarmStatus.errorRate = true;
+      emitter.emit("alarm", "errorRate", `High error rate: ${errorRate.toFixed(2)}%`);
+    } else if (errorRate <= config.thresholds.errorRate && alarmStatus.errorRate) {
+      alarmStatus.errorRate = false;
+      emitter.emit("alarm-clear", "errorRate", `Error rate returned to normal: ${errorRate.toFixed(2)}%`);
+    }
+  }
+  function formatUptime(uptime) {
+    const days = Math.floor(uptime / 86400);
+    const hours = Math.floor(uptime % 86400 / 3600);
+    const minutes = Math.floor(uptime % 3600 / 60);
+    const seconds = Math.floor(uptime % 60);
+    const parts = [];
+    if (days > 0) parts.push(`${days}d`);
+    if (hours > 0) parts.push(`${hours}h`);
+    if (minutes > 0) parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+    return parts.join(" ");
+  }
+  function start() {
+    const sampleInterval = setInterval(sampleMetrics, config.sampleInterval);
+    const reportInterval = setInterval(reportMetrics, config.reportInterval);
+    const resetInterval = setInterval(resetMetrics, config.resetInterval);
+    return {
+      stop: () => {
+        clearInterval(sampleInterval);
+        clearInterval(reportInterval);
+        clearInterval(resetInterval);
+      }
+    };
+  }
+  function trackRequest() {
+    const startTime = Date.now();
+    data.activeRequests++;
+    return {
+      end: (statusCode, error = false) => {
+        const responseTime = Date.now() - startTime;
+        data.activeRequests--;
+        data.requestCount++;
+        data.responseTimes.push(responseTime);
+        if (data.responseTimes.length > 1e3) {
+          data.responseTimes.shift();
+        }
+        data.statusCodes[statusCode] = (data.statusCodes[statusCode] || 0) + 1;
+        if (error || statusCode >= 500) {
+          data.errorCount++;
+        }
+        return responseTime;
+      }
+    };
+  }
+  function isHealthy() {
+    return !Object.values(alarmStatus).some((status) => status);
+  }
+  function getHealthMetrics() {
+    const memUsedPercent = metrics.memory.heapUsed / metrics.memory.heapTotal * 100;
+    const errorRate = metrics.requestCount ? metrics.errorCount / metrics.requestCount * 100 : 0;
+    return {
+      status: isHealthy() ? "healthy" : "unhealthy",
+      uptime: metrics.uptime,
+      responseTimes: {
+        avg: metrics.responseTimes.avg,
+        p90: metrics.responseTimes.p90 || null,
+        p99: metrics.responseTimes.p99 || null
+      },
+      memory: {
+        usedMB: Math.round(metrics.memory.heapUsed / 1024 / 1024),
+        totalMB: Math.round(metrics.memory.heapTotal / 1024 / 1024),
+        percent: memUsedPercent.toFixed(2)
+      },
+      cpu: metrics.cpu.usage.toFixed(2),
+      requests: {
+        total: metrics.requestCount,
+        active: metrics.activeRequests,
+        errors: metrics.errorCount,
+        errorRate: errorRate.toFixed(2)
+      },
+      alerts: Object.entries(alarmStatus).filter(([_, status]) => status).map(([type]) => type)
+    };
+  }
+  const intervals = start();
+  return {
+    trackRequest,
+    getMetrics: () => ({ ...metrics }),
+    getMetricsHistory: () => [...metricsHistory],
+    getHealthMetrics,
+    isHealthy,
+    stop: intervals.stop,
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+    off: emitter.off.bind(emitter)
+  };
+}
+function getMonitor(options) {
+  if (!monitorInstance) {
+    const instance = createMonitor(options);
+    const originalStop = instance.stop;
+    instance.stop = () => {
+      originalStop();
+      monitorInstance = null;
+    };
+    monitorInstance = instance;
+  }
+  return monitorInstance;
+}
+function createLoadBalancer(options = {}) {
+  const reportInterval = options.reportInterval ?? 5e3;
+  const state = {
+    workers: /* @__PURE__ */ new Map(),
+    workerIds: []
+  };
+  function startWorker() {
+    if (!cluster3.isWorker) return;
+    let prevCpu = process.cpuUsage();
+    const reportStats = () => {
+      if (!process.send) return;
+      const memoryUsage = process.memoryUsage();
+      const cpuDelta = process.cpuUsage(prevCpu);
+      prevCpu = process.cpuUsage();
+      const load = (cpuDelta.user + cpuDelta.system) / (reportInterval * 1e3);
+      const msg = {
+        type: "stats",
+        stats: { pid: process.pid, load, lastUsed: Date.now(), memoryUsage }
+      };
+      process.send(msg);
+    };
+    reportStats();
+    setInterval(reportStats, reportInterval).unref();
+  }
+  function forkWorker() {
+    const worker = cluster3.fork();
+    state.workers.set(worker.id, {
+      pid: worker.process.pid,
+      load: 0,
+      lastUsed: Date.now(),
+      memoryUsage: { rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }
+    });
+    state.workerIds.push(worker.id);
+    primaryLog(`Worker ${worker.process.pid} started`);
+  }
+  let shuttingDown = false;
+  const exitCallbacks = [];
+  function start(numWorkers = os.cpus().length) {
+    if (!cluster3.isPrimary) {
+      return startWorker();
+    }
+    primaryLog(`\u{1F9F5} Launching ${numWorkers} workers...`);
+    for (let i = 0; i < numWorkers; i++) forkWorker();
+    cluster3.on("message", (worker, message) => {
+      if (message.type === "stats" && "stats" in message) {
+        const s = state.workers.get(worker.id);
+        if (s) Object.assign(s, message.stats);
+      }
+    });
+    cluster3.on("exit", (worker, code, signal) => {
+      state.workers.delete(worker.id);
+      state.workerIds = state.workerIds.filter((id) => id !== worker.id);
+      if (shuttingDown) {
+        exitCallbacks.forEach((cb) => cb());
+        return;
+      }
+      primaryLog(`Worker ${worker.process.pid} died (${signal || code}). Restarting...`);
+      setTimeout(() => forkWorker(), 1e3);
+    });
+  }
+  function shutdown(callback) {
+    shuttingDown = true;
+    const workerIds = Object.keys(cluster3.workers ?? {});
+    if (workerIds.length === 0) {
+      callback?.();
+      return;
+    }
+    let remaining = workerIds.length;
+    exitCallbacks.push(() => {
+      remaining--;
+      if (remaining === 0) callback?.();
+    });
+    for (const id of workerIds) cluster3.workers?.[id]?.kill();
+  }
+  return {
+    start,
+    shutdown,
+    getWorkerStats: () => Array.from(state.workers.entries()),
+    getActiveWorkerCount: () => state.workerIds.length
+  };
+}
+var _ZenoRequestBase = class extends http2.IncomingMessage {
+  params = {};
+  body = nodeBody;
+};
+var ZenoRequest = class extends withRequestMethods(_ZenoRequestBase) {
+};
+var ZenoResponse = class extends withResponseMethods(
+  http2.ServerResponse
+) {
+};
+var nodeAdapter = {
+  name: "node",
+  createHandler: (config) => {
+    if (typeof config !== "string") {
+      throw new Error(
+        "nodeAdapter requires a routesDir string, not a ServerlessConfig."
+      );
+    }
+    const routesDir = config;
+    return async (config2 = {}) => {
+      const {
+        port = 3e3,
+        defaultHeaders,
+        isDev,
+        cluster: clusterConfig,
+        monitoring = { enabled: false }
+      } = config2;
+      let performanceMonitor = null;
+      if (isDev && monitoring.enabled) {
+        performanceMonitor = getMonitor({
+          sampleInterval: monitoring.sampleInterval || 5e3,
+          reportInterval: monitoring.reportInterval || 6e4,
+          thresholds: monitoring.thresholds,
+          logToConsole: true
+        });
+        if (cluster3.isPrimary) {
+          primaryLog("\u{1F4CA} Development performance monitoring enabled");
+          performanceMonitor.on("alarm", (metricType, message) => {
+            primaryLog(`\u26A0\uFE0F ALERT: ${message}`);
+          });
+          performanceMonitor.on("alarm-clear", (metricType, message) => {
+            primaryLog(`\u2705 RESOLVED: ${message}`);
+          });
+        }
+      }
+      const defaultHeadersArr = defaultHeaders ? Object.entries(defaultHeaders) : [];
+      if (clusterConfig?.enabled && cluster3.isPrimary) {
+        const numWorkers = clusterConfig.workers ?? os__default.cpus().length;
+        const protocol = config2.httpsOptions ? "https" : "http";
+        primaryLog(`\u{1F9F5} Starting server with ${numWorkers} workers`);
+        if (cluster3.schedulingPolicy !== void 0) {
+          try {
+            cluster3.schedulingPolicy = cluster3.SCHED_RR;
+          } catch {
+          }
+        }
+        const lb = createLoadBalancer();
+        lb.start(numWorkers);
+        primaryLog(`\u{1F680} Server running at ${protocol}://localhost:${port}/` + (isDev ? " (dev)" : ""));
+        if (isDev && performanceMonitor) {
+          primaryLog(`\u{1F4CA} Performance monitoring available at http://localhost:${port}/health`);
+        }
+        return {
+          close: (callback) => {
+            if (performanceMonitor) performanceMonitor.stop();
+            lb.shutdown(callback);
+          }
+        };
+      }
+      if (cluster3.isWorker || !clusterConfig?.enabled) {
+        await loadRoutes(routesDir);
+        registerCorsConfig(config2.cors);
+        registerMiddlewareConfig(config2.middleware);
+        const handleRequest = async (req, res, requestTracker) => {
+          try {
+            if (isDev && performanceMonitor && req.url === "/health") {
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify(performanceMonitor.getHealthMetrics()));
+              requestTracker?.end(200);
+              return;
+            }
+            const rawUrl = req.url || "/";
+            const qIdx = rawUrl.indexOf("?");
+            const pathname = qIdx === -1 ? rawUrl : rawUrl.slice(0, qIdx);
+            if (hasMiddlewares()) {
+              const ok = await runMiddlewares(
+                "beforeRequest",
+                req,
+                res
+              );
+              if (ok === false || res.headersSent) {
+                requestTracker?.end(res.statusCode || 204);
+                return;
+              }
+            }
+            const route = findRoute(pathname, req.method || "GET");
+            if (!route) {
+              if (hasMiddlewares())
+                await runMiddlewares("onError", req, res);
+              res.status(404).json({ error: "Route not found" });
+              requestTracker?.end(404);
+              return;
+            }
+            if ("error" in route) {
+              const status = route.status || 500;
+              res.status(status).json({ error: route.error });
+              requestTracker?.end(status, true);
+              return;
+            }
+            req.params = route.params;
+            await route.handler(req, res);
+            if (hasMiddlewares()) {
+              await runMiddlewares("afterRequest", req, res);
+            }
+            if (!res.headersSent) res.end();
+            requestTracker?.end(res.statusCode || 200);
+          } catch (error) {
+            if (isDev) console.error("Error:", error);
+            if (!res.headersSent)
+              res.status(500).json({ error: "Internal Server Error" });
+            if (hasMiddlewares())
+              await runMiddlewares("onError", req, res);
+            requestTracker?.end(res.statusCode || 500, true);
+          }
+        };
+        const requestListener = (req, res) => {
+          const requestTracker = isDev && performanceMonitor ? performanceMonitor.trackRequest() : null;
+          if (defaultHeadersArr.length > 0) {
+            for (let i = 0; i < defaultHeadersArr.length; i++) {
+              res.setHeader(defaultHeadersArr[i][0], defaultHeadersArr[i][1]);
+            }
+          }
+          handleRequest(
+            req,
+            res,
+            requestTracker
+          ).catch((err) => {
+            if (isDev) console.error("Fatal error:", err);
+            if (!res.headersSent) {
+              res.statusCode = 500;
+              res.end("Server Error");
+            }
+            requestTracker?.end(500, true);
+          });
+        };
+        const serverOptions = {
+          IncomingMessage: ZenoRequest,
+          ServerResponse: ZenoResponse
+        };
+        const server = config2.httpsOptions ? https.createServer(
+          { ...serverOptions, ...config2.httpsOptions },
+          requestListener
+        ) : http2.createServer(serverOptions, requestListener);
+        server.on("clientError", (_err, socket) => {
+          if (!socket.destroyed) socket.destroy();
+        });
+        const protocol = config2.httpsOptions ? "https" : "http";
+        if (cluster3.isWorker) {
+          createLoadBalancer().start();
+        }
+        server.listen(port, () => {
+          if (!clusterConfig?.enabled) {
+            primaryLog(
+              `\u{1F680} Server running at ${protocol}://localhost:${port}/` + (isDev ? " (dev)" : "")
+            );
+            if (isDev && performanceMonitor) {
+              primaryLog(
+                `\u{1F4CA} Performance monitoring available at http://localhost:${port}/health`
+              );
+            }
+          } else if (isDev) {
+            primaryLog(`Worker ${process.pid} is listening on port ${port}`);
+          }
+        });
+        return server;
+      }
+      return null;
+    };
+  }
+};
+
+// src/adapters/vercel.ts
+var vercelAdapter = {
+  name: "vercel",
+  createHandler: (config) => {
+    if (typeof config === "string") {
+      throw new Error(
+        "vercelAdapter.createHandler() requires a ServerlessConfig object, not a routesDir string. Import your routes manifest and pass { routes } instead."
+      );
+    }
+    let initPromise = null;
+    const init = () => {
+      if (initPromise) return initPromise;
+      initPromise = (async () => {
+        registerRoutes(config.routes);
+        registerCorsConfig(config.cors);
+        registerMiddlewareConfig(config.middleware);
+      })();
+      return initPromise;
+    };
+    return async (vercelReq, vercelRes) => {
+      await init();
+      applyRequestMethods(vercelReq);
+      applyResponseMethods(vercelRes);
+      const req = vercelReq;
+      const res = vercelRes;
+      try {
+        if (hasMiddlewares()) {
+          const shouldContinue = await runMiddlewares("beforeRequest", req, res);
+          if (shouldContinue === false || res.headersSent) return;
+        }
+        const route = findRoute(req.url ?? "/", req.method ?? "GET");
+        if (!route) {
+          res.status(404).json({ error: "Route not found" });
+          return;
+        }
+        if (isRouteError(route)) {
+          res.status(route.status ?? 500).json({ error: route.error });
+          return;
+        }
+        req.params = route.params;
+        await route.handler(req, res);
+        if (hasMiddlewares()) await runMiddlewares("afterRequest", req, res);
+      } catch (error) {
+        console.error("[zeno/vercel] Handler error:", error);
+        if (hasMiddlewares()) await runMiddlewares("onError", req, res, { error });
+        if (!res.headersSent) {
+          res.status(500).json({ error: "Internal server error" });
+        }
+      }
+    };
+  }
+};
+function netlifyResponse(statusCode, headers, multiValueHeaders, body) {
+  const hasMulti = Object.keys(multiValueHeaders).length > 0;
+  return { statusCode, headers, ...hasMulti ? { multiValueHeaders } : {}, body };
+}
+var netlifyAdapter = {
+  name: "netlify",
+  createHandler: (config) => {
+    if (typeof config === "string") {
+      throw new Error(
+        "netlifyAdapter.createHandler() requires a ServerlessConfig object. Run `zeno build` to generate routes/_manifest.ts and pass { routes } instead."
+      );
+    }
+    let initPromise = null;
+    const init = () => {
+      if (initPromise) return initPromise;
+      initPromise = (async () => {
+        registerRoutes(config.routes);
+        registerCorsConfig(config.cors);
+        registerMiddlewareConfig(config.middleware);
+      })();
+      return initPromise;
+    };
+    return async (event, _context) => {
+      await init();
+      const qs = event.queryStringParameters ? "?" + new URLSearchParams(event.queryStringParameters).toString() : "";
+      const url = event.path + qs;
+      const rawReq = new IncomingMessage(new Socket());
+      rawReq.url = url;
+      rawReq.method = event.httpMethod;
+      rawReq.headers = event.headers;
+      if (event.body) {
+        rawReq.push(Buffer.from(event.body, "utf-8"));
+      }
+      rawReq.push(null);
+      let responseBody = "";
+      let responseHeaders = {};
+      let multiValueResponseHeaders = {};
+      let headersSent = false;
+      const rawRes = new ServerResponse(rawReq);
+      rawRes.writeHead = function(status, headers) {
+        rawRes.statusCode = status;
+        if (headers) responseHeaders = { ...responseHeaders, ...headers };
+        return this;
+      };
+      rawRes.setHeader = function(name, value) {
+        const key = name.toLowerCase();
+        if (Array.isArray(value)) {
+          multiValueResponseHeaders[key] = value.map(String);
+          responseHeaders[key] = String(value[0]);
+        } else {
+          responseHeaders[key] = String(value);
+        }
+        return this;
+      };
+      rawRes.getHeader = function(name) {
+        return responseHeaders[name.toLowerCase()];
+      };
+      rawRes.end = function(body) {
+        headersSent = true;
+        if (body !== void 0) responseBody = typeof body === "string" ? body : body.toString();
+        return this;
+      };
+      Object.defineProperty(rawRes, "headersSent", { get: () => headersSent });
+      applyRequestMethods(rawReq);
+      applyResponseMethods(rawRes);
+      const req = rawReq;
+      const res = rawRes;
+      const route = findRoute(event.path, event.httpMethod);
+      if (!route) {
+        return { statusCode: 404, body: JSON.stringify({ error: "Route not found" }) };
+      }
+      if (isRouteError(route)) {
+        return {
+          statusCode: route.status ?? 500,
+          body: JSON.stringify({ error: route.error })
+        };
+      }
+      try {
+        if (hasMiddlewares()) {
+          const shouldContinue = await runMiddlewares("beforeRequest", req, res);
+          if (shouldContinue === false || headersSent) {
+            return netlifyResponse(res.statusCode, responseHeaders, multiValueResponseHeaders, responseBody);
+          }
+        }
+        req.params = route.params;
+        await route.handler(req, res);
+        if (hasMiddlewares()) await runMiddlewares("afterRequest", req, res);
+        return netlifyResponse(res.statusCode, responseHeaders, multiValueResponseHeaders, responseBody);
+      } catch (error) {
+        console.error("[zeno/netlify] Handler error:", error);
+        if (hasMiddlewares()) await runMiddlewares("onError", req, res, { error });
+        if (!headersSent) {
+          return { statusCode: 500, body: JSON.stringify({ error: "Internal server error" }) };
+        }
+        return netlifyResponse(res.statusCode, responseHeaders, multiValueResponseHeaders, responseBody);
+      }
+    };
+  }
+};
+var MAX_BODY_SIZE2 = 10485760;
+var _encoder = new TextEncoder();
+var _BunRequestBase = class {
+  params = {};
+  url;
+  method;
+  headers;
+  socket = { setTimeout: (_) => {
+  } };
+  connection;
+  _req;
+  constructor(req, pathname, search) {
+    this._req = req;
+    this.url = pathname + search;
+    this.method = req.method;
+    this.headers = req.headers;
+    this.connection = {
+      remoteAddress: req.headers.get("x-forwarded-for") ?? "127.0.0.1"
+    };
+  }
+  setTimeout(_) {
+  }
+  text() {
+    return this._req.text();
+  }
+  body() {
+    return this._req.arrayBuffer().then((b) => {
+      if (b.byteLength > MAX_BODY_SIZE2)
+        throw Object.assign(new Error("Payload Too Large"), { code: 413 });
+      return Buffer.from(b);
+    });
+  }
+};
+var BunRequest = class extends withRequestMethods(_BunRequestBase) {
+  // Uses Bun native JSON parser directly, skipping the body() to Buffer conversion
+  json() {
+    return this._req.json();
+  }
+};
+var _BunResponseBase = class {
+  statusCode = 200;
+  headersSent = false;
+  get finished() {
+    return this.headersSent;
+  }
+  get writableEnded() {
+    return this.headersSent;
+  }
+  _body = null;
+  _headers = null;
+  _sseReadable = null;
+  _sseWriter = null;
+  _sseWindowClosed = false;
+  _listeners = null;
+  on(event, listener) {
+    if (event === "finish" || event === "close") {
+      if (!this._listeners) this._listeners = [];
+      this._listeners.push(listener);
+    }
+    return this;
+  }
+  once(event, listener) {
+    return this.on(event, listener);
+  }
+  emit(event) {
+    if ((event === "finish" || event === "close") && this._listeners)
+      for (let i = 0; i < this._listeners.length; i++) this._listeners[i]();
+    return true;
+  }
+  setHeader(name, value) {
+    if (!this._headers) this._headers = [];
+    if (Array.isArray(value)) {
+      for (const v of value) this._headers.push(name, v);
+    } else {
+      this._headers.push(name, value);
+    }
+    return this;
+  }
+  getHeader(name) {
+    if (!this._headers) return void 0;
+    const lo = name.toLowerCase();
+    for (let i = 0; i < this._headers.length; i += 2)
+      if (this._headers[i].toLowerCase() === lo) return this._headers[i + 1];
+  }
+  removeHeader(name) {
+    if (!this._headers) return this;
+    const lo = name.toLowerCase();
+    for (let i = 0; i < this._headers.length; i += 2)
+      if (this._headers[i].toLowerCase() === lo) {
+        this._headers.splice(i, 2);
+        break;
+      }
+    return this;
+  }
+  hasHeader(name) {
+    if (!this._headers) return false;
+    const lo = name.toLowerCase();
+    for (let i = 0; i < this._headers.length; i += 2)
+      if (this._headers[i].toLowerCase() === lo) return true;
+    return false;
+  }
+  writeHead(statusCode, headers) {
+    this.statusCode = statusCode;
+    if (headers)
+      for (const [k, v] of Object.entries(headers)) this.setHeader(k, v);
+    return this;
+  }
+  write(chunk) {
+    if (this._sseWriter) {
+      this._sseWriter.write(_encoder.encode(String(chunk)));
+      return true;
+    }
+    this._body = (this._body ?? "") + chunk;
+    return true;
+  }
+  end(data) {
+    if (data !== void 0) this.write(data);
+    if (this._sseWriter) this._sseWriter.close();
+    this.headersSent = true;
+    if (this._listeners)
+      for (let i = 0; i < this._listeners.length; i++) this._listeners[i]();
+    return this;
+  }
+  _initSseStream() {
+    if (this._sseWindowClosed)
+      throw new Error("[zeno/bun] initSSE() must be called synchronously before any `await` in your handler.");
+    const { readable, writable } = new TransformStream();
+    this._sseReadable = readable;
+    this._sseWriter = writable.getWriter();
+  }
+  _closeSseWindow() {
+    this._sseWindowClosed = true;
+  }
+};
+var BunResponse = class extends withResponseMethods(_BunResponseBase) {
+  // Override initSSE to set up a TransformStream before calling writeHead
+  initSSE(options) {
+    this._initSseStream();
+    return super.initSSE(options);
+  }
+};
+var bunAdapter = {
+  name: "bun",
+  createHandler: (config) => {
+    if (typeof config !== "string") {
+      throw new Error(
+        "bunAdapter requires a routesDir string, not a ServerlessConfig."
+      );
+    }
+    const routesDir = config;
+    return async (config2 = {}) => {
+      const { isDev, port = 3e3, defaultHeaders, cluster: clusterConfig } = config2;
+      const primaryPid = parseInt(process.env.ZENO_BUN_WORKER ?? "0");
+      const isWorker = primaryPid > 0;
+      if (clusterConfig?.enabled && !isWorker) {
+        const numWorkers = clusterConfig.workers ?? os__default.cpus().length;
+        primaryLog(`\u{1F9F5} Starting Bun server with ${numWorkers} workers (reusePort)`);
+        const procs = Array.from(
+          { length: numWorkers },
+          () => Bun.spawn(process.argv, {
+            env: { ...process.env, ZENO_BUN_WORKER: String(process.pid) },
+            stdout: "ignore",
+            stderr: "inherit"
+          })
+        );
+        primaryLog(`\u{1F680} Server running at http://localhost:${port}/`);
+        return {
+          close: (callback) => {
+            for (const p of procs) p.kill();
+            callback?.();
+          }
+        };
+      }
+      if (isWorker) {
+        const interval = setInterval(() => {
+          try {
+            process.kill(primaryPid, 0);
+          } catch {
+            clearInterval(interval);
+            process.exit(0);
+          }
+        }, 2e3);
+        interval.unref();
+      }
+      primaryLog("\u{1F680} Bun high-performance mode enabled");
+      await loadRoutes(routesDir);
+      registerCorsConfig(config2.cors);
+      registerMiddlewareConfig(config2.middleware);
+      const defaultHeadersEntries = defaultHeaders ? Object.entries(defaultHeaders) : [];
+      const server = Bun.serve({
+        port,
+        reusePort: isWorker,
+        async fetch(request) {
+          const url = new URL(request.url);
+          const pathname = url.pathname;
+          const req = new BunRequest(request, pathname, url.search);
+          const res = new BunResponse();
+          try {
+            for (let i = 0; i < defaultHeadersEntries.length; i++) {
+              res.setHeader(
+                defaultHeadersEntries[i][0],
+                defaultHeadersEntries[i][1]
+              );
+            }
+            if (hasMiddlewares()) {
+              const ok = await runMiddlewares(
+                "beforeRequest",
+                req,
+                res
+              );
+              if (!ok || res.headersSent) return buildResponse(res);
+            }
+            const route = findRoute(pathname, request.method);
+            if (!route) {
+              if (hasMiddlewares())
+                await runMiddlewares("onError", req, res);
+              return new Response(
+                JSON.stringify({ error: "Route not found" }),
+                {
+                  status: 404,
+                  headers: { "Content-Type": "application/json" }
+                }
+              );
+            }
+            if ("error" in route) {
+              if (hasMiddlewares())
+                await runMiddlewares("onError", req, res);
+              return new Response(JSON.stringify({ error: route.error }), {
+                status: route.status || 500,
+                headers: { "Content-Type": "application/json" }
+              });
+            }
+            req.params = route.params;
+            let handlerError = null;
+            const handlerDone = (async () => {
+              await route.handler(req, res);
+              if (hasMiddlewares())
+                await runMiddlewares("afterRequest", req, res);
+              if (!res.headersSent) res.end();
+            })().catch((err) => {
+              handlerError = err;
+              if (isDev) console.error("Server error:", err);
+              if (res._sseReadable && !res.headersSent) res.end();
+            });
+            res._closeSseWindow();
+            if (res._sseReadable) {
+              return buildResponse(res, res._sseReadable);
+            }
+            await handlerDone;
+            if (handlerError && !res.headersSent) {
+              return new Response(
+                JSON.stringify({ error: "Internal Server Error" }),
+                {
+                  status: 500,
+                  headers: { "Content-Type": "application/json" }
+                }
+              );
+            }
+            return buildResponse(res);
+          } catch (error) {
+            if (isDev) console.error("Server error:", error);
+            return new Response(
+              JSON.stringify({ error: "Internal Server Error" }),
+              {
+                status: 500,
+                headers: { "Content-Type": "application/json" }
+              }
+            );
+          }
+        }
+      });
+      primaryLog(
+        `\u{1F680} Server started on http://localhost:${port}${isDev ? " (dev)" : ""}`
+      );
+      return {
+        close: () => {
+          server.stop();
+        }
+      };
+    };
+  }
+};
+function buildResponse(res, body) {
+  const responseBody = body ?? res._body;
+  if (!res._headers) return new Response(responseBody, { status: res.statusCode });
+  const headers = new Headers();
+  for (let i = 0; i < res._headers.length; i += 2) {
+    const name = res._headers[i];
+    const value = res._headers[i + 1];
+    if (name.toLowerCase() === "set-cookie") {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  }
+  return new Response(responseBody, { status: res.statusCode, headers });
+}
+
+// src/adapters/index.ts
+var adapters = {
+  node: nodeAdapter,
+  vercel: vercelAdapter,
+  netlify: netlifyAdapter,
+  bun: bunAdapter
+};
+function getAdapter(platform = "node") {
+  const adapter = adapters[platform];
+  if (!adapter) {
+    throw new Error(`Platform "${platform}" not supported`);
+  }
+  return adapter;
+}
+
+export { addMiddleware, addPathMiddleware, bunAdapter, collectMiddleware, createCorsMiddleware, createSSEClient, findRoute, getAdapter, getPathMiddlewares, getRouterStats, getRoutesDir, hasMiddlewares, initSSE, isRouteError, loadMiddlewares, loadRoutes, netlifyAdapter, nodeAdapter, primaryLog, registerCorsConfig, registerMiddlewareConfig, registerRoutes, resetMiddlewares, resetRouter, router, runMiddlewares, send, sendEvent, sendJson, setVerboseLogging, sseClose, sseComment, sseEventError, sseId, sseRetry, vercelAdapter };