shokupan 0.1.0 → 0.3.0

package/dist/router.d.ts

@@ -1,7 +1,7 @@
 import { ShokupanContext } from './context';
 import { Shokupan } from './shokupan';
 import { $appRoot, $childControllers, $childRouters, $isApplication, $isMounted, $isRouter, $mountPath, $parent, $routes } from './symbol';
-import { GuardAPISpec, MethodAPISpec, OpenAPIOptions, ProcessResult, RequestOptions, ShokupanRouteConfig, StaticServeOptions, JSXRenderer, Method, ShokupanController, ShokupanHandler, ShokupanRoute } from './types';
+import { GuardAPISpec, JSXRenderer, Method, MethodAPISpec, Middleware, OpenAPIOptions, ProcessResult, RequestOptions, RouteMetadata, ShokupanController, ShokupanHandler, ShokupanRoute, ShokupanRouteConfig, StaticServeOptions } from './types';
 type HeadersInit = Headers | Record<string, string> | [string, string][];
 export declare const RouterRegistry: Map<string, ShokupanRouter<any>>;
 export declare const ShokupanApplicationTree: {};
@@ -15,6 +15,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     private [$parent];
     [$childRouters]: ShokupanRouter<T>[];
     [$childControllers]: ShokupanController[];
+    middleware: Middleware[];
     get rootConfig(): {
         [x: string]: any;
         port?: number;
@@ -24,6 +25,12 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         enableOpenApiGen?: boolean;
         reusePort?: boolean;
         controllersOnly?: boolean;
+        enableTracing?: boolean;
+        autoBackpressureFeedback?: boolean;
+        autoBackpressureLevel?: number;
+        enableMiddlewareTracking?: boolean;
+        middlewareTrackingMaxCapacity?: number;
+        middlewareTrackingTTL?: number;
         httpLogger?: (ctx: ShokupanContext<Record<string, any>>) => void;
         logger?: {
             verbose?: boolean;
@@ -49,11 +56,50 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
             onReadTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
             onWriteTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
             onRequestTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
-        };
+        } | {
+            onError?: (error: unknown, ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+            onRequestStart?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+            onRequestEnd?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+            onResponseStart?: (ctx: ShokupanContext<Record<string, any>>, response: Response) => void | Promise<void>;
+            onResponseEnd?: (ctx: ShokupanContext<Record<string, any>>, response: Response) => void | Promise<void>;
+            beforeValidate?: (ctx: ShokupanContext<Record<string, any>>, data: any) => void | Promise<void>;
+            afterValidate?: (ctx: ShokupanContext<Record<string, any>>, data: any) => void | Promise<void>;
+            onReadTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+            onWriteTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+            onRequestTimeout?: (ctx: ShokupanContext<Record<string, any>>) => void | Promise<void>;
+        }[];
     };
     get root(): Shokupan<any>;
     [$routes]: ShokupanRoute[];
+    private trie;
+    metadata?: RouteMetadata;
     private currentGuards;
+    getComponentRegistry(): {
+        metadata: RouteMetadata;
+        middleware: {
+            name: string;
+            metadata: RouteMetadata;
+            order: number;
+            _fn: Middleware;
+        }[];
+        routes: {
+            type: string;
+            path: string;
+            method: Method;
+            metadata: RouteMetadata;
+            handlerName: string;
+            tags: any;
+            order: number;
+            _fn: ShokupanHandler<Record<string, any>>;
+        }[];
+        routers: any;
+        controllers: {
+            type: string;
+            path: any;
+            name: string;
+            metadata: any;
+        }[];
+    };
     constructor(config?: ShokupanRouteConfig);
     private isRouterInstance;
     /**
@@ -91,7 +137,8 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * Processes a request directly.
      */
     processRequest(options: RequestOptions): Promise<ProcessResult>;
