cpeak 2.8.0 → 2.9.0

package/dist/index.d.ts

@@ -4,10 +4,12 @@ import { Readable } from 'node:stream';
 import { Buffer } from 'node:buffer';
 import * as node_zlib from 'node:zlib';
 
-declare function frameworkError(message: string, skipFn: Function, code?: string, status?: number): Error & {
+declare function frameworkError(message: string, skipFn: Function, code?: string, status?: number, clientDisconnect?: boolean): Error & {
     code?: string;
     cpeak_err?: boolean;
+    clientDisconnect?: boolean;
 };
+declare function isClientDisconnect(err: unknown): boolean;
 declare enum ErrorCode {
     MISSING_MIME = "CPEAK_ERR_MISSING_MIME",
     FILE_NOT_FOUND = "CPEAK_ERR_FILE_NOT_FOUND",
@@ -17,8 +19,11 @@ declare enum ErrorCode {
     PAYLOAD_TOO_LARGE = "CPEAK_ERR_PAYLOAD_TOO_LARGE",
     WEAK_SECRET = "CPEAK_ERR_WEAK_SECRET",
     COMPRESSION_NOT_ENABLED = "CPEAK_ERR_COMPRESSION_NOT_ENABLED",
+    RENDER_NOT_ENABLED = "CPEAK_ERR_RENDER_NOT_ENABLED",
     DUPLICATE_ROUTE = "CPEAK_ERR_DUPLICATE_ROUTE",
-    INVALID_ROUTE = "CPEAK_ERR_INVALID_ROUTE"
+    INVALID_ROUTE = "CPEAK_ERR_INVALID_ROUTE",
+    DUPLICATE_FALLBACK = "CPEAK_ERR_DUPLICATE_FALLBACK",
+    RENDER_FAIL = "CPEAK_ERR_RENDER_FAIL"
 }
 
 interface CompressionOptions {
@@ -29,48 +34,6 @@ interface CompressionOptions {
 }
 type ResolvedCompressionConfig = Required<CompressionOptions>;
 
-type CpeakHttpServer = Server<typeof CpeakIncomingMessage, typeof CpeakServerResponse>;
-interface CpeakOptions {
-    compression?: boolean | CompressionOptions;
-    mimeTypes?: StringMap;
-}
-type StringMap = Record<string, string>;
-interface CpeakRequest<ReqBody = any, ReqQueries = any> extends IncomingMessage {
-    params: StringMap;
-    query: ReqQueries;
-    body?: ReqBody;
-    cookies?: StringMap;
-    signedCookies?: Record<string, string | false>;
-    [key: string]: any;
-}
-interface CpeakResponse extends ServerResponse {
-    sendFile: (path: string, mime?: string) => Promise<void>;
-    status: (code: number) => CpeakResponse;
-    attachment: (filename?: string) => CpeakResponse;
-    cookie: (name: string, value: string, options?: any) => CpeakResponse;
-    redirect: (location: string) => void;
-    json: (data: any) => Promise<void>;
-    compress: (mime: string, body: Buffer | string | Readable, size?: number) => Promise<void>;
-    [key: string]: any;
-}
-type Next = (err?: any) => void;
-type Middleware<ReqBody = any, ReqParams = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse, next: Next) => void;
-type RouteMiddleware<ReqBody = any, ReqParams = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse, next: Next) => void | Promise<void>;
-type Handler<ReqBody = any, ReqParams = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse) => void | Promise<void>;
-
-declare const parseJSON: (options?: {
-    limit?: number;
-}) => (req: CpeakRequest, res: CpeakResponse, next: Next) => void;
-
-declare const serveStatic: (folderPath: string, options?: {
-    prefix?: string;
-    live?: boolean;
-}) => (req: CpeakRequest, res: CpeakResponse, next: Next) => void | Promise<void>;
-
-declare const render: () => (req: CpeakRequest, res: CpeakResponse, next: Next) => void;
-
-declare const swagger: (spec: object, prefix?: string) => (req: CpeakRequest, res: CpeakResponse, next: Next) => Promise<void> | undefined;
-
 interface PbkdfOptions {
     iterations?: number;
     keylen?: number;
@@ -111,6 +74,50 @@ interface CorsOptions {
     optionsSuccessStatus?: number;
 }
 
+type CpeakHttpServer = Server<typeof CpeakIncomingMessage, typeof CpeakServerResponse>;
+interface CpeakOptions {
+    compression?: boolean | CompressionOptions;
+    mimeTypes?: StringMap;
+}
+type StringMap = Record<string, string>;
+interface CpeakRequest<ReqBody = any, ReqQueries = any> extends IncomingMessage {
+    params: StringMap;
+    query: ReqQueries;
+    body?: ReqBody;
+    cookies?: StringMap;
+    signedCookies?: Record<string, string | false>;
+    [key: string]: any;
+}
+interface CpeakResponse<ResBody = any> extends ServerResponse {
+    sendFile: (path: string, mime?: string) => Promise<void>;
+    status: (code: number) => CpeakResponse<ResBody>;
+    attachment: (filename?: string) => CpeakResponse<ResBody>;
+    cookie: (name: string, value: string, options?: CookieOptions) => CpeakResponse<ResBody>;
+    redirect: (location: string) => void;
+    json: (data: ResBody) => Promise<void>;
+    compress: (mime: string, body: Buffer | string | Readable, size?: number) => Promise<void>;
+    render: (filePath: string, data: Record<string, unknown>, mime?: string) => Promise<void>;
+    [key: string]: any;
+}
+type Next = (err?: any) => void;
+type Middleware<ReqBody = any, ReqParams = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse, next: Next) => unknown;
+type RouteMiddleware<ReqBody = any, ReqParams = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse, next: Next) => unknown;
+type Handler<ReqBody = any, ReqParams = any, ResBody = any> = (req: CpeakRequest<ReqBody, ReqParams>, res: CpeakResponse<ResBody>) => unknown;
+
+declare const parseJSON: (options?: {
+    limit?: number;
+}) => (req: CpeakRequest, res: CpeakResponse, next: Next) => void;
+
+declare const serveStatic: (folderPath: string, options?: {
+    prefix?: string;
+    live?: boolean;
+    exclude?: string[];
+}) => (req: CpeakRequest, res: CpeakResponse, next: Next) => void | Promise<void>;
+
+declare const render: () => (req: CpeakRequest, res: CpeakResponse, next: Next) => void;
+
+declare const swagger: (spec: object, prefix?: string) => (req: CpeakRequest, res: CpeakResponse, next: Next) => Promise<void> | undefined;
+
 declare function hashPassword(password: string, options?: PbkdfOptions): Promise<string>;
 declare function verifyPassword(password: string, stored: string): Promise<boolean>;
 declare function auth(options: AuthOptions): Middleware;
