@stacksjs/bun-router 0.0.8 → 0.0.9

package/dist/index.js

@@ -66,7 +66,7 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-jhsk5c5b.js";
+} from "./chunk-n5pvpz7q.js";
 
 // src/auth.ts
 function base64UrlEncode(str) {
@@ -2787,7 +2787,8 @@ function request() {
 // src/response/response-factory.ts
 var response = {
   json: (data, options = {}) => {
-    const { status = 200, headers = {}, pretty = false } = options;
+    const opts = typeof options === "number" ? { status: options } : options;
+    const { status = 200, headers = {}, pretty = false } = opts;
     const body = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
     return new Response(body, {
       status,
@@ -9546,513 +9547,6 @@ function applyRequestEnhancements(req, params = {}) {
   return getEnhancementHost().enhanceRequest(req, params);
 }
 
-// src/router/server.ts
-function registerServerHandling(RouterClass) {
-  Object.defineProperties(RouterClass.prototype, {
-    serve: {
-      async value(options = {}) {
-        if (this._initFileRoutes) {
-          await this._initFileRoutes();
-        }
-        if (this._initApiRoutes) {
-          await this._initApiRoutes();
-        }
-        this.invalidateCache();
-        const serverOptions = {
-          idleTimeout: 255,
-          ...options,
-          fetch: this.handleRequest.bind(this)
-        };
-        const staticRouteMap = {};
-        if (this.staticResponses && this.staticResponses.size > 0) {
-          for (const [path, response2] of this.staticResponses) {
-            staticRouteMap[path] = response2;
-          }
-        }
-        if (options.static) {
-          Object.assign(staticRouteMap, options.static);
-        }
-        if (Object.keys(staticRouteMap).length > 0) {
-          serverOptions.static = staticRouteMap;
-        }
-        if (options.development !== undefined) {
-          serverOptions.development = options.development;
-        }
-        if (this.wsConfig) {
-          serverOptions.websocket = this.wsConfig;
-        }
-        this.serverInstance = Bun.serve(serverOptions);
-        if (this.config.verbose) {
-          const port = this.serverInstance.port;
-          const hostname = this.serverInstance.hostname;
-          console.log(`
-\uD83D\uDE80 Server running at http://${hostname}:${port}
-`);
-        }
-        return this.serverInstance;
-      },
-      writable: true,
-      configurable: true
-    },
-    reload: {
-      async value() {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot reload");
-        }
-        this.invalidateCache();
-        const port = this.serverInstance.port;
-        const hostname = this.serverInstance.hostname;
-        this.serverInstance.stop();
-        this.serverInstance = Bun.serve({
-          port,
-          hostname,
-          fetch: this.handleRequest.bind(this),
-          websocket: this.wsConfig || undefined
-        });
-        if (this.config.verbose) {
-          console.log(`\uD83D\uDD04 Server reloaded at http://${hostname}:${port}`);
-        }
-      },
-      writable: true,
-      configurable: true
-    },
-    handleRequest: {
-      async value(req) {
-        const self = this;
-        return runWithRequest(req, () => self.handleRequestImpl(req));
-      },
-      writable: true,
-      configurable: true
-    },
-    handleRequestImpl: {
-      async value(req) {
-        try {
-          const url2 = new URL(req.url);
-          if (req.method === "OPTIONS") {
-            const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-            const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
-            if (!optionsMatch) {
-              return new Response(null, {
-                status: 204,
-                headers: {
-                  "Access-Control-Allow-Origin": "*",
-                  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-                  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin",
-                  "Access-Control-Max-Age": "86400",
-                  "Access-Control-Allow-Credentials": "true"
-                }
-              });
-            }
-          }
-          const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
-          const match = this.matchRoute(url2.pathname, req.method, hostname);
-          const enhancedReq = this.enhanceRequest(req, match?.params || {});
-          setCurrentRequest(enhancedReq);
-          if (match) {
-            enhancedReq.route = match.route;
-            const middlewareStack = [...this.globalMiddleware];
-            if (match.route.middleware && match.route.middleware.length > 0) {
-              middlewareStack.push(...match.route.middleware);
-            }
-            const routeHandlerMiddleware = async (req2, _next) => {
-              return await this.resolveHandler(match.route.handler, req2);
-            };
-            middlewareStack.push(routeHandlerMiddleware);
-            const response2 = await this.runMiddleware(enhancedReq, middlewareStack);
-            if (response2) {
-              return this.applyModifiedCookies(response2, enhancedReq);
-            }
-            return new Response("No response from middleware chain", { status: 500 });
-          }
-          const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
-          const corsHeaders = {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
-          };
-          if (allowedMethods.length > 0) {
-            const methodNotAllowedHandler = async (_req, _next) => {
-              return new Response(JSON.stringify({
-                success: false,
-                message: "Method Not Allowed",
-                path: url2.pathname,
-                method: req.method,
-                allowed: allowedMethods
-              }), {
-                status: 405,
-                headers: { ...corsHeaders, Allow: allowedMethods.join(", ") }
-              });
-            };
-            if (this.globalMiddleware.length > 0) {
-              const stack = [...this.globalMiddleware, methodNotAllowedHandler];
-              const response2 = await this.runMiddleware(enhancedReq, stack);
-              if (response2)
-                return this.applyModifiedCookies(response2, enhancedReq);
-            }
-            return await methodNotAllowedHandler(enhancedReq, async () => null);
-          }
-          if (this.fallbackHandler) {
-            const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
-            return this.applyModifiedCookies(response2, enhancedReq);
-          }
-          const notFoundHandler = async (_req, _next) => {
-            return new Response(JSON.stringify({
-              success: false,
-              message: "Not Found",
-              path: url2.pathname,
-              method: req.method
-            }), { status: 404, headers: corsHeaders });
-          };
-          if (this.globalMiddleware.length > 0) {
-            const stack = [...this.globalMiddleware, notFoundHandler];
-            const response2 = await this.runMiddleware(enhancedReq, stack);
-            if (response2)
-              return this.applyModifiedCookies(response2, enhancedReq);
-          }
-          return await notFoundHandler(enhancedReq, async () => null);
-        } catch (error) {
-          console.error("Error handling request:", error);
-          if (this.errorHandler) {
-            return this.errorHandler(error);
-          }
-          return new Response(JSON.stringify({
-            success: false,
-            message: "Internal Server Error",
-            error: error instanceof Error ? error.message : String(error)
-          }), {
-            status: 500,
-            headers: {
-              "Content-Type": "application/json",
-              "Access-Control-Allow-Origin": "*",
-              "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-              "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
-            }
-          });
-        }
-      },
-      writable: true,
-      configurable: true
-    },
-    enhanceRequest: {
-      value(req, params = {}) {
-        let parsedCookies = null;
-        const getCookies = () => {
-          if (parsedCookies === null) {
-            parsedCookies = {};
-            const cookieHeader = req.headers.get("cookie") || "";
-            cookieHeader.split(";").forEach((cookie) => {
-              const parts = cookie.trim().split("=");
-              if (parts.length >= 2) {
-                const name = parts[0].trim();
-                const value = parts.slice(1).join("=").trim();
-                parsedCookies[name] = decodeURIComponent(value);
-              }
-            });
-          }
-          return parsedCookies;
-        };
-        const cookies = {
-          get: (name) => getCookies()[name],
-          set: (name, value, options = {}) => {
-            const enhancedRequest = req;
-            if (!enhancedRequest._cookiesToSet) {
-              enhancedRequest._cookiesToSet = [];
-            }
-            enhancedRequest._cookiesToSet.push({ name, value, options });
-          },
-          delete: (name, options = {}) => {
-            const enhancedRequest = req;
-            if (!enhancedRequest._cookiesToDelete) {
-              enhancedRequest._cookiesToDelete = [];
-            }
-            enhancedRequest._cookiesToDelete.push({ name, options });
-          },
-          getAll: () => ({ ...getCookies() })
-        };
-        const enhancedReq = Object.assign(req, {
-          params,
-          cookies: getCookies(),
-          _cookiesToSet: [],
-          _cookiesToDelete: []
-        });
-        Object.assign(enhancedReq, { cookies: { ...getCookies(), ...cookies } });
-        return enhancedReq;
-      },
-      writable: true,
-      configurable: true
-    },
-    applyModifiedCookies: {
-      value(response2, req) {
-        const newResponse = new Response(response2.body, {
-          status: response2.status,
-          statusText: response2.statusText,
-          headers: response2.headers
-        });
-        if (req._cookiesToSet && req._cookiesToSet.length > 0) {
-          for (const { name, value, options } of req._cookiesToSet) {
-            const cookieString = this.serializeCookie(name, value, options);
-            newResponse.headers.append("Set-Cookie", cookieString);
-          }
-        }
-        if (req._cookiesToDelete && req._cookiesToDelete.length > 0) {
-          for (const { name, options } of req._cookiesToDelete) {
-            const deletionOptions = {
-              ...options,
-              expires: new Date(0),
-              maxAge: 0
-            };
-            const cookieString = this.serializeCookie(name, "", deletionOptions);
-            newResponse.headers.append("Set-Cookie", cookieString);
-          }
-        }
-        return newResponse;
-      },
-      writable: true,
-      configurable: true
-    },
-    serializeCookie: {
-      value(name, value, options = {}) {
-        let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-        if (options.maxAge !== undefined) {
-          cookie += `; Max-Age=${options.maxAge}`;
-        }
-        if (options.expires && options.expires instanceof Date) {
-          cookie += `; Expires=${options.expires.toUTCString()}`;
-        }
-        if (options.path) {
-          cookie += `; Path=${options.path}`;
-        } else {
-          cookie += "; Path=/";
-        }
-        if (options.domain) {
-          cookie += `; Domain=${options.domain}`;
-        }
-        if (options.secure) {
-          cookie += "; Secure";
-        }
-        if (options.httpOnly) {
-          cookie += "; HttpOnly";
-        }
-        if (options.sameSite) {
-          const sameSite = options.sameSite.toLowerCase();
-          cookie += `; SameSite=${sameSite.charAt(0).toUpperCase() + sameSite.slice(1)}`;
-        }
-        return cookie;
-      },
-      writable: true,
-      configurable: true
-    }
-  });
-}
-
-// src/router/view-rendering.ts
-import { join as join4 } from "path";
-function registerViewRendering(RouterClass) {
-  Object.defineProperties(RouterClass.prototype, {
-    renderView: {
-      async value(view, data = {}, options = {}) {
-        const viewsConfig = this.config.views || {
-          viewsPath: "resources/views",
-          extensions: [".html", ".stx"],
-          cache: Bun.env.NODE_ENV === "production",
-          engine: "auto"
-        };
-        const cacheKey = `${view}:${options.layout || ""}`;
-        if (viewsConfig.cache && this.templateCache.has(cacheKey)) {
-          return this.processTemplate(this.templateCache.get(cacheKey), data, viewsConfig);
-        }
-        const viewPath = await resolveViewPath(view, viewsConfig.viewsPath, viewsConfig.extensions);
-        if (!viewPath) {
-          throw new Error(`View '${view}' not found`);
-        }
-        let viewContent = await Bun.file(viewPath).text();
-        const layoutName = options.layout || viewsConfig.defaultLayout;
-        if (layoutName) {
-          const layoutPath = await resolveViewPath(join4("layouts", layoutName), viewsConfig.viewsPath, viewsConfig.extensions);
-          if (!layoutPath) {
-            throw new Error(`Layout '${layoutName}' not found`);
-          }
-          const layoutContent = await Bun.file(layoutPath).text();
-          viewContent = layoutContent.replace(/\{\{\s*content\s*\}\}/g, viewContent);
-        }
-        if (viewsConfig.cache) {
-          this.templateCache.set(cacheKey, viewContent);
-        }
-        return this.processTemplate(viewContent, data, viewsConfig);
-      },
-      writable: true,
-      configurable: true
-    },
-    processTemplate: {
-      async value(template, data, viewConfig) {
-        const engine = viewConfig?.engine || "auto";
-        if (engine === "custom" && viewConfig?.customRenderer) {
-          return viewConfig.customRenderer(template, data, {});
-        }
-        let processedTemplate = processHtmlTemplate(template, data);
-        if (viewConfig?.minify?.enabled) {
-          try {
-            const _minifyOptions = viewConfig.minify.options || {
-              removeComments: true,
-              collapseWhitespace: true,
-              minifyJS: true,
-              minifyCSS: true
-            };
-            processedTemplate = processedTemplate.replace(/\s+/g, " ").replace(/<!--[\s\S]*?-->/g, "");
-          } catch (err) {
-            console.error("Error minifying HTML:", err);
-          }
-        }
-        return processedTemplate;
-      },
-      writable: true,
-      configurable: true
-    },
-    view: {
-      value(path, viewOrData, dataOrOptions = {}, optionsOrType = {}, typeOrName = "web", name) {
-        let view;
-        let data = {};
-        let options = {};
-        let type = "web";
-        let routeName;
-        if (typeof viewOrData === "string") {
-          view = viewOrData;
-          if (typeof dataOrOptions === "object" && !Array.isArray(dataOrOptions)) {
-            if ("layout" in dataOrOptions || "status" in dataOrOptions || "headers" in dataOrOptions) {
-              options = dataOrOptions;
-            } else {
-              data = dataOrOptions;
-            }
-          }
-          if (typeof optionsOrType === "object") {
-            options = { ...options, ...optionsOrType };
-          } else if (typeof optionsOrType === "string") {
-            type = optionsOrType;
-          }
-          if (typeof typeOrName === "string") {
-            if (typeOrName === "web" || typeOrName === "api") {
-              type = typeOrName;
-            } else {
-              routeName = typeOrName;
-            }
-          }
-          if (name) {
-            routeName = name;
-          }
-        } else {
-          data = viewOrData;
-          if (typeof dataOrOptions === "string") {
-            view = dataOrOptions;
-          } else {
-            throw new TypeError("View name must be a string");
-          }
-          if (typeof optionsOrType === "object") {
-            options = optionsOrType;
-          } else if (typeof optionsOrType === "string") {
-            if (optionsOrType === "web" || optionsOrType === "api") {
-              type = optionsOrType;
-            } else {
-              view = optionsOrType;
-              type = "web";
-            }
-          }
-        }
-        const handler = async (_req) => {
-          let renderedView = await this.renderView(view, data, {
-            layout: options.layout
-          });
-          const queryPreservationConfig = this.config?.queryPreservation;
-          if (queryPreservationConfig?.enabled !== false && queryPreservationConfig?.preserve?.length) {
-            renderedView = injectQueryPreservationScript(renderedView, queryPreservationConfig);
-          }
-          const headers = new Headers;
-          headers.set("Content-Type", "text/html; charset=utf-8");
-          if (options.headers) {
-            for (const [key, value] of Object.entries(options.headers)) {
-              headers.set(key, value);
-            }
-          }
-          return new Response(renderedView, {
-            status: options.status || 200,
-            headers
-          });
-        };
-        this.get(path, handler, type, routeName);
-        return this;
-      },
-      writable: true,
-      configurable: true
-    }
-  });
-}
-
-// src/router/websocket.ts
-function registerWebSocketHandling(RouterClass) {
-  Object.defineProperties(RouterClass.prototype, {
-    websocket: {
-      value(config2) {
-        this.wsConfig = config2;
-        return this;
-      },
-      writable: true,
-      configurable: true
-    },
-    publish: {
-      value(topic, data, compress = false) {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot publish to WebSocket topics");
-        }
-        return this.serverInstance.publish(topic, data, compress);
-      },
-      writable: true,
-      configurable: true
-    },
-    subscriberCount: {
-      value(topic) {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot get subscriber count");
-        }
-        return this.serverInstance.subscriberCount(topic);
-      },
-      writable: true,
-      configurable: true
-    },
-    upgrade: {
-      value(request2, options) {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot upgrade to WebSocket");
-        }
-        if (!this.wsConfig) {
-          throw new Error("WebSocket configuration not set, use router.websocket() to configure");
-        }
-        return this.serverInstance.upgrade(request2, options);
-      },
-      writable: true,
-      configurable: true
-    },
-    timeout: {
-      value(request2, seconds) {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot set timeout");
-        }
-        this.serverInstance.timeout(request2, seconds);
-      },
-      writable: true,
-      configurable: true
-    },
-    requestIP: {
-      value(request2) {
-        if (!this.serverInstance) {
-          throw new Error("Server not started, cannot get request IP");
-        }
-        return this.serverInstance.requestIP(request2);
-      },
-      writable: true,
-      configurable: true
-    }
-  });
-}
 // src/request/macros.ts
 class RequestMacroRegistry {
   macros = new Map;
@@ -10275,91 +9769,599 @@ var BuiltInRequestMacros = {
         if (key && value) {
           cookies[key] = decodeURIComponent(value);
         }
-      });
-    }
-    return cookies;
-  },
-  file(name) {
-    return this.files?.find((f) => f.fieldName === name);
-  },
-  hasFile(name) {
-    return !!this.files?.find((f) => f.fieldName === name);
-  },
-  path() {
-    return new URL(this.url).pathname;
-  },
-  fullUrl() {
-    return this.url;
-  },
-  root() {
-    const url2 = new URL(this.url);
-    return `${url2.protocol}//${url2.host}`;
-  },
-  is(pattern) {
-    const path = this.path();
-    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(path);
-  },
-  route() {
-    return this.routeName || null;
-  },
-  fingerprint() {
-    const url2 = new URL(this.url);
-    const data = {
-      method: this.method,
-      path: url2.pathname,
-      query: url2.search,
-      ip: BuiltInRequestMacros.ip.call(this)
-    };
-    return btoa(JSON.stringify(data));
-  },
-  signature(secret) {
-    const data = `${this.method}${this.url}${BuiltInRequestMacros.ip.call(this)}${secret}`;
-    let hash = 0;
-    for (let i = 0;i < data.length; i++) {
-      const char = data.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
+      });
+    }
+    return cookies;
+  },
+  file(name) {
+    return this.files?.find((f) => f.fieldName === name);
+  },
+  hasFile(name) {
+    return !!this.files?.find((f) => f.fieldName === name);
+  },
+  path() {
+    return new URL(this.url).pathname;
+  },
+  fullUrl() {
+    return this.url;
+  },
+  root() {
+    const url2 = new URL(this.url);
+    return `${url2.protocol}//${url2.host}`;
+  },
+  is(pattern) {
+    const path = this.path();
+    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(path);
+  },
+  route() {
+    return this.routeName || null;
+  },
+  fingerprint() {
+    const url2 = new URL(this.url);
+    const data = {
+      method: this.method,
+      path: url2.pathname,
+      query: url2.search,
+      ip: BuiltInRequestMacros.ip.call(this)
+    };
+    return btoa(JSON.stringify(data));
+  },
+  signature(secret) {
+    const data = `${this.method}${this.url}${BuiltInRequestMacros.ip.call(this)}${secret}`;
+    let hash = 0;
+    for (let i = 0;i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  },
+  merge(data) {
+    if (!this.validated) {
+      this.validated = {};
+    }
+    Object.assign(this.validated, data);
+  },
+  replace(data) {
+    this.validated = { ...data };
+  },
+  age() {
+    const startTime = this.startTime || Date.now();
+    return Date.now() - startTime;
+  },
+  isFromTrustedProxy(trustedProxies = []) {
+    const ip = BuiltInRequestMacros.ip.call(this);
+    return trustedProxies.includes(ip);
+  },
+  contentLength() {
+    const length = this.headers.get("content-length");
+    return length ? Number.parseInt(length, 10) : 0;
+  },
+  contentType() {
+    return this.headers.get("content-type");
+  },
+  isContentType(type) {
+    const contentType = this.contentType();
+    return contentType ? contentType.includes(type) : false;
+  }
+};
+function registerBuiltInRequestMacros() {
+  Object.entries(BuiltInRequestMacros).forEach(([name, handler]) => {
+    RequestWithMacros.macro(name, handler);
+  });
+}
+registerBuiltInRequestMacros();
+
+// src/router/server.ts
+function registerServerHandling(RouterClass) {
+  Object.defineProperties(RouterClass.prototype, {
+    serve: {
+      async value(options = {}) {
+        if (this._initFileRoutes) {
+          await this._initFileRoutes();
+        }
+        if (this._initApiRoutes) {
+          await this._initApiRoutes();
+        }
+        this.invalidateCache();
+        const serverOptions = {
+          idleTimeout: 255,
+          ...options,
+          fetch: this.handleRequest.bind(this)
+        };
+        const staticRouteMap = {};
+        if (this.staticResponses && this.staticResponses.size > 0) {
+          for (const [path, response2] of this.staticResponses) {
+            staticRouteMap[path] = response2;
+          }
+        }
+        if (options.static) {
+          Object.assign(staticRouteMap, options.static);
+        }
+        if (Object.keys(staticRouteMap).length > 0) {
+          serverOptions.static = staticRouteMap;
+        }
+        if (options.development !== undefined) {
+          serverOptions.development = options.development;
+        }
+        if (this.wsConfig) {
+          serverOptions.websocket = this.wsConfig;
+        }
+        this.serverInstance = Bun.serve(serverOptions);
+        if (this.config.verbose) {
+          const port = this.serverInstance.port;
+          const hostname = this.serverInstance.hostname;
+          console.log(`
+\uD83D\uDE80 Server running at http://${hostname}:${port}
+`);
+        }
+        return this.serverInstance;
+      },
+      writable: true,
+      configurable: true
+    },
+    reload: {
+      async value() {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot reload");
+        }
+        this.invalidateCache();
+        const port = this.serverInstance.port;
+        const hostname = this.serverInstance.hostname;
+        this.serverInstance.stop();
+        this.serverInstance = Bun.serve({
+          port,
+          hostname,
+          fetch: this.handleRequest.bind(this),
+          websocket: this.wsConfig || undefined
+        });
+        if (this.config.verbose) {
+          console.log(`\uD83D\uDD04 Server reloaded at http://${hostname}:${port}`);
+        }
+      },
+      writable: true,
+      configurable: true
+    },
+    handleRequest: {
+      async value(req) {
+        const self = this;
+        return runWithRequest(req, () => self.handleRequestImpl(req));
+      },
+      writable: true,
+      configurable: true
+    },
+    handleRequestImpl: {
+      async value(req) {
+        try {
+          const url2 = new URL(req.url);
+          if (req.method === "OPTIONS") {
+            const hostname2 = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+            const optionsMatch = this.matchRoute(url2.pathname, "OPTIONS", hostname2);
+            if (!optionsMatch) {
+              return new Response(null, {
+                status: 204,
+                headers: {
+                  "Access-Control-Allow-Origin": "*",
+                  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+                  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin",
+                  "Access-Control-Max-Age": "86400",
+                  "Access-Control-Allow-Credentials": "true"
+                }
+              });
+            }
+          }
+          const hostname = url2.hostname || req.headers.get("host")?.split(":")[0] || "localhost";
+          const match = this.matchRoute(url2.pathname, req.method, hostname);
+          const enhancedReq = this.enhanceRequest(req, match?.params || {});
+          setCurrentRequest(enhancedReq);
+          if (match) {
+            enhancedReq.route = match.route;
+            const middlewareStack = [...this.globalMiddleware];
+            if (match.route.middleware && match.route.middleware.length > 0) {
+              middlewareStack.push(...match.route.middleware);
+            }
+            const routeHandlerMiddleware = async (req2, _next) => {
+              return await this.resolveHandler(match.route.handler, req2);
+            };
+            middlewareStack.push(routeHandlerMiddleware);
+            const response2 = await this.runMiddleware(enhancedReq, middlewareStack);
+            if (response2) {
+              return this.applyModifiedCookies(response2, enhancedReq);
+            }
+            return new Response("No response from middleware chain", { status: 500 });
+          }
+          const allowedMethods = this.getAllowedMethods(url2.pathname, hostname);
+          const corsHeaders = {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
+          };
+          if (allowedMethods.length > 0) {
+            const methodNotAllowedHandler = async (_req, _next) => {
+              return new Response(JSON.stringify({
+                success: false,
+                message: "Method Not Allowed",
+                path: url2.pathname,
+                method: req.method,
+                allowed: allowedMethods
+              }), {
+                status: 405,
+                headers: { ...corsHeaders, Allow: allowedMethods.join(", ") }
+              });
+            };
+            if (this.globalMiddleware.length > 0) {
+              const stack = [...this.globalMiddleware, methodNotAllowedHandler];
+              const response2 = await this.runMiddleware(enhancedReq, stack);
+              if (response2)
+                return this.applyModifiedCookies(response2, enhancedReq);
+            }
+            return await methodNotAllowedHandler(enhancedReq, async () => null);
+          }
+          if (this.fallbackHandler) {
+            const response2 = await this.resolveHandler(this.fallbackHandler, enhancedReq);
+            return this.applyModifiedCookies(response2, enhancedReq);
+          }
+          const notFoundHandler = async (_req, _next) => {
+            return new Response(JSON.stringify({
+              success: false,
+              message: "Not Found",
+              path: url2.pathname,
+              method: req.method
+            }), { status: 404, headers: corsHeaders });
+          };
+          if (this.globalMiddleware.length > 0) {
+            const stack = [...this.globalMiddleware, notFoundHandler];
+            const response2 = await this.runMiddleware(enhancedReq, stack);
+            if (response2)
+              return this.applyModifiedCookies(response2, enhancedReq);
+          }
+          return await notFoundHandler(enhancedReq, async () => null);
+        } catch (error) {
+          console.error("Error handling request:", error);
+          if (this.errorHandler) {
+            return this.errorHandler(error);
+          }
+          return new Response(JSON.stringify({
+            success: false,
+            message: "Internal Server Error",
+            error: error instanceof Error ? error.message : String(error)
+          }), {
+            status: 500,
+            headers: {
+              "Content-Type": "application/json",
+              "Access-Control-Allow-Origin": "*",
+              "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+              "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With, Accept, Origin"
+            }
+          });
+        }
+      },
+      writable: true,
+      configurable: true
+    },
+    enhanceRequest: {
+      value(req, params = {}) {
+        let parsedCookies = null;
+        const getCookies = () => {
+          if (parsedCookies === null) {
+            parsedCookies = {};
+            const cookieHeader = req.headers.get("cookie") || "";
+            cookieHeader.split(";").forEach((cookie) => {
+              const parts = cookie.trim().split("=");
+              if (parts.length >= 2) {
+                const name = parts[0].trim();
+                const value = parts.slice(1).join("=").trim();
+                parsedCookies[name] = decodeURIComponent(value);
+              }
+            });
+          }
+          return parsedCookies;
+        };
+        const cookies = {
+          get: (name) => getCookies()[name],
+          set: (name, value, options = {}) => {
+            const enhancedRequest = req;
+            if (!enhancedRequest._cookiesToSet) {
+              enhancedRequest._cookiesToSet = [];
+            }
+            enhancedRequest._cookiesToSet.push({ name, value, options });
+          },
+          delete: (name, options = {}) => {
+            const enhancedRequest = req;
+            if (!enhancedRequest._cookiesToDelete) {
+              enhancedRequest._cookiesToDelete = [];
+            }
+            enhancedRequest._cookiesToDelete.push({ name, options });
+          },
+          getAll: () => ({ ...getCookies() })
+        };
+        const enhancedReq = Object.assign(req, {
+          params,
+          cookies: getCookies(),
+          _cookiesToSet: [],
+          _cookiesToDelete: []
+        });
+        RequestWithMacros.applyMacros(enhancedReq);
+        Object.assign(enhancedReq, { cookies: { ...getCookies(), ...cookies } });
+        return enhancedReq;
+      },
+      writable: true,
+      configurable: true
+    },
+    applyModifiedCookies: {
+      value(response2, req) {
+        const newResponse = new Response(response2.body, {
+          status: response2.status,
+          statusText: response2.statusText,
+          headers: response2.headers
+        });
+        if (req._cookiesToSet && req._cookiesToSet.length > 0) {
+          for (const { name, value, options } of req._cookiesToSet) {
+            const cookieString = this.serializeCookie(name, value, options);
+            newResponse.headers.append("Set-Cookie", cookieString);
+          }
+        }
+        if (req._cookiesToDelete && req._cookiesToDelete.length > 0) {
+          for (const { name, options } of req._cookiesToDelete) {
+            const deletionOptions = {
+              ...options,
+              expires: new Date(0),
+              maxAge: 0
+            };
+            const cookieString = this.serializeCookie(name, "", deletionOptions);
+            newResponse.headers.append("Set-Cookie", cookieString);
+          }
+        }
+        return newResponse;
+      },
+      writable: true,
+      configurable: true
+    },
+    serializeCookie: {
+      value(name, value, options = {}) {
+        let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+        if (options.maxAge !== undefined) {
+          cookie += `; Max-Age=${options.maxAge}`;
+        }
+        if (options.expires && options.expires instanceof Date) {
+          cookie += `; Expires=${options.expires.toUTCString()}`;
+        }
+        if (options.path) {
+          cookie += `; Path=${options.path}`;
+        } else {
+          cookie += "; Path=/";
+        }
+        if (options.domain) {
+          cookie += `; Domain=${options.domain}`;
+        }
+        if (options.secure) {
+          cookie += "; Secure";
+        }
+        if (options.httpOnly) {
+          cookie += "; HttpOnly";
+        }
+        if (options.sameSite) {
+          const sameSite = options.sameSite.toLowerCase();
+          cookie += `; SameSite=${sameSite.charAt(0).toUpperCase() + sameSite.slice(1)}`;
+        }
+        return cookie;
+      },
+      writable: true,
+      configurable: true
     }
-    return Math.abs(hash).toString(36);
-  },
-  merge(data) {
-    if (!this.validated) {
-      this.validated = {};
+  });
+}
+
+// src/router/view-rendering.ts
+import { join as join4 } from "path";
+function registerViewRendering(RouterClass) {
+  Object.defineProperties(RouterClass.prototype, {
+    renderView: {
+      async value(view, data = {}, options = {}) {
+        const viewsConfig = this.config.views || {
+          viewsPath: "resources/views",
+          extensions: [".html", ".stx"],
+          cache: Bun.env.NODE_ENV === "production",
+          engine: "auto"
+        };
+        const cacheKey = `${view}:${options.layout || ""}`;
+        if (viewsConfig.cache && this.templateCache.has(cacheKey)) {
+          return this.processTemplate(this.templateCache.get(cacheKey), data, viewsConfig);
+        }
+        const viewPath = await resolveViewPath(view, viewsConfig.viewsPath, viewsConfig.extensions);
+        if (!viewPath) {
+          throw new Error(`View '${view}' not found`);
+        }
+        let viewContent = await Bun.file(viewPath).text();
+        const layoutName = options.layout || viewsConfig.defaultLayout;
+        if (layoutName) {
+          const layoutPath = await resolveViewPath(join4("layouts", layoutName), viewsConfig.viewsPath, viewsConfig.extensions);
+          if (!layoutPath) {
+            throw new Error(`Layout '${layoutName}' not found`);
+          }
+          const layoutContent = await Bun.file(layoutPath).text();
+          viewContent = layoutContent.replace(/\{\{\s*content\s*\}\}/g, viewContent);
+        }
+        if (viewsConfig.cache) {
+          this.templateCache.set(cacheKey, viewContent);
+        }
+        return this.processTemplate(viewContent, data, viewsConfig);
+      },
+      writable: true,
+      configurable: true
+    },
+    processTemplate: {
+      async value(template, data, viewConfig) {
+        const engine = viewConfig?.engine || "auto";
+        if (engine === "custom" && viewConfig?.customRenderer) {
+          return viewConfig.customRenderer(template, data, {});
+        }
+        let processedTemplate = processHtmlTemplate(template, data);
+        if (viewConfig?.minify?.enabled) {
+          try {
+            const _minifyOptions = viewConfig.minify.options || {
+              removeComments: true,
+              collapseWhitespace: true,
+              minifyJS: true,
+              minifyCSS: true
+            };
+            processedTemplate = processedTemplate.replace(/\s+/g, " ").replace(/<!--[\s\S]*?-->/g, "");
+          } catch (err) {
+            console.error("Error minifying HTML:", err);
+          }
+        }
+        return processedTemplate;
+      },
+      writable: true,
+      configurable: true
+    },
+    view: {
+      value(path, viewOrData, dataOrOptions = {}, optionsOrType = {}, typeOrName = "web", name) {
+        let view;
+        let data = {};
+        let options = {};
+        let type = "web";
+        let routeName;
+        if (typeof viewOrData === "string") {
+          view = viewOrData;
+          if (typeof dataOrOptions === "object" && !Array.isArray(dataOrOptions)) {
+            if ("layout" in dataOrOptions || "status" in dataOrOptions || "headers" in dataOrOptions) {
+              options = dataOrOptions;
+            } else {
+              data = dataOrOptions;
+            }
+          }
+          if (typeof optionsOrType === "object") {
+            options = { ...options, ...optionsOrType };
+          } else if (typeof optionsOrType === "string") {
+            type = optionsOrType;
+          }
+          if (typeof typeOrName === "string") {
+            if (typeOrName === "web" || typeOrName === "api") {
+              type = typeOrName;
+            } else {
+              routeName = typeOrName;
+            }
+          }
+          if (name) {
+            routeName = name;
+          }
+        } else {
+          data = viewOrData;
+          if (typeof dataOrOptions === "string") {
+            view = dataOrOptions;
+          } else {
+            throw new TypeError("View name must be a string");
+          }
+          if (typeof optionsOrType === "object") {
+            options = optionsOrType;
+          } else if (typeof optionsOrType === "string") {
+            if (optionsOrType === "web" || optionsOrType === "api") {
+              type = optionsOrType;
+            } else {
+              view = optionsOrType;
+              type = "web";
+            }
+          }
+        }
+        const handler = async (_req) => {
+          let renderedView = await this.renderView(view, data, {
+            layout: options.layout
+          });
+          const queryPreservationConfig = this.config?.queryPreservation;
+          if (queryPreservationConfig?.enabled !== false && queryPreservationConfig?.preserve?.length) {
+            renderedView = injectQueryPreservationScript(renderedView, queryPreservationConfig);
+          }
+          const headers = new Headers;
+          headers.set("Content-Type", "text/html; charset=utf-8");
+          if (options.headers) {
+            for (const [key, value] of Object.entries(options.headers)) {
+              headers.set(key, value);
+            }
+          }
+          return new Response(renderedView, {
+            status: options.status || 200,
+            headers
+          });
+        };
+        this.get(path, handler, type, routeName);
+        return this;
+      },
+      writable: true,
+      configurable: true
     }
-    Object.assign(this.validated, data);
-  },
-  replace(data) {
-    this.validated = { ...data };
-  },
-  age() {
-    const startTime = this.startTime || Date.now();
-    return Date.now() - startTime;
-  },
-  isFromTrustedProxy(trustedProxies = []) {
-    const ip = BuiltInRequestMacros.ip.call(this);
-    return trustedProxies.includes(ip);
-  },
-  contentLength() {
-    const length = this.headers.get("content-length");
-    return length ? Number.parseInt(length, 10) : 0;
-  },
-  contentType() {
-    return this.headers.get("content-type");
-  },
-  isContentType(type) {
-    const contentType = this.contentType();
-    return contentType ? contentType.includes(type) : false;
-  }
-};
-function registerBuiltInRequestMacros() {
-  Object.entries(BuiltInRequestMacros).forEach(([name, handler]) => {
-    RequestWithMacros.macro(name, handler);
   });
 }
-registerBuiltInRequestMacros();
 
+// src/router/websocket.ts
+function registerWebSocketHandling(RouterClass) {
+  Object.defineProperties(RouterClass.prototype, {
+    websocket: {
+      value(config2) {
+        this.wsConfig = config2;
+        return this;
+      },
+      writable: true,
+      configurable: true
+    },
+    publish: {
+      value(topic, data, compress = false) {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot publish to WebSocket topics");
+        }
+        return this.serverInstance.publish(topic, data, compress);
+      },
+      writable: true,
+      configurable: true
+    },
+    subscriberCount: {
+      value(topic) {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot get subscriber count");
+        }
+        return this.serverInstance.subscriberCount(topic);
+      },
+      writable: true,
+      configurable: true
+    },
+    upgrade: {
+      value(request2, options) {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot upgrade to WebSocket");
+        }
+        if (!this.wsConfig) {
+          throw new Error("WebSocket configuration not set, use router.websocket() to configure");
+        }
+        return this.serverInstance.upgrade(request2, options);
+      },
+      writable: true,
+      configurable: true
+    },
+    timeout: {
+      value(request2, seconds) {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot set timeout");
+        }
+        this.serverInstance.timeout(request2, seconds);
+      },
+      writable: true,
+      configurable: true
+    },
+    requestIP: {
+      value(request2) {
+        if (!this.serverInstance) {
+          throw new Error("Server not started, cannot get request IP");
+        }
+        return this.serverInstance.requestIP(request2);
+      },
+      writable: true,
+      configurable: true
+    }
+  });
+}
 // src/response/macros.ts
 import process4 from "process";