-    private applyHooks;
+    private applyRouterHooks;
+    private wrapWithHooks;
     /**
      * Find a route matching the given method and path.
      * @param method HTTP method

package/dist/server-adapter-BWrEJbKL.js

@@ -0,0 +1,64 @@
+import * as http from "node:http";
+import "node:https";
+function createHttpServer() {
+  return async (options) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const request = new Request(url.toString(), {
+        method: req.method,
+        headers: req.headers,
+        body: ["GET", "HEAD"].includes(req.method) ? void 0 : new ReadableStream({
+          start(controller) {
+            req.on("data", (chunk) => controller.enqueue(chunk));
+            req.on("end", () => controller.close());
+            req.on("error", (err) => controller.error(err));
+          }
+        })
+      });
+      const response = await options.fetch(request, fauxServer);
+      res.statusCode = response.status;
+      response.headers.forEach((v, k) => res.setHeader(k, v));
+      if (response.body) {
+        const buffer = await response.arrayBuffer();
+        res.end(Buffer.from(buffer));
+      } else {
+        res.end();
+      }
+    });
+    const fauxServer = {
+      stop: () => {
+        server.close();
+        return Promise.resolve();
+      },
+      upgrade(req, options2) {
+        return false;
+      },
+      reload(options2) {
+        return fauxServer;
+      },
+      get port() {
+        const addr = server.address();
+        if (typeof addr === "object" && addr !== null) {
+          return addr.port;
+        }
+        return options.port;
+      },
+      hostname: options.hostname,
+      development: options.development,
+      pendingRequests: 0,
+      requestIP: (req) => null,
+      publish: () => 0,
+      subscriberCount: () => 0,
+      url: new URL(`http://${options.hostname}:${options.port}`)
+    };
+    return new Promise((resolve) => {
+      server.listen(options.port, options.hostname, () => {
+        resolve(fauxServer);
+      });
+    });
+  };
+}
+export {
+  createHttpServer
+};
+//# sourceMappingURL=server-adapter-BWrEJbKL.js.map

package/dist/server-adapter-BWrEJbKL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-adapter-BWrEJbKL.js","sources":["../src/plugins/server-adapter.ts"],"sourcesContent":["import type { Server } from \"bun\";\nimport * as http from \"node:http\";\nimport * as https from \"node:https\";\nimport type { ServerFactory } from \"../types\";\n\n/**\n * Creates a server factory that uses the standard Node.js `http` module.\n * @returns A ServerFactory compatible with Shokupan.\n */\nexport function createHttpServer(): ServerFactory {\n    return async (options: any): Promise<Server<any>> => {\n        const server = http.createServer(async (req, res) => {\n            const url = new URL(req.url!, `http://${req.headers.host}`);\n            const request = new Request(url.toString(), {\n                method: req.method,\n                headers: req.headers as any,\n                body: ['GET', 'HEAD'].includes(req.method!) ? undefined : new ReadableStream({\n                    start(controller) {\n                        req.on('data', chunk => controller.enqueue(chunk));\n                        req.on('end', () => controller.close());\n                        req.on('error', err => controller.error(err));\n                    }\n                }) as any\n            });\n\n            const response = await options.fetch(request, fauxServer);\n\n            res.statusCode = response.status;\n            response.headers.forEach((v, k) => res.setHeader(k, v));\n\n            if (response.body) {\n                // Optimize: Use arrayBuffer for direct conversion instead of async iteration\n                const buffer = await response.arrayBuffer();\n                res.end(Buffer.from(buffer));\n            } else {\n                res.end();\n            }\n        });\n\n        const fauxServer: Server<any> = {\n            stop: () => {\n                server.close();\n                return Promise.resolve(); // Bun.Server stop usually returns void but in type definition it might vary.\n            },\n            upgrade(req, options) {\n                return false;\n            },\n            reload(options) {\n                return fauxServer as any;\n            },\n            get port() {\n                const addr = server.address();\n                if (typeof addr === 'object' && addr !== null) {\n                    return addr.port;\n                }\n                return options.port;\n            },\n            hostname: options.hostname,\n            development: options.development,\n            pendingRequests: 0,\n            requestIP: (req) => null,\n            publish: () => 0,\n            subscriberCount: () => 0,\n            url: new URL(`http://${options.hostname}:${options.port}`)\n        } as unknown as Server<any>;\n\n        return new Promise((resolve) => {\n            server.listen(options.port, options.hostname, () => {\n                resolve(fauxServer);\n            });\n        });\n    };\n}\n\n/**\n * Creates a server factory that uses the standard Node.js `https` module.\n * @param sslOptions - Node.js HTTPS options (key, cert, etc.)\n * @returns A ServerFactory compatible with Shokupan.\n */\nexport function createHttpsServer(sslOptions: https.ServerOptions): ServerFactory {\n    return async (options: any): Promise<Server<any>> => {\n        const server = https.createServer(sslOptions, async (req, res) => {\n            const url = new URL(req.url!, `https://${req.headers.host}`);\n            const request = new Request(url.toString(), {\n                method: req.method,\n                headers: req.headers as any,\n                body: ['GET', 'HEAD'].includes(req.method!) ? undefined : new ReadableStream({\n                    start(controller) {\n                        req.on('data', chunk => controller.enqueue(chunk));\n                        req.on('end', () => controller.close());\n                        req.on('error', err => controller.error(err));\n                    }\n                }) as any\n            });\n\n            const response = await options.fetch(request, fauxServer);\n\n            res.statusCode = response.status;\n            response.headers.forEach((v, k) => res.setHeader(k, v));\n\n            if (response.body) {\n                // Optimize: Use arrayBuffer for direct conversion instead of async iteration\n                const buffer = await response.arrayBuffer();\n                res.end(Buffer.from(buffer));\n            } else {\n                res.end();\n            }\n        });\n\n        const fauxServer: Server<any> = {\n            stop: () => {\n                server.close();\n            },\n            upgrade(req, options) {\n                return false;\n            },\n            reload(options) {\n                return fauxServer as any;\n            },\n            get port() {\n                const addr = server.address();\n                if (typeof addr === 'object' && addr !== null) {\n                    return addr.port;\n                }\n                return options.port;\n            },\n            hostname: options.hostname,\n            development: options.development,\n            pendingRequests: 0,\n            requestIP: (req) => null,\n            publish: () => 0,\n            subscriberCount: () => 0,\n            url: new URL(`https://${options.hostname}:${options.port}`)\n        } as unknown as Server<any>;\n\n        return new Promise((resolve) => {\n            server.listen(options.port, options.hostname, () => {\n                resolve(fauxServer);\n            });\n        });\n    };\n}\n"],"names":["options"],"mappings":";;AASO,SAAS,mBAAkC;AAC9C,SAAO,OAAO,YAAuC;AACjD,UAAM,SAAS,KAAK,aAAa,OAAO,KAAK,QAAQ;AACjD,YAAM,MAAM,IAAI,IAAI,IAAI,KAAM,UAAU,IAAI,QAAQ,IAAI,EAAE;AAC1D,YAAM,UAAU,IAAI,QAAQ,IAAI,YAAY;AAAA,QACxC,QAAQ,IAAI;AAAA,QACZ,SAAS,IAAI;AAAA,QACb,MAAM,CAAC,OAAO,MAAM,EAAE,SAAS,IAAI,MAAO,IAAI,SAAY,IAAI,eAAe;AAAA,UACzE,MAAM,YAAY;AACd,gBAAI,GAAG,QAAQ,CAAA,UAAS,WAAW,QAAQ,KAAK,CAAC;AACjD,gBAAI,GAAG,OAAO,MAAM,WAAW,OAAO;AACtC,gBAAI,GAAG,SAAS,CAAA,QAAO,WAAW,MAAM,GAAG,CAAC;AAAA,UAChD;AAAA,QAAA,CACH;AAAA,MAAA,CACJ;AAED,YAAM,WAAW,MAAM,QAAQ,MAAM,SAAS,UAAU;AAExD,UAAI,aAAa,SAAS;AAC1B,eAAS,QAAQ,QAAQ,CAAC,GAAG,MAAM,IAAI,UAAU,GAAG,CAAC,CAAC;AAEtD,UAAI,SAAS,MAAM;AAEf,cAAM,SAAS,MAAM,SAAS,YAAA;AAC9B,YAAI,IAAI,OAAO,KAAK,MAAM,CAAC;AAAA,MAC/B,OAAO;AACH,YAAI,IAAA;AAAA,MACR;AAAA,IACJ,CAAC;AAED,UAAM,aAA0B;AAAA,MAC5B,MAAM,MAAM;AACR,eAAO,MAAA;AACP,eAAO,QAAQ,QAAA;AAAA,MACnB;AAAA,MACA,QAAQ,KAAKA,UAAS;AAClB,eAAO;AAAA,MACX;AAAA,MACA,OAAOA,UAAS;AACZ,eAAO;AAAA,MACX;AAAA,MACA,IAAI,OAAO;AACP,cAAM,OAAO,OAAO,QAAA;AACpB,YAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC3C,iBAAO,KAAK;AAAA,QAChB;AACA,eAAO,QAAQ;AAAA,MACnB;AAAA,MACA,UAAU,QAAQ;AAAA,MAClB,aAAa,QAAQ;AAAA,MACrB,iBAAiB;AAAA,MACjB,WAAW,CAAC,QAAQ;AAAA,MACpB,SAAS,MAAM;AAAA,MACf,iBAAiB,MAAM;AAAA,MACvB,KAAK,IAAI,IAAI,UAAU,QAAQ,QAAQ,IAAI,QAAQ,IAAI,EAAE;AAAA,IAAA;AAG7D,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC5B,aAAO,OAAO,QAAQ,MAAM,QAAQ,UAAU,MAAM;AAChD,gBAAQ,UAAU;AAAA,MACtB,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AACJ;"}

package/dist/server-adapter-fVKP60e0.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const http = require("node:http");
+require("node:https");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const http__namespace = /* @__PURE__ */ _interopNamespaceDefault(http);
+function createHttpServer() {
+  return async (options) => {
+    const server = http__namespace.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const request = new Request(url.toString(), {
+        method: req.method,
+        headers: req.headers,
+        body: ["GET", "HEAD"].includes(req.method) ? void 0 : new ReadableStream({
+          start(controller) {
+            req.on("data", (chunk) => controller.enqueue(chunk));
+            req.on("end", () => controller.close());
+            req.on("error", (err) => controller.error(err));
+          }
+        })
+      });
+      const response = await options.fetch(request, fauxServer);
+      res.statusCode = response.status;
+      response.headers.forEach((v, k) => res.setHeader(k, v));
+      if (response.body) {
+        const buffer = await response.arrayBuffer();
+        res.end(Buffer.from(buffer));
+      } else {
+        res.end();
+      }
+    });
+    const fauxServer = {
+      stop: () => {
+        server.close();
+        return Promise.resolve();
+      },
+      upgrade(req, options2) {
+        return false;
+      },
+      reload(options2) {
+        return fauxServer;
+      },
+      get port() {
+        const addr = server.address();
+        if (typeof addr === "object" && addr !== null) {
+          return addr.port;
+        }
+        return options.port;
+      },
+      hostname: options.hostname,
+      development: options.development,
+      pendingRequests: 0,
+      requestIP: (req) => null,
+      publish: () => 0,
+      subscriberCount: () => 0,
+      url: new URL(`http://${options.hostname}:${options.port}`)
+    };
+    return new Promise((resolve) => {
+      server.listen(options.port, options.hostname, () => {
+        resolve(fauxServer);
+      });
+    });
+  };
+}
+exports.createHttpServer = createHttpServer;
+//# sourceMappingURL=server-adapter-fVKP60e0.cjs.map

package/dist/server-adapter-fVKP60e0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-adapter-fVKP60e0.cjs","sources":["../src/plugins/server-adapter.ts"],"sourcesContent":["import type { Server } from \"bun\";\nimport * as http from \"node:http\";\nimport * as https from \"node:https\";\nimport type { ServerFactory } from \"../types\";\n\n/**\n * Creates a server factory that uses the standard Node.js `http` module.\n * @returns A ServerFactory compatible with Shokupan.\n */\nexport function createHttpServer(): ServerFactory {\n    return async (options: any): Promise<Server<any>> => {\n        const server = http.createServer(async (req, res) => {\n            const url = new URL(req.url!, `http://${req.headers.host}`);\n            const request = new Request(url.toString(), {\n                method: req.method,\n                headers: req.headers as any,\n                body: ['GET', 'HEAD'].includes(req.method!) ? undefined : new ReadableStream({\n                    start(controller) {\n                        req.on('data', chunk => controller.enqueue(chunk));\n                        req.on('end', () => controller.close());\n                        req.on('error', err => controller.error(err));\n                    }\n                }) as any\n            });\n\n            const response = await options.fetch(request, fauxServer);\n\n            res.statusCode = response.status;\n            response.headers.forEach((v, k) => res.setHeader(k, v));\n\n            if (response.body) {\n                // Optimize: Use arrayBuffer for direct conversion instead of async iteration\n                const buffer = await response.arrayBuffer();\n                res.end(Buffer.from(buffer));\n            } else {\n                res.end();\n            }\n        });\n\n        const fauxServer: Server<any> = {\n            stop: () => {\n                server.close();\n                return Promise.resolve(); // Bun.Server stop usually returns void but in type definition it might vary.\n            },\n            upgrade(req, options) {\n                return false;\n            },\n            reload(options) {\n                return fauxServer as any;\n            },\n            get port() {\n                const addr = server.address();\n                if (typeof addr === 'object' && addr !== null) {\n                    return addr.port;\n                }\n                return options.port;\n            },\n            hostname: options.hostname,\n            development: options.development,\n            pendingRequests: 0,\n            requestIP: (req) => null,\n            publish: () => 0,\n            subscriberCount: () => 0,\n            url: new URL(`http://${options.hostname}:${options.port}`)\n        } as unknown as Server<any>;\n\n        return new Promise((resolve) => {\n            server.listen(options.port, options.hostname, () => {\n                resolve(fauxServer);\n            });\n        });\n    };\n}\n\n/**\n * Creates a server factory that uses the standard Node.js `https` module.\n * @param sslOptions - Node.js HTTPS options (key, cert, etc.)\n * @returns A ServerFactory compatible with Shokupan.\n */\nexport function createHttpsServer(sslOptions: https.ServerOptions): ServerFactory {\n    return async (options: any): Promise<Server<any>> => {\n        const server = https.createServer(sslOptions, async (req, res) => {\n            const url = new URL(req.url!, `https://${req.headers.host}`);\n            const request = new Request(url.toString(), {\n                method: req.method,\n                headers: req.headers as any,\n                body: ['GET', 'HEAD'].includes(req.method!) ? undefined : new ReadableStream({\n                    start(controller) {\n                        req.on('data', chunk => controller.enqueue(chunk));\n                        req.on('end', () => controller.close());\n                        req.on('error', err => controller.error(err));\n                    }\n                }) as any\n            });\n\n            const response = await options.fetch(request, fauxServer);\n\n            res.statusCode = response.status;\n            response.headers.forEach((v, k) => res.setHeader(k, v));\n\n            if (response.body) {\n                // Optimize: Use arrayBuffer for direct conversion instead of async iteration\n                const buffer = await response.arrayBuffer();\n                res.end(Buffer.from(buffer));\n            } else {\n                res.end();\n            }\n        });\n\n        const fauxServer: Server<any> = {\n            stop: () => {\n                server.close();\n            },\n            upgrade(req, options) {\n                return false;\n            },\n            reload(options) {\n                return fauxServer as any;\n            },\n            get port() {\n                const addr = server.address();\n                if (typeof addr === 'object' && addr !== null) {\n                    return addr.port;\n                }\n                return options.port;\n            },\n            hostname: options.hostname,\n            development: options.development,\n            pendingRequests: 0,\n            requestIP: (req) => null,\n            publish: () => 0,\n            subscriberCount: () => 0,\n            url: new URL(`https://${options.hostname}:${options.port}`)\n        } as unknown as Server<any>;\n\n        return new Promise((resolve) => {\n            server.listen(options.port, options.hostname, () => {\n                resolve(fauxServer);\n            });\n        });\n    };\n}\n"],"names":["http","options"],"mappings":";;;;;;;;;;;;;;;;;;;;;AASO,SAAS,mBAAkC;AAC9C,SAAO,OAAO,YAAuC;AACjD,UAAM,SAASA,gBAAK,aAAa,OAAO,KAAK,QAAQ;AACjD,YAAM,MAAM,IAAI,IAAI,IAAI,KAAM,UAAU,IAAI,QAAQ,IAAI,EAAE;AAC1D,YAAM,UAAU,IAAI,QAAQ,IAAI,YAAY;AAAA,QACxC,QAAQ,IAAI;AAAA,QACZ,SAAS,IAAI;AAAA,QACb,MAAM,CAAC,OAAO,MAAM,EAAE,SAAS,IAAI,MAAO,IAAI,SAAY,IAAI,eAAe;AAAA,UACzE,MAAM,YAAY;AACd,gBAAI,GAAG,QAAQ,CAAA,UAAS,WAAW,QAAQ,KAAK,CAAC;AACjD,gBAAI,GAAG,OAAO,MAAM,WAAW,OAAO;AACtC,gBAAI,GAAG,SAAS,CAAA,QAAO,WAAW,MAAM,GAAG,CAAC;AAAA,UAChD;AAAA,QAAA,CACH;AAAA,MAAA,CACJ;AAED,YAAM,WAAW,MAAM,QAAQ,MAAM,SAAS,UAAU;AAExD,UAAI,aAAa,SAAS;AAC1B,eAAS,QAAQ,QAAQ,CAAC,GAAG,MAAM,IAAI,UAAU,GAAG,CAAC,CAAC;AAEtD,UAAI,SAAS,MAAM;AAEf,cAAM,SAAS,MAAM,SAAS,YAAA;AAC9B,YAAI,IAAI,OAAO,KAAK,MAAM,CAAC;AAAA,MAC/B,OAAO;AACH,YAAI,IAAA;AAAA,MACR;AAAA,IACJ,CAAC;AAED,UAAM,aAA0B;AAAA,MAC5B,MAAM,MAAM;AACR,eAAO,MAAA;AACP,eAAO,QAAQ,QAAA;AAAA,MACnB;AAAA,MACA,QAAQ,KAAKC,UAAS;AAClB,eAAO;AAAA,MACX;AAAA,MACA,OAAOA,UAAS;AACZ,eAAO;AAAA,MACX;AAAA,MACA,IAAI,OAAO;AACP,cAAM,OAAO,OAAO,QAAA;AACpB,YAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC3C,iBAAO,KAAK;AAAA,QAChB;AACA,eAAO,QAAQ;AAAA,MACnB;AAAA,MACA,UAAU,QAAQ;AAAA,MAClB,aAAa,QAAQ;AAAA,MACrB,iBAAiB;AAAA,MACjB,WAAW,CAAC,QAAQ;AAAA,MACpB,SAAS,MAAM;AAAA,MACf,iBAAiB,MAAM;AAAA,MACvB,KAAK,IAAI,IAAI,UAAU,QAAQ,QAAQ,IAAI,QAAQ,IAAI,EAAE;AAAA,IAAA;AAG7D,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC5B,aAAO,OAAO,QAAQ,MAAM,QAAQ,UAAU,MAAM;AAChD,gBAAQ,UAAU;AAAA,MACtB,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AACJ;;"}

package/dist/shokupan.d.ts

@@ -5,7 +5,10 @@ import { Middleware, ProcessResult, RequestOptions, ShokupanConfig } from './typ
 export declare class Shokupan<T = any> extends ShokupanRouter<T> {
     readonly applicationConfig: ShokupanConfig;
     openApiSpec?: any;
-    private middleware;
+    private composedMiddleware?;
+    private cpuMonitor?;
+    private hookCache;
+    private hooksInitialized;
     get logger(): {
         verbose?: boolean;
         info?: (msg: string, props: Record<string, any>) => void;
@@ -24,13 +27,19 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      * Registers a callback to be executed before the server starts listening.
      */
     onStart(callback: () => Promise<void> | void): this;
+    private specAvailableHooks;
+    /**
+     * Registers a callback to be executed when the OpenAPI spec is available.
+     * This happens after generateOpenApi() but before the server starts listening (or at least before it finishes startup if async).
+     */
+    onSpecAvailable(callback: (spec: any) => void | Promise<void>): this;
     /**
      * Starts the application server.
      *
      * @param port - The port to listen on. If not specified, the port from the configuration is used. If that is not specified, port 3000 is used.
      * @returns The server instance.
      */
-    listen(port?: number): Promise<Bun.Server>;
+    listen(port?: number): Promise<Bun.Server<any>>;
     [$dispatch](req: ShokupanRequest<T>): Promise<Response>;
     /**
      * Processes a request by wrapping the standard fetch method.
@@ -44,5 +53,9 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      * @param server - The server instance.
      * @returns The response to send.
      */
-    fetch(req: Request, server?: import('bun').Server): Promise<Response>;
+    fetch(req: Request, server?: import('bun').Server<any>): Promise<Response>;
+    private handleRequest;
+    private ensureHooksInitialized;
+    private executeHook;
+    private hasHook;
 }

package/dist/types.d.ts

@@ -5,6 +5,13 @@ import { $isRouter } from './symbol';
 export type DeepPartial<T> = T extends Function ? T : T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
+export interface RouteMetadata {
+    file: string;
+    line: number;
+    name?: string;
+    isBuiltin?: boolean;
+    pluginName?: string;
+}
 export type MethodAPISpec = OpenAPI.Operation;
 export type GuardAPISpec = DeepPartial<OpenAPI.Operation>;
 export type RouterAPISpec = OpenAPI.Operation & Pick<Required<OpenAPI.Operation>, 'tags'> & {
@@ -53,10 +60,15 @@ export declare enum RouteParamType {
     CONTEXT = "CONTEXT"
 }
 export interface ServerFactory {
-    (options: any): Server | Promise<Server>;
+    (options: any): Server<any> | Promise<Server<any>>;
 }
 export type NextFn = () => Promise<any>;
-export type Middleware = (ctx: ShokupanContext<unknown>, next: NextFn) => Promise<any> | any;
+export type Middleware = ((ctx: ShokupanContext<unknown>, next: NextFn) => Promise<any> | any) & {
+    isBuiltin?: boolean;
+    pluginName?: string;
+    metadata?: RouteMetadata;
+    order?: number;
+};
 export type JSXRenderer = (element: any, args?: unknown) => string | Promise<string>;
 export type ShokupanRouteConfig = DeepPartial<{
     name: string;
@@ -73,30 +85,87 @@ export type ShokupanRouteConfig = DeepPartial<{
     /**
      * Hooks for this route/router.
      */
-    hooks: ShokupanHooks;
+    hooks: ShokupanHooks | ShokupanHooks[];
     /**
      * Whether to enforce that only controller classes (constructors) are accepted by the router.
      */
     controllersOnly: boolean;
+    /**
+     * Whether to enable automatic backpressure based on system CPU load.
+     */
+    autoBackpressureFeedback: boolean;
+    /**
+     * The CPU usage percentage threshold (0-100) at which to start rejecting requests.
+     */
+    autoBackpressureLevel: number;
 }>;
 export type ShokupanRoute = {
+    /**
+     * HTTP method
+     */
     method: Method;
+    /**
+     * Route path
+     */
     path: string;
+    /**
+     * Compiled regex for the route
+     */
     regex: RegExp;
+    /**
+     * Route parameters
+     */
     keys: string[];
+    /**
+     * Route handler
+     */
     handler: ShokupanHandler;
+    /**
+     * Optimization: Handler with hooks baked in.
+     * Used by runtime router, while `handler` is used by OpenAPI generator.
+     */
+    bakedHandler?: ShokupanHandler;
+    /**
+     * OpenAPI spec for the route
+     */
     handlerSpec?: MethodAPISpec;
+    /**
+     * Group for the route
+     */
     group?: string;
+    /**
+     * Guards for the route
+     */
     guards?: {
+        /**
+         * Guard handler
+         */
         handler: ShokupanHandler;
+        /**
+         * Guard OpenAPI spec
+         */
         spec?: GuardAPISpec;
     }[];
+    /**
+     * Timeout for this specific route (milliseconds).
+     */
     requestTimeout?: number;
+    /**
+     * Custom JSX renderer for this route.
+     */
     renderer?: JSXRenderer;
     /**
      * Hooks from the router/route definition
      */
     hooks?: ShokupanHooks;
+    /**
+     * Source metadata
+     */
+    metadata?: RouteMetadata;
+    /**
+     * Order of the middleware
+     */
+    order?: number;
 };
 export type ShokupanConfig<T extends Record<string, any> = Record<string, any>> = DeepPartial<{
     /**
@@ -135,6 +204,41 @@ export type ShokupanConfig<T extends Record<string, any> = Record<string, any>>
      * @default false
      */
     controllersOnly: boolean;
+    /**
+     * Whether to enable OpenTelemetry tracing.
+     * @default false
+     */
+    enableTracing?: boolean;
+    /**
+     * Whether to enable automatic backpressure based on system CPU load.
+     * @default false
+     */
+    autoBackpressureFeedback?: boolean;
+    /**
+     * The CPU usage percentage threshold (0-100) at which to start rejecting requests.
+     * @default 60
+     */
+    autoBackpressureLevel?: number;
+    /**
+     * Whether to enable middleware and handler tracking.
+     * When enabled, `ctx.handlerStack` will be populated with the handlers the request has passed through.
+     * Also, `ctx.state` will be a Proxy that tracks changes made by each handler.
+     * @default false
+     */
+    enableMiddlewareTracking: boolean;
+    /**
+     * Maximum number of middleware executions to store in the datastore.
+     * Only applies when enableMiddlewareTracking is true.
+     * @default 10000
+     */
+    middlewareTrackingMaxCapacity?: number;
+    /**
+     * Time-to-live for middleware tracking entries in milliseconds.
+     * Entries older than this will be cleaned up.
+     * Only applies when enableMiddlewareTracking is true.
+     * @default 86400000 (1 day)
+     */
+    middlewareTrackingTTL?: number;
     /**
      * HTTP logger function.
      */
@@ -182,7 +286,7 @@ export type ShokupanConfig<T extends Record<string, any> = Record<string, any>>
     /**
      * Lifecycle hooks.
      */
-    hooks: ShokupanHooks<T>;
+    hooks: ShokupanHooks<T> | ShokupanHooks<T>[];
     [key: string]: any;
 }>;
 export interface RequestOptions {

package/dist/util/cpu-monitor.d.ts

@@ -0,0 +1,11 @@
+export declare class SystemCpuMonitor {
+    private readonly intervalMs;
+    private interval;
+    private lastCpus;
+    private currentUsage;
+    constructor(intervalMs?: number);
+    start(): void;
+    stop(): void;
+    getUsage(): number;
+    private update;
+}

package/dist/util/stack.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Captures the file and line number of the caller.
+ * Use skipFrames to skip helper functions in the stack trace.
+ */
+export declare function getCallerInfo(skipFrames?: number): {
+    file: string;
+    line: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "shokupan",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "description": "Shokupan is a low-lift modern web framework for Bun.",
     "author": "Andrew G. Knackstedt",
     "repository": {
@@ -20,7 +20,9 @@
     "scripts": {
         "dev": "bun --watch --inspect src/example/main.ts",
         "debug:otel": "sh scripts/debug-otel.sh",
-        "build": "vite build"
+        "build": "vite build",
+        "bench": "cd src/benchmarking && bun runner.ts",
+        "bench:advanced": "cd src/benchmarking && bun advanced-runner.ts"
     },
     "bin": {
         "shokupan": "./dist/cli.js",
@@ -58,12 +60,16 @@
         "@opentelemetry/semantic-conventions": "^1.38.0",
         "@scalar/api-reference": "^1.40.9",
         "@scalar/openapi-types": "^0.5.3",
+        "@surrealdb/node": "^2.4.0",
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
         "arctic": "^3.7.0",
         "class-transformer": "^0.5.1",
         "class-validator": "^0.14.3",
         "eta": "^4.5.0",
         "jose": "^6.1.3",
         "reflect-metadata": "^0.2.2",
+        "surrealdb": "^2.0.0-alpha.14",
         "tslib": "^2.8.1"
     },
     "devDependencies": {
@@ -72,7 +78,6 @@
         "@types/axios": "^0.9.36",
         "@types/bun": "^1.2.23",
         "@types/supertest": "^6.0.3",
-        "ajv": "^8.17.1",
         "axios": "^1.13.2",
         "get-port": "^7.1.0",
         "supertest": "^7.1.4",