cpeak 2.7.0 → 2.9.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // lib/index.ts
 import http from "http";
-import fs3 from "fs/promises";
-import { createReadStream } from "fs";
-import { pipeline as pipeline2 } from "stream/promises";
+import fs2 from "fs/promises";
+import { createReadStream as createReadStream2 } from "fs";
+import { pipeline as pipeline3 } from "stream/promises";
 
-// lib/utils/compression.ts
+// lib/internal/compression.ts
 import zlib from "zlib";
 import { Readable } from "stream";
 import { Buffer as Buffer2 } from "buffer";
@@ -114,6 +114,226 @@ async function compressAndSend(res, mime, body, config, size) {
   );
 }
 
+// lib/internal/mimeTypes.ts
+var MIME_TYPES = {
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  eot: "application/vnd.ms-fontobject",
+  otf: "font/otf",
+  ttf: "font/ttf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  json: "application/json",
+  map: "application/json",
+  webmanifest: "application/manifest+json",
+  xml: "application/xml",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  webp: "image/webp",
+  avif: "image/avif"
+};
+
+// lib/internal/errors.ts
+function frameworkError(message, skipFn, code, status, clientDisconnect) {
+  const err = new Error(message);
+  Error.captureStackTrace(err, skipFn);
+  err.cpeak_err = true;
+  if (code) err.code = code;
+  if (status) err.status = status;
+  if (clientDisconnect) err.clientDisconnect = true;
+  return err;
+}
+var CLIENT_DISCONNECT_CODES = /* @__PURE__ */ new Set([
+  "ERR_STREAM_PREMATURE_CLOSE",
+  "ERR_STREAM_DESTROYED",
+  "ECONNRESET",
+  "EPIPE"
+]);
+function isClientDisconnect(err) {
+  return CLIENT_DISCONNECT_CODES.has(err?.code);
+}
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["MISSING_MIME"] = "CPEAK_ERR_MISSING_MIME";
+  ErrorCode2["FILE_NOT_FOUND"] = "CPEAK_ERR_FILE_NOT_FOUND";
+  ErrorCode2["NOT_A_FILE"] = "CPEAK_ERR_NOT_A_FILE";
+  ErrorCode2["SEND_FILE_FAIL"] = "CPEAK_ERR_SEND_FILE_FAIL";
+  ErrorCode2["INVALID_JSON"] = "CPEAK_ERR_INVALID_JSON";
+  ErrorCode2["PAYLOAD_TOO_LARGE"] = "CPEAK_ERR_PAYLOAD_TOO_LARGE";
+  ErrorCode2["WEAK_SECRET"] = "CPEAK_ERR_WEAK_SECRET";
+  ErrorCode2["COMPRESSION_NOT_ENABLED"] = "CPEAK_ERR_COMPRESSION_NOT_ENABLED";
+  ErrorCode2["RENDER_NOT_ENABLED"] = "CPEAK_ERR_RENDER_NOT_ENABLED";
+  ErrorCode2["DUPLICATE_ROUTE"] = "CPEAK_ERR_DUPLICATE_ROUTE";
+  ErrorCode2["INVALID_ROUTE"] = "CPEAK_ERR_INVALID_ROUTE";
+  ErrorCode2["DUPLICATE_FALLBACK"] = "CPEAK_ERR_DUPLICATE_FALLBACK";
+  ErrorCode2["RENDER_FAIL"] = "CPEAK_ERR_RENDER_FAIL";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// lib/internal/router.ts
+function createNode() {
+  return { staticChildren: /* @__PURE__ */ new Map() };
+}
+var Router = class {
+  #treesByMethod = /* @__PURE__ */ new Map();
+  add(method, path3, middleware, handler) {
+    const methodKey = method.toLowerCase();
+    let root = this.#treesByMethod.get(methodKey);
+    if (!root) {
+      root = createNode();
+      this.#treesByMethod.set(methodKey, root);
+    }
+    const segments = splitPath(path3);
+    const paramNames = [];
+    let currentNode = root;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const isLastSegment = i === segments.length - 1;
+      if (segment.length > 1 && segment.startsWith("*")) {
+        throw frameworkError(
+          `Invalid route "${path3}": named wildcards (e.g. "*name") are not supported. Use a plain "*" at the end of the path.`,
+          this.add,
+          "CPEAK_ERR_INVALID_ROUTE" /* INVALID_ROUTE */
+        );
+      }
+      if (segment === "*") {
+        if (!isLastSegment) {
+          throw frameworkError(
+            `Invalid route "${path3}": "*" is only allowed as the final path segment.`,
+            this.add,
+            "CPEAK_ERR_INVALID_ROUTE" /* INVALID_ROUTE */
+          );
+        }
+        if (currentNode.wildcardChild) {
+          throw frameworkError(
+            `Duplicate route: ${method.toUpperCase()} ${path3}`,
+            this.add,
+            "CPEAK_ERR_DUPLICATE_ROUTE" /* DUPLICATE_ROUTE */
+          );
+        }
+        currentNode.wildcardChild = { handler, middleware, paramNames };
+        return;
+      }
+      if (segment.startsWith(":")) {
+        const paramName = segment.slice(1);
+        if (!paramName) {
+          throw frameworkError(
+            `Invalid route "${path3}": empty parameter name.`,
+            this.add,
+            "CPEAK_ERR_INVALID_ROUTE" /* INVALID_ROUTE */
+          );
+        }
+        paramNames.push(paramName);
+        if (!currentNode.paramChild) {
+          currentNode.paramChild = createNode();
+        }
+        currentNode = currentNode.paramChild;
+        continue;
+      }
+      let staticChild = currentNode.staticChildren.get(segment);
+      if (!staticChild) {
+        staticChild = createNode();
+        currentNode.staticChildren.set(segment, staticChild);
+      }
+      currentNode = staticChild;
+    }
+    if (currentNode.handler) {
+      throw frameworkError(
+        `Duplicate route: ${method.toUpperCase()} ${path3}`,
+        this.add,
+        "CPEAK_ERR_DUPLICATE_ROUTE" /* DUPLICATE_ROUTE */
+      );
+    }
+    currentNode.handler = handler;
+    currentNode.middleware = middleware;
+    currentNode.paramNames = paramNames;
+  }
+  find(method, path3) {
+    const root = this.#treesByMethod.get(method.toLowerCase());
+    if (!root) return null;
+    const segments = splitPath(path3);
+    return matchSegments(root, segments, 0, []);
+  }
+};
+function matchSegments(node, segments, segmentIndex, capturedValues) {
+  if (segmentIndex === segments.length) {
+    if (node.handler) {
+      return {
+        middleware: node.middleware,
+        handler: node.handler,
+        params: zipParams(node.paramNames, capturedValues)
+      };
+    }
+    if (node.wildcardChild) {
+      return {
+        middleware: node.wildcardChild.middleware,
+        handler: node.wildcardChild.handler,
+        params: zipParams(node.wildcardChild.paramNames, capturedValues)
+      };
+    }
+    return null;
+  }
+  const segment = segments[segmentIndex];
+  const staticChild = node.staticChildren.get(segment);
+  if (staticChild) {
+    const foundMatch = matchSegments(
+      staticChild,
+      segments,
+      segmentIndex + 1,
+      capturedValues
+    );
+    if (foundMatch) return foundMatch;
+  }
+  if (node.paramChild) {
+    capturedValues.push(safeDecode(segment));
+    const foundMatch = matchSegments(
+      node.paramChild,
+      segments,
+      segmentIndex + 1,
+      capturedValues
+    );
+    if (foundMatch) return foundMatch;
+    capturedValues.pop();
+  }
+  if (node.wildcardChild) {
+    return {
+      middleware: node.wildcardChild.middleware,
+      handler: node.wildcardChild.handler,
+      params: zipParams(node.wildcardChild.paramNames, capturedValues)
+    };
+  }
+  return null;
+}
+function zipParams(names, values) {
+  const params = {};
+  for (let i = 0; i < names.length; i++) {
+    params[names[i]] = values[i];
+  }
+  return params;
+}
+function safeDecode(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function splitPath(path3) {
+  if (path3 === "" || path3 === "/") return [];
+  const withoutLeadingSlash = path3.startsWith("/") ? path3.slice(1) : path3;
+  return withoutLeadingSlash.split("/");
+}
+
 // lib/utils/parseJSON.ts
 import { Buffer as Buffer3 } from "buffer";
 function isJSON(contentType) {
@@ -171,39 +391,40 @@ var parseJSON = (options = {}) => {
 // lib/utils/serveStatic.ts
 import fs from "fs";
 import path from "path";
-var MIME_TYPES = {
-  html: "text/html",
-  css: "text/css",
-  js: "application/javascript",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  svg: "image/svg+xml",
-  txt: "text/plain",
-  eot: "application/vnd.ms-fontobject",
-  otf: "font/otf",
-  ttf: "font/ttf",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  gif: "image/gif",
-  ico: "image/x-icon",
-  json: "application/json",
-  webmanifest: "application/manifest+json"
-};
-var serveStatic = (folderPath, newMimeTypes, options) => {
-  if (newMimeTypes) {
-    Object.assign(MIME_TYPES, newMimeTypes);
-  }
+var serveStatic = (folderPath, options) => {
   const prefix = options?.prefix ?? "";
+  const live = options?.live ?? false;
+  if (live) {
+    const resolvedFolder2 = path.resolve(folderPath);
+    const excludes2 = (options?.exclude ?? []).map((e) => path.join(resolvedFolder2, e));
+    return async function(req, res, next) {
+      const url = req.url;
+      if (typeof url !== "string") return next();
+      const pathname = url.split("?")[0];
+      const unprefixed = prefix ? pathname.slice(prefix.length) : pathname;
+      const filePath = path.join(resolvedFolder2, unprefixed);
+      const fileExtension = path.extname(filePath).slice(1);
+      const mime = MIME_TYPES[fileExtension];
+      if (!mime || !filePath.startsWith(resolvedFolder2)) return next();
+      if (excludes2.some((e) => filePath.startsWith(e))) return next();
+      const stat = await fs.promises.stat(filePath).catch(() => null);
+      if (stat?.isFile()) return res.sendFile(filePath, mime);
+      next();
+    };
+  }
+  const resolvedFolder = path.resolve(folderPath);
+  const excludes = (options?.exclude ?? []).map((e) => path.join(resolvedFolder, e));
   function processFolder(folderPath2, parentFolder) {
     const staticFiles = [];
     const files = fs.readdirSync(folderPath2);
     for (const file of files) {
       const fullPath = path.join(folderPath2, file);
       if (fs.statSync(fullPath).isDirectory()) {
+        if (excludes.some((e) => fullPath.startsWith(e))) continue;
         const subfolderFiles = processFolder(fullPath, parentFolder);
         staticFiles.push(...subfolderFiles);
       } else {
+        if (excludes.some((e) => fullPath.startsWith(e))) continue;
         const relativePath = path.relative(parentFolder, fullPath);
         const fileExtension = path.extname(file).slice(1);
         if (MIME_TYPES[fileExtension]) staticFiles.push("/" + relativePath);
@@ -236,47 +457,126 @@ var serveStatic = (folderPath, newMimeTypes, options) => {
 };
 
 // lib/utils/render.ts
-import fs2 from "fs/promises";
-function renderTemplate(templateStr, data) {
-  let result = [];
-  let currentIndex = 0;
-  while (currentIndex < templateStr.length) {
-    const startIdx = templateStr.indexOf("{{", currentIndex);
-    if (startIdx === -1) {
-      result.push(templateStr.slice(currentIndex));
-      break;
+import path2 from "path";
+import { createReadStream } from "fs";
+import { readFile } from "fs/promises";
+import { Transform } from "stream";
+import { pipeline as pipeline2 } from "stream/promises";
+var MAX_PATTERN = 128;
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var TemplateTransform = class _TemplateTransform extends Transform {
+  constructor(data, baseDir) {
+    super();
+    this.data = data;
+    this.baseDir = baseDir;
+  }
+  tail = "";
+  _transform(chunk, _, callback) {
+    const str = this.tail + chunk.toString("utf8");
+    if (str.length <= MAX_PATTERN) {
+      this.tail = str;
+      callback();
+      return;
     }
-    result.push(templateStr.slice(currentIndex, startIdx));
-    const endIdx = templateStr.indexOf("}}", startIdx);
-    if (endIdx === -1) {
-      result.push(templateStr.slice(startIdx));
-      break;
+    let boundary = str.length - MAX_PATTERN;
+    for (const [opener, closer] of [
+      ["{{", "}}"],
+      ["<cpeak", ">"]
+    ]) {
+      const last = str.lastIndexOf(opener, boundary - 1);
+      if (last === -1) continue;
+      const closeIdx = str.indexOf(closer, last + opener.length);
+      if (closeIdx === -1 || closeIdx >= boundary)
+        boundary = Math.min(boundary, last);
     }
-    const varName = templateStr.slice(startIdx + 2, endIdx).trim();
-    const replacement = data[varName] !== void 0 ? data[varName] : "";
-    result.push(replacement);
-    currentIndex = endIdx + 2;
+    this.tail = str.slice(boundary);
+    const safe = str.slice(0, boundary);
+    if (safe)
+      this.process(safe).then(() => callback()).catch(callback);
+    else callback();
   }
-  return result.join("");
-}
+  _flush(callback) {
+    if (this.tail)
+      this.process(this.tail).then(() => callback()).catch(callback);
+    else callback();
+  }
+  async process(str) {
+    const RE = /<cpeak\s+include="([^"]+)"\s*\/?>|<cpeak\s+html=\{([^}]+)\}\s*\/?>|\{\{([^}]+)\}\}/g;
+    let last = 0;
+    for (const match of str.matchAll(RE)) {
+      const idx = match.index;
+      if (idx > last) this.push(str.slice(last, idx));
+      const [, includeSrc, rawKey, escapedKey] = match;
+      if (includeSrc !== void 0) {
+        const includePath = path2.resolve(this.baseDir, includeSrc);
+        const content = await readFile(includePath, "utf8");
+        const chunks = [];
+        const nested = new _TemplateTransform(
+          this.data,
+          path2.dirname(includePath)
+        );
+        await new Promise((resolve, reject) => {
+          nested.on("data", (c) => chunks.push(c));
+          nested.on("end", resolve);
+          nested.on("error", reject);
+          nested.end(Buffer.from(content, "utf8"));
+        });
+        this.push(Buffer.concat(chunks));
+      } else if (rawKey !== void 0) {
+        const val = this.data[rawKey.trim()];
+        if (val !== void 0) this.push(String(val));
+      } else {
+        const val = this.data[escapedKey.trim()];
+        if (val !== void 0) this.push(escapeHtml(String(val)));
+      }
+      last = idx + match[0].length;
+    }
+    if (last < str.length) this.push(str.slice(last));
+  }
+};
 var render = () => {
   return function(req, res, next) {
-    res.render = async (path2, data, mime) => {
+    res.render = async (filePath, data, mime) => {
+      if (res.headersSent) return;
       if (!mime) {
+        const dotIndex = filePath.lastIndexOf(".");
+        const fileExtension = dotIndex >= 0 ? filePath.slice(dotIndex + 1) : "";
+        mime = MIME_TYPES[fileExtension];
+        if (!mime) {
+          throw frameworkError(
+            `MIME type is missing for "${filePath}". Pass it as the third argument or register the extension via cpeak({ mimeTypes: { ${fileExtension || "ext"}: "..." } }).`,
+            res.render,
+            "CPEAK_ERR_MISSING_MIME" /* MISSING_MIME */
+          );
+        }
+      }
+      const resolved = path2.resolve(filePath);
+      try {
+        if (res._compression) {
+          const readStream = createReadStream(resolved);
+          const transform = new TemplateTransform(data, path2.dirname(resolved));
+          pipeline2(readStream, transform).catch(() => {
+          });
+          await compressAndSend(res, mime, transform, res._compression);
+          return;
+        }
+        res.setHeader("Content-Type", mime);
+        await pipeline2(
+          createReadStream(resolved),
+          new TemplateTransform(data, path2.dirname(resolved)),
+          res
+        );
+      } catch (err) {
         throw frameworkError(
-          `MIME type is missing. You called res.render("${path2}", ...) but forgot to provide the third "mime" argument.`,
-          res.render
+          `Failed to render "${filePath}." Error: ${err}`,
+          res.render,
+          "CPEAK_ERR_RENDER_FAIL" /* RENDER_FAIL */,
+          void 0,
+          isClientDisconnect(err)
         );
       }
-      let fileStr = await fs2.readFile(path2, "utf-8");
-      const finalStr = renderTemplate(fileStr, data);
-      const config = res.socket?.server?._cpeakCompression;
-      if (config) {
-        await compressAndSend(res, mime, finalStr, config);
-        return;
-      }
-      res.setHeader("Content-Type", mime);
-      res.end(finalStr);
     };
     next();
   };
@@ -468,8 +768,8 @@ function parseRawCookies(header) {
 }
 function buildSetCookieHeader(name, value, options) {
   const parts = [`${name}=${encodeURIComponent(value)}`];
-  const path2 = options.path ?? "/";
-  parts.push(`Path=${path2}`);
+  const path3 = options.path ?? "/";
+  parts.push(`Path=${path3}`);
   if (options.domain) parts.push(`Domain=${options.domain}`);
   if (options.maxAge !== void 0)
     parts.push(`Max-Age=${Math.floor(options.maxAge / 1e3)}`);
@@ -603,28 +903,6 @@ var cors = (options = {}) => {
 };
 
 // lib/index.ts
-function frameworkError(message, skipFn, code, status) {
-  const err = new Error(message);
-  Error.captureStackTrace(err, skipFn);
-  err.cpeak_err = true;
-  if (code) err.code = code;
-  if (status) err.status = status;
-  return err;
-}
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2["MISSING_MIME"] = "CPEAK_ERR_MISSING_MIME";
-  ErrorCode2["FILE_NOT_FOUND"] = "CPEAK_ERR_FILE_NOT_FOUND";
-  ErrorCode2["NOT_A_FILE"] = "CPEAK_ERR_NOT_A_FILE";
-  ErrorCode2["SEND_FILE_FAIL"] = "CPEAK_ERR_SEND_FILE_FAIL";
-  ErrorCode2["INVALID_JSON"] = "CPEAK_ERR_INVALID_JSON";
-  ErrorCode2["PAYLOAD_TOO_LARGE"] = "CPEAK_ERR_PAYLOAD_TOO_LARGE";
-  ErrorCode2["WEAK_SECRET"] = "CPEAK_ERR_WEAK_SECRET";
-  ErrorCode2["COMPRESSION_NOT_ENABLED"] = "CPEAK_ERR_COMPRESSION_NOT_ENABLED";
-  return ErrorCode2;
-})(ErrorCode || {});
-function compressionConfigFor(res) {
-  return res.socket?.server?._cpeakCompression;
-}
 var CpeakIncomingMessage = class extends http.IncomingMessage {
   // We define body and params here for better V8 optimization (not changing the shape of the object at runtime)
   body = void 0;
@@ -647,44 +925,59 @@ var CpeakIncomingMessage = class extends http.IncomingMessage {
   }
 };
 var CpeakServerResponse = class extends http.ServerResponse {
+  // Set per-request from the Cpeak instance. Undefined when compression isn't enabled.
+  _compression;
   // Send a file back to the client
-  async sendFile(path2, mime) {
+  async sendFile(path3, mime) {
+    if (this.headersSent) return;
     if (!mime) {
-      throw frameworkError(
-        'MIME type is missing. Use res.sendFile(path, "mime-type").',
-        this.sendFile,
-        "CPEAK_ERR_MISSING_MIME" /* MISSING_MIME */
-      );
+      const dotIndex = path3.lastIndexOf(".");
+      const fileExtension = dotIndex >= 0 ? path3.slice(dotIndex + 1) : "";
+      mime = MIME_TYPES[fileExtension];
+      if (!mime) {
+        throw frameworkError(
+          `MIME type is missing for "${path3}". Pass it as the second argument or register the extension via cpeak({ mimeTypes: { ${fileExtension || "ext"}: "..." } }).`,
+          this.sendFile,
+          "CPEAK_ERR_MISSING_MIME" /* MISSING_MIME */
+        );
+      }
     }
     try {
-      const stat = await fs3.stat(path2);
+      const stat = await fs2.stat(path3);
       if (!stat.isFile()) {
         throw frameworkError(
-          `Not a file: ${path2}`,
+          `Not a file: ${path3}`,
           this.sendFile,
           "CPEAK_ERR_NOT_A_FILE" /* NOT_A_FILE */
         );
       }
-      const config = compressionConfigFor(this);
-      if (config) {
-        await compressAndSend(this, mime, createReadStream(path2), config, stat.size);
+      if (this._compression) {
+        await compressAndSend(
+          this,
+          mime,
+          createReadStream2(path3),
+          this._compression,
+          stat.size
+        );
         return;
       }
       this.setHeader("Content-Type", mime);
       this.setHeader("Content-Length", String(stat.size));
-      await pipeline2(createReadStream(path2), this);
+      await pipeline3(createReadStream2(path3), this);
     } catch (err) {
       if (err?.code === "ENOENT") {
         throw frameworkError(
-          `File not found: ${path2}`,
+          `File not found: ${path3}`,
           this.sendFile,
           "CPEAK_ERR_FILE_NOT_FOUND" /* FILE_NOT_FOUND */
         );
       }
       throw frameworkError(
-        `Failed to send file: ${path2}`,
+        `Failed to send file: ${path3}`,
         this.sendFile,
-        "CPEAK_ERR_SEND_FILE_FAIL" /* SEND_FILE_FAIL */
+        "CPEAK_ERR_SEND_FILE_FAIL" /* SEND_FILE_FAIL */,
+        void 0,
+        isClientDisconnect(err)
       );
     }
   }
@@ -704,84 +997,104 @@ var CpeakServerResponse = class extends http.ServerResponse {
     this.writeHead(302, { Location: location });
     this.end();
   }
-  // Send a json data back to the client. Sync hot path when compression is
-  // off — no Promise allocation, no microtask. Branches into compressAndSend
-  // (async) when compression was enabled at cpeak() construction.
+  // Send a json data back to the client.
+  // This is only good for bodies that their size is less than the highWaterMark value.
   json(data) {
+    if (this.headersSent) return Promise.resolve();
     const body = JSON.stringify(data);
-    const config = compressionConfigFor(this);
-    if (config) {
-      return compressAndSend(this, "application/json", body, config);
+    if (this._compression) {
+      return compressAndSend(this, "application/json", body, this._compression);
     }
     this.setHeader("Content-Type", "application/json");
     this.end(body);
+    return Promise.resolve();
   }
-  // Explicit compression entry point. Throws if compression wasn't configured —
-  // the developer asked to compress but the framework was never told to.
+  render() {
+    throw frameworkError(
+      "render middleware not registered. Add render() via app.beforeEach(render()) to use res.render.",
+      this.render,
+      "CPEAK_ERR_RENDER_NOT_ENABLED" /* RENDER_NOT_ENABLED */
+    );
+  }
+  // Explicit compression entry point. A developer can use this in any custom handler to compress arbitrary responses
   compress(mime, body, size) {
-    const config = compressionConfigFor(this);
-    if (!config) {
+    if (this.headersSent) return Promise.resolve();
+    if (!this._compression) {
       throw frameworkError(
         "compression is not enabled. Pass `compression` to cpeak({ compression: true | { ... } }) to use res.compress.",
         this.compress,
         "CPEAK_ERR_COMPRESSION_NOT_ENABLED" /* COMPRESSION_NOT_ENABLED */
       );
     }
-    return compressAndSend(this, mime, body, config, size);
+    return compressAndSend(this, mime, body, this._compression, size);
   }
 };
 var Cpeak = class {
   #server;
-  #routes;
+  #router;
   #middleware;
   #handleErr;
+  #fallback;
+  #compression;
   constructor(options = {}) {
     this.#server = http.createServer({
       IncomingMessage: CpeakIncomingMessage,
       ServerResponse: CpeakServerResponse
     });
-    this.#routes = {};
+    this.#router = new Router();
     this.#middleware = [];
     if (options.compression) {
-      this.#server._cpeakCompression = resolveCompressionOptions(
-        options.compression
-      );
+      this.#compression = resolveCompressionOptions(options.compression);
     }
+    if (options.mimeTypes) Object.assign(MIME_TYPES, options.mimeTypes);
     this.#server.on(
       "request",
       async (req, res) => {
+        res._compression = this.#compression;
         const qIndex = req.url?.indexOf("?");
         const urlWithoutQueries = qIndex === -1 ? req.url || "" : req.url?.substring(0, qIndex);
-        const dispatchError = (error) => {
+        const dispatchError = async (error) => {
           if (res.headersSent) {
             req.socket?.destroy();
-            return;
+          } else {
+            res.setHeader("Connection", "close");
+          }
+          if (isClientDisconnect(error) && !error.clientDisconnect) {
+            error.clientDisconnect = true;
+          }
+          try {
+            await this.#handleErr?.(error, req, res);
+          } catch (handlerFailure) {
+            console.error(
+              "[cpeak] handleErr failed while processing:",
+              error,
+              "\nReason:",
+              handlerFailure
+            );
+            if (!res.headersSent) {
+              try {
+                res.statusCode = 500;
+                res.end();
+              } catch {
+              }
+            }
           }
-          res.setHeader("Connection", "close");
-          this.#handleErr?.(error, req, res);
         };
         const runHandler = async (req2, res2, middleware, cb, index) => {
           if (index === middleware.length) {
             try {
-              await cb(req2, res2, dispatchError);
+              await cb(req2, res2);
             } catch (error) {
               dispatchError(error);
             }
           } else {
             try {
-              await middleware[index](
-                req2,
-                res2,
-                // The next function
-                async (error) => {
-                  if (error) {
-                    return dispatchError(error);
-                  }
-                  await runHandler(req2, res2, middleware, cb, index + 1);
-                },
-                // Error handler for a route middleware
-                dispatchError
-              );
+              await middleware[index](req2, res2, async (error) => {
+                if (error) {
+                  return dispatchError(error);
+                }
+                await runHandler(req2, res2, middleware, cb, index + 1);
+              });
             } catch (error) {
               dispatchError(error);
             }
@@ -789,25 +1102,25 @@ var Cpeak = class {
         };
         const runMiddleware = async (req2, res2, middleware, index) => {
           if (index === middleware.length) {
-            const routes = this.#routes[req2.method?.toLowerCase() || ""];
-            if (routes && typeof routes[Symbol.iterator] === "function")
-              for (const route of routes) {
-                const match = urlWithoutQueries?.match(route.regex);
-                if (match) {
-                  const pathVariables = this.#extractPathVariables(
-                    route.path,
-                    match
-                  );
-                  req2.params = pathVariables;
-                  return await runHandler(
-                    req2,
-                    res2,
-                    route.middleware,
-                    route.cb,
-                    0
-                  );
-                }
+            const method = req2.method?.toLowerCase() || "";
+            const found = this.#router.find(method, urlWithoutQueries || "");
+            if (found) {
+              req2.params = found.params;
+              return await runHandler(
+                req2,
+                res2,
+                found.middleware,
+                found.handler,
+                0
+              );
+            }
+            if (this.#fallback) {
+              try {
+                return await this.#fallback(req2, res2);
+              } catch (error) {
+                return dispatchError(error);
               }
+            }
             return res2.status(404).json({ error: `Cannot ${req2.method} ${urlWithoutQueries}` });
           } else {
             try {
@@ -826,15 +1139,13 @@ var Cpeak = class {
       }
     );
   }
-  route(method, path2, ...args) {
-    if (!this.#routes[method]) this.#routes[method] = [];
+  route(method, path3, ...args) {
     const cb = args.pop();
     if (!cb || typeof cb !== "function") {
       throw new Error("Route definition must include a handler");
     }
     const middleware = args.flat();
-    const regex = this.#pathToRegex(path2);
-    this.#routes[method].push({ path: path2, regex, middleware, cb });
+    this.#router.add(method, path3, middleware, cb);
   }
   beforeEach(cb) {
     this.#middleware.push(cb);
@@ -842,31 +1153,29 @@ var Cpeak = class {
   handleErr(cb) {
     this.#handleErr = cb;
   }
-  listen(port, cb) {
-    return this.#server.listen(port, cb);
+  // This will handle any request that doesn't match any of the routes and middleware functions
+  fallback(cb) {
+    if (this.#fallback) {
+      throw frameworkError(
+        "Fallback handler is already registered. Only one fallback can be set per app.",
+        this.fallback,
+        "CPEAK_ERR_DUPLICATE_FALLBACK" /* DUPLICATE_FALLBACK */
+      );
+    }
+    this.#fallback = cb;
+  }
+  listen(...args) {
+    return this.#server.listen(...args);
   }
   address() {
     return this.#server.address();
   }
   close(cb) {
-    this.#server.close(cb);
-  }
-  // ------------------------------
-  // PRIVATE METHODS:
-  // ------------------------------
-  #pathToRegex(path2) {
-    const regexString = "^" + path2.replace(/:\w+/g, "([^/]+)").replace(/\*/g, ".*") + "$";
-    return new RegExp(regexString);
-  }
-  #extractPathVariables(path2, match) {
-    const paramNames = (path2.match(/:\w+/g) || []).map(
-      (param) => param.slice(1)
-    );
-    const params = {};
-    paramNames.forEach((name, index) => {
-      params[name] = match[index + 1];
-    });
-    return params;
+    return this.#server.close(cb);
+  }
+  // A getter for developers who want to access the underlying http server instance for advanced use cases that aren't covered by Cpeak
+  get server() {
+    return this.#server;
   }
 };
 function cpeak(options) {
@@ -883,6 +1192,7 @@ export {
   cpeak as default,
   frameworkError,
   hashPassword,
+  isClientDisconnect,
   parseJSON,
   render,
   serveStatic,