@carno.js/core 1.1.2 → 1.3.0

package/dist/compression/CompressionMiddleware.js

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var CompressionMiddleware_exports = {};
+__export(CompressionMiddleware_exports, {
+  CompressionMiddleware: () => CompressionMiddleware
+});
+module.exports = __toCommonJS(CompressionMiddleware_exports);
+var import_zlib = require("zlib");
+const DEFAULT_THRESHOLD = 1024, DEFAULT_ENCODINGS = ["br", "gzip"], DEFAULT_COMPRESSIBLE_TYPES = [
+  "text/",
+  "application/json",
+  "application/javascript",
+  "application/xml",
+  "application/xhtml+xml",
+  "image/svg+xml"
+], DEFAULT_BROTLI_QUALITY = 4, DEFAULT_GZIP_LEVEL = 6;
+class CompressionMiddleware {
+  constructor(config) {
+    this.threshold = config?.threshold ?? DEFAULT_THRESHOLD, this.compressibleTypes = (config?.compressibleTypes ?? DEFAULT_COMPRESSIBLE_TYPES).map((t) => t.toLowerCase());
+    const encodings = config?.encodings ?? DEFAULT_ENCODINGS;
+    this.encodingOrder = encodings;
+    const brotliQuality = config?.brotliQuality ?? DEFAULT_BROTLI_QUALITY, gzipLevel = config?.gzipLevel ?? DEFAULT_GZIP_LEVEL;
+    this.compressors = /* @__PURE__ */ new Map();
+    for (const enc of encodings)
+      switch (enc) {
+        case "br":
+          this.compressors.set("br", (data) => {
+            const buf = (0, import_zlib.brotliCompressSync)(data, {
+              params: { [import_zlib.constants.BROTLI_PARAM_QUALITY]: brotliQuality }
+            });
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+          });
+          break;
+        case "gzip":
+          this.compressors.set(
+            "gzip",
+            (data) => Bun.gzipSync(data, { level: gzipLevel })
+          );
+          break;
+        case "deflate":
+          this.compressors.set(
+            "deflate",
+            (data) => Bun.deflateSync(data)
+          );
+          break;
+      }
+  }
+  async handle(ctx, next) {
+    const response = await next(), acceptEncoding = ctx.req.headers.get("accept-encoding");
+    if (!acceptEncoding || response.headers.get("content-encoding"))
+      return response;
+    const contentType = response.headers.get("content-type");
+    if (!contentType || !this.isCompressible(contentType))
+      return response;
+    const encoding = this.negotiateEncoding(acceptEncoding);
+    if (!encoding)
+      return response;
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength < this.threshold)
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    const compressor = this.compressors.get(encoding), bodyBytes = new Uint8Array(buffer), compressed = compressor(bodyBytes);
+    if (compressed.byteLength >= buffer.byteLength)
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    const headers = new Headers(response.headers);
+    return headers.set("Content-Encoding", encoding), headers.set("Content-Length", String(compressed.byteLength)), headers.set("Vary", this.buildVaryHeader(headers.get("Vary"))), new Response(compressed, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  isCompressible(contentType) {
+    const lower = contentType.toLowerCase();
+    for (const pattern of this.compressibleTypes)
+      if (lower.includes(pattern)) return !0;
+    return !1;
+  }
+  negotiateEncoding(acceptEncoding) {
+    const lower = acceptEncoding.toLowerCase();
+    for (const encoding of this.encodingOrder)
+      if (lower.includes(encoding)) return encoding;
+    return null;
+  }
+  buildVaryHeader(existing) {
+    return existing ? existing.toLowerCase().includes("accept-encoding") ? existing : `${existing}, Accept-Encoding` : "Accept-Encoding";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompressionMiddleware
+});

package/dist/compression/CompressionMiddleware.mjs

@@ -0,0 +1,90 @@
+import { brotliCompressSync, constants } from "zlib";
+const DEFAULT_THRESHOLD = 1024, DEFAULT_ENCODINGS = ["br", "gzip"], DEFAULT_COMPRESSIBLE_TYPES = [
+  "text/",
+  "application/json",
+  "application/javascript",
+  "application/xml",
+  "application/xhtml+xml",
+  "image/svg+xml"
+], DEFAULT_BROTLI_QUALITY = 4, DEFAULT_GZIP_LEVEL = 6;
+class CompressionMiddleware {
+  constructor(config) {
+    this.threshold = config?.threshold ?? DEFAULT_THRESHOLD, this.compressibleTypes = (config?.compressibleTypes ?? DEFAULT_COMPRESSIBLE_TYPES).map((t) => t.toLowerCase());
+    const encodings = config?.encodings ?? DEFAULT_ENCODINGS;
+    this.encodingOrder = encodings;
+    const brotliQuality = config?.brotliQuality ?? DEFAULT_BROTLI_QUALITY, gzipLevel = config?.gzipLevel ?? DEFAULT_GZIP_LEVEL;
+    this.compressors = /* @__PURE__ */ new Map();
+    for (const enc of encodings)
+      switch (enc) {
+        case "br":
+          this.compressors.set("br", (data) => {
+            const buf = brotliCompressSync(data, {
+              params: { [constants.BROTLI_PARAM_QUALITY]: brotliQuality }
+            });
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+          });
+          break;
+        case "gzip":
+          this.compressors.set(
+            "gzip",
+            (data) => Bun.gzipSync(data, { level: gzipLevel })
+          );
+          break;
+        case "deflate":
+          this.compressors.set(
+            "deflate",
+            (data) => Bun.deflateSync(data)
+          );
+          break;
+      }
+  }
+  async handle(ctx, next) {
+    const response = await next(), acceptEncoding = ctx.req.headers.get("accept-encoding");
+    if (!acceptEncoding || response.headers.get("content-encoding"))
+      return response;
+    const contentType = response.headers.get("content-type");
+    if (!contentType || !this.isCompressible(contentType))
+      return response;
+    const encoding = this.negotiateEncoding(acceptEncoding);
+    if (!encoding)
+      return response;
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength < this.threshold)
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    const compressor = this.compressors.get(encoding), bodyBytes = new Uint8Array(buffer), compressed = compressor(bodyBytes);
+    if (compressed.byteLength >= buffer.byteLength)
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    const headers = new Headers(response.headers);
+    return headers.set("Content-Encoding", encoding), headers.set("Content-Length", String(compressed.byteLength)), headers.set("Vary", this.buildVaryHeader(headers.get("Vary"))), new Response(compressed, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  isCompressible(contentType) {
+    const lower = contentType.toLowerCase();
+    for (const pattern of this.compressibleTypes)
+      if (lower.includes(pattern)) return !0;
+    return !1;
+  }
+  negotiateEncoding(acceptEncoding) {
+    const lower = acceptEncoding.toLowerCase();
+    for (const encoding of this.encodingOrder)
+      if (lower.includes(encoding)) return encoding;
+    return null;
+  }
+  buildVaryHeader(existing) {
+    return existing ? existing.toLowerCase().includes("accept-encoding") ? existing : `${existing}, Accept-Encoding` : "Accept-Encoding";
+  }
+}
+export {
+  CompressionMiddleware
+};

package/dist/index.js

@@ -18,6 +18,7 @@ __export(index_exports, {
   Body: () => import_params.Body,
   CacheService: () => import_CacheService.CacheService,
   Carno: () => import_Carno.Carno,
+  CompressionMiddleware: () => import_CompressionMiddleware.CompressionMiddleware,
   ConflictException: () => import_HttpException.ConflictException,
   Container: () => import_Container.Container,
   Context: () => import_Context.Context,
@@ -70,13 +71,14 @@ __export(index_exports, {
   withTestApp: () => import_TestHarness.withTestApp
 });
 module.exports = __toCommonJS(index_exports);
-var import_reflect_metadata = require("reflect-metadata"), import_Carno = require('./Carno.js'), import_Context = require('./context/Context.js'), import_Controller = require('./decorators/Controller.js'), import_methods = require('./decorators/methods.js'), import_params = require('./decorators/params.js'), import_Middleware = require('./decorators/Middleware.js'), import_Service = require('./decorators/Service.js'), import_Inject = require('./decorators/Inject.js'), import_Container = require('./container/Container.js'), import_RadixRouter = require('./router/RadixRouter.js'), import_CorsHandler = require('./cors/CorsHandler.js'), import_ValidatorAdapter = require('./validation/ValidatorAdapter.js'), import_ZodAdapter = require('./validation/ZodAdapter.js'), import_ValibotAdapter = require('./validation/ValibotAdapter.js'), import_HttpException = require('./exceptions/HttpException.js'), import_Lifecycle = require('./events/Lifecycle.js'), import_CacheService = require('./cache/CacheService.js'), import_MemoryDriver = require('./cache/MemoryDriver.js'), import_RedisDriver = require('./cache/RedisDriver.js'), import_TestHarness = require('./testing/TestHarness.js'), import_Metadata = require('./utils/Metadata.js');
+var import_reflect_metadata = require("reflect-metadata"), import_Carno = require('./Carno.js'), import_Context = require('./context/Context.js'), import_Controller = require('./decorators/Controller.js'), import_methods = require('./decorators/methods.js'), import_params = require('./decorators/params.js'), import_Middleware = require('./decorators/Middleware.js'), import_Service = require('./decorators/Service.js'), import_Inject = require('./decorators/Inject.js'), import_Container = require('./container/Container.js'), import_RadixRouter = require('./router/RadixRouter.js'), import_CorsHandler = require('./cors/CorsHandler.js'), import_CompressionMiddleware = require('./compression/CompressionMiddleware.js'), import_ValidatorAdapter = require('./validation/ValidatorAdapter.js'), import_ZodAdapter = require('./validation/ZodAdapter.js'), import_ValibotAdapter = require('./validation/ValibotAdapter.js'), import_HttpException = require('./exceptions/HttpException.js'), import_Lifecycle = require('./events/Lifecycle.js'), import_CacheService = require('./cache/CacheService.js'), import_MemoryDriver = require('./cache/MemoryDriver.js'), import_RedisDriver = require('./cache/RedisDriver.js'), import_TestHarness = require('./testing/TestHarness.js'), import_Metadata = require('./utils/Metadata.js');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BadRequestException,
   Body,
   CacheService,
   Carno,
+  CompressionMiddleware,
   ConflictException,
   Container,
   Context,

package/dist/index.mjs

@@ -10,6 +10,7 @@ import { Inject } from "./decorators/Inject.mjs";
 import { Container, Scope } from "./container/Container.mjs";
 import { RadixRouter } from "./router/RadixRouter.mjs";
 import { CorsHandler } from "./cors/CorsHandler.mjs";
+import { CompressionMiddleware } from "./compression/CompressionMiddleware.mjs";
 import { Schema, getSchema, VALIDATION_SCHEMA } from "./validation/ValidatorAdapter.mjs";
 import { ZodAdapter, ValidationException } from "./validation/ZodAdapter.mjs";
 import { ValibotAdapter } from "./validation/ValibotAdapter.mjs";
@@ -42,6 +43,7 @@ export {
   Body,
   CacheService,
   Carno,
+  CompressionMiddleware,
   ConflictException,
   Container,
   Context,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@carno.js/core",
-    "version": "1.1.2",
+    "version": "1.3.0",
     "description": "Ultra-fast HTTP framework with aggressive AOT/JIT compilation",
     "main": "src/index.ts",
     "types": "src/index.ts",
@@ -21,5 +21,5 @@
         "esbuild-fix-imports-plugin": "^1.0.23",
         "tsup": "^8.5.1"
     },
-    "gitHead": "4239bdaf06a9c741e69639e996d91b8852ae3cd1"
+    "gitHead": "5e5c0a508a88a08d5af99081777a48e2dae539fe"
 }

package/src/Carno.ts

@@ -23,7 +23,7 @@ export type MiddlewareHandler = (ctx: Context) => Response | void | Promise<Resp
 
 export type MiddlewareClass = new (...args: any[]) => CarnoMiddleware;
 
-export type MiddlewareEntry = MiddlewareHandler | MiddlewareClass;
+export type MiddlewareEntry = MiddlewareHandler | MiddlewareClass | CarnoMiddleware;
 
 type ResolvedMiddleware =
     | { kind: 'function'; handler: MiddlewareHandler }
@@ -84,6 +84,10 @@ export class Carno {
     private validator: ValidatorAdapter | null = null;
     private server: any;
 
+    // WebSocket support
+    _wsHandlerBuilder: ((container: Container) => any) | null = null;
+    _wsUpgradePaths: Set<string> = new Set();
+
     // Cached lifecycle event flags - checked once at startup
     private hasInitHooks = false;
     private hasBootHooks = false;
@@ -117,7 +121,7 @@ export class Carno {
 
     /**
      * Use a Carno plugin.
-     * Imports controllers, services, middlewares, and routes from another Carno instance.
+     * Imports controllers, services, middlewares, routes, and WebSocket config from another Carno instance.
      */
     use(plugin: Carno): this {
         // Import controllers from plugin
@@ -165,9 +169,36 @@ export class Carno {
             }
         }
 
+        // Import WebSocket handler builder and upgrade paths
+        if (plugin._wsHandlerBuilder) {
+            this._wsHandlerBuilder = plugin._wsHandlerBuilder;
+            for (const path of plugin._wsUpgradePaths) {
+                this._wsUpgradePaths.add(path);
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     * Register a WebSocket handler builder and the upgrade paths.
+     * Used internally by @carno.js/websocket plugin.
+     */
+    wsHandler(builder: (container: Container) => any, upgradePaths: string[]): this {
+        this._wsHandlerBuilder = builder;
+        for (const path of upgradePaths) {
+            this._wsUpgradePaths.add(path);
+        }
         return this;
     }
 
+    /**
+     * Returns the underlying Bun server instance (available after listen()).
+     */
+    getServer(): any {
+        return this.server;
+    }
+
     private findServiceInPlugin(plugin: Carno, exported: any): any | undefined {
         return plugin._services.find(
             s => this.getServiceToken(s) === this.getServiceToken(exported)
@@ -284,6 +315,32 @@ export class Carno {
             }
         };
 
+        // Wire in WebSocket support if a handler builder was registered
+        if (this._wsHandlerBuilder && this._wsUpgradePaths.size > 0) {
+            config.websocket = this._wsHandlerBuilder(this.container);
+
+            const upgradePaths = this._wsUpgradePaths;
+            const fallback = this.handleNotFound.bind(this);
+
+            config.fetch = (req: Request, server: any) => {
+                const pathname = new URL(req.url).pathname;
+
+                if (upgradePaths.has(pathname)) {
+                    const upgraded = server.upgrade(req, {
+                        data: {
+                            id: crypto.randomUUID(),
+                            namespace: pathname,
+                        },
+                    });
+
+                    if (upgraded) return;
+                    return new Response('WebSocket upgrade failed', { status: 400 });
+                }
+
+                return fallback(req);
+            };
+        }
+
         this.server = Bun.serve(config);
 
         // Execute BOOT hooks after server is ready
@@ -313,6 +370,12 @@ export class Carno {
             useValue: this.container
         });
 
+        // Register this Carno instance so services can inject it (e.g. RoomManager)
+        this.container.register({
+            token: Carno,
+            useValue: this
+        });
+
         // Always register CacheService (Memory by default)
         const cacheConfig = typeof this.config.cache === 'object' ? this.config.cache : {};
         this.container.register({
@@ -539,6 +602,11 @@ export class Carno {
             return { kind: 'class', instance };
         }
 
+        // Pre-built instance with handle method
+        if (typeof middleware === 'object' && middleware !== null && 'handle' in middleware) {
+            return { kind: 'class', instance: middleware as CarnoMiddleware };
+        }
+
         // Already a function
         return { kind: 'function', handler: middleware as MiddlewareHandler };
     }
@@ -572,9 +640,14 @@ export class Carno {
             } else {
                 chain = async (ctx: Context) => {
                     let response: Response | undefined;
-                    await mw.instance.handle(ctx, async () => {
+                    const result = await mw.instance.handle(ctx, async () => {
                         response = await nextLayer(ctx);
+                        return response;
                     });
+                    // If middleware returned a Response, use it (enables response transformation)
+                    if (result instanceof Response) {
+                        return result;
+                    }
                     return response ?? new Response(null, { status: 200 });
                 };
             }

package/src/compression/CompressionMiddleware.ts

@@ -0,0 +1,221 @@
+import type { Context } from '../context/Context';
+import type { CarnoMiddleware, CarnoClosure } from '../middleware/CarnoMiddleware';
+import { brotliCompressSync, constants } from 'zlib';
+
+type GzipLevel = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type BrotliQuality = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+
+/**
+ * Compression configuration.
+ */
+export interface CompressionConfig {
+  /**
+   * Minimum response size in bytes to trigger compression.
+   * Responses smaller than this are sent uncompressed.
+   * @default 1024
+   */
+  threshold?: number;
+
+  /**
+   * Preferred encoding order. Client's Accept-Encoding is matched against this list.
+   * @default ['br', 'gzip']
+   */
+  encodings?: ('br' | 'gzip' | 'deflate')[];
+
+  /**
+   * Content-Type patterns that should be compressed.
+   * Matched using string includes (case-insensitive).
+   * @default ['text/', 'application/json', 'application/javascript', 'application/xml', 'image/svg+xml']
+   */
+  compressibleTypes?: string[];
+
+  /**
+   * Brotli compression quality (0-11). Higher = better compression, slower.
+   * @default 4
+   */
+  brotliQuality?: BrotliQuality;
+
+  /**
+   * Gzip compression level (-1 to 9). Higher = better compression, slower.
+   * @default 6
+   */
+  gzipLevel?: GzipLevel;
+}
+
+const DEFAULT_THRESHOLD = 1024;
+const DEFAULT_ENCODINGS: ('br' | 'gzip' | 'deflate')[] = ['br', 'gzip'];
+const DEFAULT_COMPRESSIBLE_TYPES = [
+  'text/',
+  'application/json',
+  'application/javascript',
+  'application/xml',
+  'application/xhtml+xml',
+  'image/svg+xml',
+];
+const DEFAULT_BROTLI_QUALITY: BrotliQuality = 4;
+const DEFAULT_GZIP_LEVEL: GzipLevel = 6;
+
+type CompressFn = (data: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+
+/**
+ * Compression middleware for Carno.
+ *
+ * Supports **gzip**, **brotli** and **deflate** using Bun's native APIs
+ * (zero external dependencies).
+ *
+ * Does NOT touch the hot path — runs entirely as a middleware in the
+ * onion chain. Routes without middleware remain untouched.
+ *
+ * All configuration is resolved once at construction time (startup)
+ * so the per-request overhead is minimal: one header check +
+ * one compression call for eligible responses.
+ *
+ * @example
+ * ```ts
+ * import { Carno, CompressionMiddleware } from '@carno.js/core';
+ *
+ * const app = new Carno()
+ *   .middlewares([new CompressionMiddleware()])
+ *   .controllers([MyController]);
+ *
+ * app.listen(3000);
+ * ```
+ *
+ * @example Custom configuration:
+ * ```ts
+ * new CompressionMiddleware({
+ *   threshold: 512,
+ *   encodings: ['gzip'],
+ *   gzipLevel: 9,
+ * })
+ * ```
+ */
+export class CompressionMiddleware implements CarnoMiddleware {
+  private readonly threshold: number;
+  private readonly compressibleTypes: string[];
+  private readonly compressors: Map<string, CompressFn>;
+  private readonly encodingOrder: string[];
+
+  constructor(config?: CompressionConfig) {
+    this.threshold = config?.threshold ?? DEFAULT_THRESHOLD;
+    this.compressibleTypes = (config?.compressibleTypes ?? DEFAULT_COMPRESSIBLE_TYPES)
+      .map(t => t.toLowerCase());
+
+    const encodings = config?.encodings ?? DEFAULT_ENCODINGS;
+    this.encodingOrder = encodings;
+
+    const brotliQuality = config?.brotliQuality ?? DEFAULT_BROTLI_QUALITY;
+    const gzipLevel = config?.gzipLevel ?? DEFAULT_GZIP_LEVEL;
+
+    // Pre-build compressor functions at construction time (startup only)
+    this.compressors = new Map();
+
+    for (const enc of encodings) {
+      switch (enc) {
+        case 'br':
+          this.compressors.set('br', (data: Uint8Array<ArrayBuffer>) => {
+            const buf = brotliCompressSync(data, {
+              params: { [constants.BROTLI_PARAM_QUALITY]: brotliQuality },
+            });
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+          });
+          break;
+        case 'gzip':
+          this.compressors.set('gzip', (data: Uint8Array<ArrayBuffer>) =>
+            Bun.gzipSync(data, { level: gzipLevel }),
+          );
+          break;
+        case 'deflate':
+          this.compressors.set('deflate', (data: Uint8Array<ArrayBuffer>) =>
+            Bun.deflateSync(data),
+          );
+          break;
+      }
+    }
+  }
+
+  async handle(ctx: Context, next: CarnoClosure): Promise<Response | void> {
+    const response = await next();
+
+    // Fast-exit: no Accept-Encoding header
+    const acceptEncoding = ctx.req.headers.get('accept-encoding');
+    if (!acceptEncoding) {
+      return response;
+    }
+
+    // Already encoded — skip
+    if (response.headers.get('content-encoding')) {
+      return response;
+    }
+
+    // Non-compressible content type — skip
+    const contentType = response.headers.get('content-type');
+    if (!contentType || !this.isCompressible(contentType)) {
+      return response;
+    }
+
+    // Negotiate encoding
+    const encoding = this.negotiateEncoding(acceptEncoding);
+    if (!encoding) {
+      return response;
+    }
+
+    // Read body bytes (consumes the response body)
+    const buffer = await response.arrayBuffer();
+
+    // Below threshold — reconstruct original response
+    if (buffer.byteLength < this.threshold) {
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+
+    const compressor = this.compressors.get(encoding)!;
+    const bodyBytes = new Uint8Array(buffer);
+    const compressed = compressor(bodyBytes);
+
+    // If compressed is not smaller, return original uncompressed
+    if (compressed.byteLength >= buffer.byteLength) {
+      return new Response(buffer, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+
+    const headers = new Headers(response.headers);
+    headers.set('Content-Encoding', encoding);
+    headers.set('Content-Length', String(compressed.byteLength));
+    headers.set('Vary', this.buildVaryHeader(headers.get('Vary')));
+
+    return new Response(compressed, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+
+  private isCompressible(contentType: string): boolean {
+    const lower = contentType.toLowerCase();
+    for (const pattern of this.compressibleTypes) {
+      if (lower.includes(pattern)) return true;
+    }
+    return false;
+  }
+
+  private negotiateEncoding(acceptEncoding: string): string | null {
+    const lower = acceptEncoding.toLowerCase();
+    for (const encoding of this.encodingOrder) {
+      if (lower.includes(encoding)) return encoding;
+    }
+    return null;
+  }
+
+  private buildVaryHeader(existing: string | null): string {
+    if (!existing) return 'Accept-Encoding';
+    if (existing.toLowerCase().includes('accept-encoding')) return existing;
+    return `${existing}, Accept-Encoding`;
+  }
+}

package/src/index.ts

@@ -51,6 +51,10 @@ export type { RouteMatch } from './router/RadixRouter';
 export { CorsHandler } from './cors/CorsHandler';
 export type { CorsConfig, CorsOrigin } from './cors/CorsHandler';
 
+// Compression
+export { CompressionMiddleware } from './compression/CompressionMiddleware';
+export type { CompressionConfig } from './compression/CompressionMiddleware';
+
 // Validation
 export type { ValidatorAdapter, ValidationResult, ValidationError, ValidationConfig } from './validation/ValidatorAdapter';
 export { Schema, getSchema, VALIDATION_SCHEMA } from './validation/ValidatorAdapter';

package/src/middleware/CarnoMiddleware.ts

@@ -2,13 +2,19 @@ import type { Context } from '../context/Context';
 
 /**
  * Closure function to call the next middleware in the chain.
+ * Returns the Response produced by the next layer, allowing
+ * middlewares to inspect or transform it.
  */
-export type CarnoClosure = () => void | Promise<void>;
+export type CarnoClosure = () => Promise<Response>;
 
 /**
  * Interface for onion-style middleware.
  * Middleware must call next() to continue the chain.
+ *
+ * Returning a Response from handle() replaces the response
+ * produced by the downstream chain (useful for response transformers
+ * like compression).
  */
 export interface CarnoMiddleware {
-  handle(ctx: Context, next: CarnoClosure): void | Promise<void>;
+  handle(ctx: Context, next: CarnoClosure): void | Response | Promise<void | Response>;
 }