@@ -134,6 +141,7 @@ declare class CpeakServerResponse extends http.ServerResponse<CpeakIncomingMessa
     attachment(filename?: string): this;
     redirect(location: string): void;
     json(data: any): Promise<void>;
+    render(): Promise<void>;
     compress(mime: string, body: Buffer | string | Readable, size?: number): Promise<void>;
 }
 declare class Cpeak {
@@ -142,6 +150,7 @@ declare class Cpeak {
     route(method: string, path: string, ...args: (RouteMiddleware | Handler)[]): void;
     beforeEach(cb: Middleware): void;
     handleErr(cb: (err: unknown, req: CpeakRequest, res: CpeakResponse) => void): void;
+    fallback(cb: Handler): void;
     listen(port: number, cb?: () => void): CpeakHttpServer;
     listen(port: number, host: string, cb?: () => void): CpeakHttpServer;
     listen(options: net.ListenOptions, cb?: () => void): CpeakHttpServer;
@@ -152,4 +161,4 @@ declare class Cpeak {
 
 declare function cpeak(options?: CpeakOptions): Cpeak;
 
-export { type AuthOptions, type CompressionOptions, type CookieOptions, type CorsOptions, Cpeak, type CpeakHttpServer, CpeakIncomingMessage, type CpeakOptions, type CpeakRequest, type CpeakResponse, CpeakServerResponse, ErrorCode, type Handler, type Middleware, type Next, type PbkdfOptions, type RouteMiddleware, auth, cookieParser, cors, cpeak as default, frameworkError, hashPassword, parseJSON, render, serveStatic, swagger, verifyPassword };
+export { type AuthOptions, type CompressionOptions, type CookieOptions, type CorsOptions, Cpeak, type CpeakHttpServer, CpeakIncomingMessage, type CpeakOptions, type CpeakRequest, type CpeakResponse, CpeakServerResponse, ErrorCode, type Handler, type Middleware, type Next, type PbkdfOptions, type RouteMiddleware, auth, cookieParser, cors, cpeak as default, frameworkError, hashPassword, isClientDisconnect, parseJSON, render, serveStatic, swagger, verifyPassword };

package/dist/index.js

@@ -1,8 +1,8 @@
 // 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/internal/compression.ts
 import zlib from "zlib";
@@ -132,18 +132,37 @@ var MIME_TYPES = {
   gif: "image/gif",
   ico: "image/x-icon",
   json: "application/json",
-  webmanifest: "application/manifest+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) {
+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";
@@ -153,8 +172,11 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   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 || {});
 
@@ -164,14 +186,14 @@ function createNode() {
 }
 var Router = class {
   #treesByMethod = /* @__PURE__ */ new Map();
-  add(method, path2, middleware, handler) {
+  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(path2);
+    const segments = splitPath(path3);
     const paramNames = [];
     let currentNode = root;
     for (let i = 0; i < segments.length; i++) {
@@ -179,7 +201,7 @@ var Router = class {
       const isLastSegment = i === segments.length - 1;
       if (segment.length > 1 && segment.startsWith("*")) {
         throw frameworkError(
-          `Invalid route "${path2}": named wildcards (e.g. "*name") are not supported. Use a plain "*" at the end of the path.`,
+          `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 */
         );
@@ -187,14 +209,14 @@ var Router = class {
       if (segment === "*") {
         if (!isLastSegment) {
           throw frameworkError(
-            `Invalid route "${path2}": "*" is only allowed as the final path segment.`,
+            `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()} ${path2}`,
+            `Duplicate route: ${method.toUpperCase()} ${path3}`,
             this.add,
             "CPEAK_ERR_DUPLICATE_ROUTE" /* DUPLICATE_ROUTE */
           );
@@ -206,7 +228,7 @@ var Router = class {
         const paramName = segment.slice(1);
         if (!paramName) {
           throw frameworkError(
-            `Invalid route "${path2}": empty parameter name.`,
+            `Invalid route "${path3}": empty parameter name.`,
             this.add,
             "CPEAK_ERR_INVALID_ROUTE" /* INVALID_ROUTE */
           );
@@ -227,7 +249,7 @@ var Router = class {
     }
     if (currentNode.handler) {
       throw frameworkError(
-        `Duplicate route: ${method.toUpperCase()} ${path2}`,
+        `Duplicate route: ${method.toUpperCase()} ${path3}`,
         this.add,
         "CPEAK_ERR_DUPLICATE_ROUTE" /* DUPLICATE_ROUTE */
       );
@@ -236,10 +258,10 @@ var Router = class {
     currentNode.middleware = middleware;
     currentNode.paramNames = paramNames;
   }
-  find(method, path2) {
+  find(method, path3) {
     const root = this.#treesByMethod.get(method.toLowerCase());
     if (!root) return null;
-    const segments = splitPath(path2);
+    const segments = splitPath(path3);
     return matchSegments(root, segments, 0, []);
   }
 };
@@ -306,9 +328,9 @@ function safeDecode(segment) {
     return segment;
   }
 }
-function splitPath(path2) {
-  if (path2 === "" || path2 === "/") return [];
-  const withoutLeadingSlash = path2.startsWith("/") ? path2.slice(1) : path2;
+function splitPath(path3) {
+  if (path3 === "" || path3 === "/") return [];
+  const withoutLeadingSlash = path3.startsWith("/") ? path3.slice(1) : path3;
   return withoutLeadingSlash.split("/");
 }
 
@@ -373,30 +395,36 @@ var serveStatic = (folderPath, options) => {
   const prefix = options?.prefix ?? "";
   const live = options?.live ?? false;
   if (live) {
-    const resolvedFolder = path.resolve(folderPath);
+    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(resolvedFolder, unprefixed);
+      const filePath = path.join(resolvedFolder2, unprefixed);
       const fileExtension = path.extname(filePath).slice(1);
       const mime = MIME_TYPES[fileExtension];
-      if (!mime || !filePath.startsWith(resolvedFolder)) return next();
+      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);
@@ -429,51 +457,126 @@ var serveStatic = (folderPath, 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 = path2.lastIndexOf(".");
-        const fileExtension = dotIndex >= 0 ? path2.slice(dotIndex + 1) : "";
+        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 "${path2}". Pass it as the third argument or register the extension via cpeak({ mimeTypes: { ${fileExtension || "ext"}: "..." } }).`,
-            res.render
+            `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 */
           );
         }
       }
-      let fileStr = await fs2.readFile(path2, "utf-8");
-      const finalStr = renderTemplate(fileStr, data);
-      if (res._compression) {
-        await compressAndSend(res, mime, finalStr, res._compression);
-        return;
+      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(
+          `Failed to render "${filePath}." Error: ${err}`,
+          res.render,
+          "CPEAK_ERR_RENDER_FAIL" /* RENDER_FAIL */,
+          void 0,
+          isClientDisconnect(err)
+        );
       }
-      res.setHeader("Content-Type", mime);
-      res.end(finalStr);
     };
     next();
   };
@@ -665,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)}`);
@@ -825,24 +928,25 @@ 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) {
-      const dotIndex = path2.lastIndexOf(".");
-      const fileExtension = dotIndex >= 0 ? path2.slice(dotIndex + 1) : "";
+      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 "${path2}". Pass it as the second argument or register the extension via cpeak({ mimeTypes: { ${fileExtension || "ext"}: "..." } }).`,
+          `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 */
         );
@@ -851,7 +955,7 @@ var CpeakServerResponse = class extends http.ServerResponse {
         await compressAndSend(
           this,
           mime,
-          createReadStream(path2),
+          createReadStream2(path3),
           this._compression,
           stat.size
         );
@@ -859,19 +963,21 @@ var CpeakServerResponse = class extends http.ServerResponse {
       }
       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)
       );
     }
   }
@@ -894,6 +1000,7 @@ var CpeakServerResponse = class extends http.ServerResponse {
   // 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);
     if (this._compression) {
       return compressAndSend(this, "application/json", body, this._compression);
@@ -902,8 +1009,16 @@ var CpeakServerResponse = class extends http.ServerResponse {
     this.end(body);
     return Promise.resolve();
   }
+  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) {
+    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.",
@@ -919,6 +1034,7 @@ var Cpeak = class {
   #router;
   #middleware;
   #handleErr;
+  #fallback;
   #compression;
   constructor(options = {}) {
     this.#server = http.createServer({
@@ -940,9 +1056,12 @@ var Cpeak = class {
         const dispatchError = async (error) => {
           if (res.headersSent) {
             req.socket?.destroy();
-            return;
+          } else {
+            res.setHeader("Connection", "close");
+          }
+          if (isClientDisconnect(error) && !error.clientDisconnect) {
+            error.clientDisconnect = true;
           }
-          res.setHeader("Connection", "close");
           try {
             await this.#handleErr?.(error, req, res);
           } catch (handlerFailure) {
@@ -995,6 +1114,13 @@ var Cpeak = class {
                 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 {
@@ -1013,13 +1139,13 @@ var Cpeak = class {
       }
     );
   }
-  route(method, path2, ...args) {
+  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();
-    this.#router.add(method, path2, middleware, cb);
+    this.#router.add(method, path3, middleware, cb);
   }
   beforeEach(cb) {
     this.#middleware.push(cb);
@@ -1027,6 +1153,17 @@ var Cpeak = class {
   handleErr(cb) {
     this.#handleErr = 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);
   }
@@ -1055,6 +1192,7 @@ export {
   cpeak as default,
   frameworkError,
   hashPassword,
+  isClientDisconnect,
   parseJSON,
   render,
   serveStatic,